fix and add readme

Author: purp1le

package-lock.json

@@ -15,6 +15,7 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
+    "@ton.org/func-js": "^0.1.3",
     "@types/uuid": "^8.3.4",
     "bn.js": "^5.2.1",
     "chai": "^4.3.6",

package.json

@@ -4,6 +4,8 @@ import { SmartContract } from 'ton-contract-executor'
 import { encodeRaffleStorage, RaffleStorage } from './raffle.storage'
 import * as fs from 'fs'
 import BN from 'bn.js'
+import { compileFunc } from "../../utils/compileFunc";
+import { RaffleSource } from './raffle.source'
 
 
 
@@ -21,12 +23,15 @@ type StateResponse = {
     leftCoinsGot: BN,
     rightCoinsGot: BN,
     coinsForNft: BN,
-    leftNfts: Map<string, boolean> | null,
-    rightNfts: Map<string, boolean> | null,
+    nfts: Map<string, number> | null,
     raffledNfts: Map<string, boolean> | null
 }
 
-function DictToMap (slice : Slice): boolean {
+function DictToMapN (slice : Slice): number {
+    return slice.readUint(4).toNumber().valueOf()
+}
+
+function DictToMapB (slice: Slice): boolean {
     return slice.readBit()
 }
 
@@ -47,23 +52,18 @@ export class RaffleLocal {
         const [ state, rightNftsCount, rightNftsReceived, leftNftsCount,
             leftNftsReceived, leftUser, rightUser, superUser, leftCommission,
             rightCommission, leftCoinsGot, rightCoinsGot,
-            coinsForNft, leftNfts, rightNfts, raffledNfts ] = res.result as [BN, BN,
+            coinsForNft, nfts, raffledNfts ] = res.result as [BN, BN,
             BN, BN,
             BN, Slice, Slice, Slice, BN, BN, BN, BN, BN, Cell, Cell, Cell]
-        const leftMap = leftNfts ? parseDict<boolean>(
-            leftNfts.beginParse(),
-            256,
-            DictToMap
-        ) : null
-        const rightMap = rightNfts ? parseDict<boolean>(
-            rightNfts.beginParse(),
+        const nftMap = nfts ? parseDict<number>(
+            nfts.beginParse(),
             256,
-            DictToMap
+            DictToMapN
         ) : null
         const raffledMap = raffledNfts ? parseDict<boolean>(
             raffledNfts.beginParse(),
             256,
-            DictToMap
+            DictToMapB
         ) : null
         return {
             state: state ? state.toNumber() : 0,
@@ -79,21 +79,15 @@ export class RaffleLocal {
             leftCoinsGot: leftCoinsGot,
             rightCoinsGot: rightCoinsGot,
             coinsForNft: coinsForNft,
-            leftNfts: leftMap,
-            rightNfts: rightMap,
+            nfts: nftMap,
             raffledNfts: raffledMap
         }
     }
 
-    static bocFileToTCell (filename: string): Cell {
-        const file = fs.readFileSync(filename)
-        return Cell.fromBoc(file)[0]
-    }
-
     static async createFromConfig(raffleStorage: RaffleStorage) {
-        const code = RaffleLocal.bocFileToTCell('./packages/contracts/sources/nft-raffle/code.boc')
+        const code = await compileFunc(RaffleSource)
         const data = encodeRaffleStorage(raffleStorage)
-        const smc = await SmartContract.fromCell(code, data)
+        const smc = await SmartContract.fromCell(code.cell, data)
 
         const address = contractAddress({
             workchain: 0,

packages/contracts/nft-raffle/main.test.ts

@@ -3,47 +3,50 @@ import BN from 'bn.js'
 import { SmartContract } from 'ton-contract-executor'
 import { getRandSigner } from './raffle.signers'
 
-class queries {
-    public static nftOwnerAssigned (
-        queryId: BN,
-        prevOwner: Address,
-        op: number = 0x05138d91
-    ): Cell {
-        const msg = new Builder()
-            .storeUint(op, 32)
-            .storeUint(queryId, 64)
-            .storeAddress(prevOwner)
-            .storeBit(0)
+export const OperationCodes = {
+    ownershipAssigned: 0x05138d91,
+    cancel: 2001,
+    addCoins: 2002,
+    maintain: 2003,
+    sendAgain: 2004,
+}
 
-        return msg.endCell()
-    }
+export const Queries = {
+    nftOwnerAssigned: (params: { queryId?: number, prevOwner: Address}) => {
+        const msgBody = new Cell()
+        msgBody.bits.writeUint(OperationCodes.ownershipAssigned, 32)
+        msgBody.bits.writeUint(params.queryId || 0, 64)
+        msgBody.bits.writeAddress(params.prevOwner)
 
-    public static cancel (): Cell {
+        return msgBody
+    },
+    cancel: () => {
         const msg = new Builder()
-            .storeUint(2001, 32)
-
+            .storeUint(OperationCodes.cancel, 32)
         return msg.endCell()
-    }
-
-    public static addCoins (): Cell {
+    },
+    addCoins: () => {
         const msg = new Builder()
-            .storeUint(2002, 32)
+            .storeUint(OperationCodes.addCoins, 32)
         return msg.endCell()
-    }
-
-    public static sendTrans (): Cell {
+    },
+    sendTrans: () => {
         const body = new Builder()
             .storeUint(0x18, 6)
             .storeAddress(getRandSigner())
             .storeCoins(toNano(0.1))
             .storeUint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1)
         const msg = new Builder()
-            .storeUint(2003, 32)
+            .storeUint(OperationCodes.maintain, 32)
             .storeRef(body.endCell())
             .storeUint(0, 8)
             .endCell()
         return msg
+    },
+    sendAgain: () => {
+        const msg = new Builder()
+            .storeUint(OperationCodes.sendAgain, 32)
+            .endCell()
+        return msg
     }
 }
-
-export { queries }

packages/contracts/nft-raffle/raffle.local.ts

@@ -0,0 +1,12 @@
+import { combineFunc } from "../../utils/combineFunc";
+
+
+export const RaffleSource = combineFunc(__dirname, [
+    "../sources/stdlib.fc",
+    "../sources/nft-raffle/struct/constants.func",
+    "../sources/nft-raffle/struct/storage.func",
+    "../sources/nft-raffle/struct/utils.func",
+    "../sources/nft-raffle/struct/handles.func",
+    "../sources/nft-raffle/struct/get-methods.func",
+    '../sources/nft-raffle/main.func',
+])

packages/contracts/nft-raffle/raffle.queries.ts

@@ -23,16 +23,16 @@ interface CommissionSlice {
     leftCommission: BN
     rightCommission: BN
     coinsForNft: BN
+    coinsForCommission: BN
 }
 
-interface NFTItem {
+export interface NFTItem {
     addr: Address
-    received: boolean
+    received: number
 }
 
 interface DictSlice {
-    leftNfts: NFTItem[]
-    rightNfts: NFTItem[]
+    nfts: NFTItem[]
 }
 
 export interface RaffleStorage {
@@ -64,26 +64,18 @@ function encodeRaffleStorage
         .storeCoins(new BN(0))
         .storeCoins(new BN(0))
         .storeCoins(raffleStorage.commissionSlice.coinsForNft)
+        .storeCoins(raffleStorage.commissionSlice.coinsForCommission)
         .endCell()
-    const leftNfts = new DictBuilder(256)
-    if (raffleStorage.dictSlice.leftNfts.length > 0) {
-        for (let i = 0; i < raffleStorage.dictSlice.leftNfts.length; i += 1) {
-            const bitCell = new Cell()
-            bitCell.bits.writeBit(raffleStorage.dictSlice.leftNfts[i].received)
-            leftNfts.storeCell(new BN(raffleStorage.dictSlice.leftNfts[i].addr.hash), bitCell)
-        }
-    }
-    const rightNfts = new DictBuilder(256)
-    if (raffleStorage.dictSlice.rightNfts.length > 0) {
-        for (let i = 0; i < raffleStorage.dictSlice.rightNfts.length; i += 1) {
-            const bitCell = new Cell()
-            bitCell.bits.writeBit(raffleStorage.dictSlice.rightNfts[i].received)
-            rightNfts.storeCell(new BN(raffleStorage.dictSlice.rightNfts[i].addr.hash), bitCell)
+    const nfts = new DictBuilder(256)
+    if (raffleStorage.dictSlice.nfts.length > 0) {
+        for (let i = 0; i < raffleStorage.dictSlice.nfts.length; i += 1) {
+            const value = new Cell()
+            value.bits.writeUint(raffleStorage.dictSlice.nfts[i].received, 4)
+            nfts.storeCell(new BN(raffleStorage.dictSlice.nfts[i].addr.hash), value)
         }
     }
     const dictCell = new Builder()
-        .storeDict(leftNfts.endCell())
-        .storeDict(rightNfts.endCell())
+        .storeDict(nfts.endCell())
         .storeDict(new DictBuilder(256).endDict())
     const storageCell = new Builder()
         .storeRef(stateCell)

packages/contracts/nft-raffle/raffle.source.ts

@@ -1,9 +1,3 @@
-#include "../stdlib.fc";
-#include "struct/constants.func";
-#include "struct/storage.func";
-#include "struct/utils.func";
-#include "struct/handles.func";
-#include "struct/get-methods.func";
 
 
 {-
@@ -49,6 +43,11 @@
         return ();
     }
 
+    if (op == op::send_again()) {
+        handle::send_again(msg_value);
+        return ();
+    }
+
     if (op == op::maintain()) {
         handle::maintain(sender_addr, in_msg_body);
         return();

packages/contracts/nft-raffle/raffle.storage.ts

@@ -3,16 +3,19 @@ int state::canceled()   asm "2 PUSHINT";
 int state::completed()  asm "3 PUSHINT";
 
 int min_tons_for_storage() asm "1000000 PUSHINT"; ;; 0,001 TON
+int min_tons_for_operation() asm "10000000 PUSHINT"; ;; 0,01 TON
 
 int op::transfer()              asm "0x5fcc3d14 PUSHINT";
 int op::ownership_assigned()    asm "0x05138d91 PUSHINT";
 int op::cancel()                asm "2001 PUSHINT";
 int op::add_coins()             asm "2002 PUSHINT";
 int op::maintain()              asm "2003 PUSHINT";
+int op::send_again()            asm "2004 PUSHINT";
 
 slice msg::canceled() asm "<b 124 word NFT raffle canceled| $, b> <s PUSHSLICE";
 slice msg::commission() asm "<b 124 word NFT raffle commission| $, b> <s PUSHSLICE";
 
 
 int err::state() asm "1001 PUSHINT";
 int err::wrong_addr() asm "1002 PUSHINT";
+int err::coins() asm "1003 PUSHINT";

packages/contracts/sources/nft-raffle/main.func

@@ -3,5 +3,5 @@ _ raffle_state() method_id {
     return (db::state, db::right_nfts_count, db::right_nfts_received, db::left_nfts_count,
     db::left_nfts_received, db::left_user, db::right_user, db::super_user, db::left_commission,
     db::right_commission, db::left_coins_got, db::right_coins_got, db::coins_for_nft,
-    db::left_nfts, db::right_nfts, db::raffled_nfts);
+    db::nfts, db::raffled_nfts);
 }

packages/contracts/sources/nft-raffle/struct/constants.func

@@ -1,6 +1,6 @@
 () handle::raffle() impure inline_ref {
     db::state = state::completed();
-    db::raffled_nfts = utils::raffle_nfts(db::raffled_nfts, db::left_nfts, db::right_nfts);
+    db::raffled_nfts = utils::raffle_nfts(db::raffled_nfts, db::nfts);
     utils::send_raffled_nfts(db::raffled_nfts, db::coins_for_nft);
     raw_reserve(min_tons_for_storage(), 0);
     utils::send_tons(db::super_user, 0, msg::commission(), 130);
@@ -16,28 +16,27 @@
 }
 
 () handle::receive_nft(slice nft_addr, int msg_value, slice in_msg_body) impure inline_ref {
-    int extra_coins = msg_value - db::coins_for_nft;
-    
-    if ((extra_coins < 0) | (db::state != state::active())) {
+    int extra_coins = msg_value - db::coins_for_nft - db::coins_for_commission;
+
+    if ((extra_coins < min_tons_for_operation()) | (db::state != state::active())) {
         handle::return_nft(nft_addr,in_msg_body);
         return ();
     }
     (_, int addr) = parse_std_addr(nft_addr);
-    (cell left_nfts, int left_succes) = db::left_nfts.utils::add_nft(addr);
-    (cell right_nfts, int right_success) = db::right_nfts.utils::add_nft(addr);
+    (cell nfts, int left_success, int right_success) = db::nfts.utils::add_nft(addr);
 
-    if (~ (left_succes | right_success)) {
+    if (~ (left_success | right_success)) {
         handle::return_nft(nft_addr,in_msg_body);
         return ();
     }
-    db::left_nfts = left_nfts;
-    db::right_nfts = right_nfts;
-    if (left_succes) {
+    db::nfts = nfts;
+    if (left_success) {
         db::left_nfts_received += 1;
-        db::left_coins_got += msg_value;
-    } else {
+        db::left_coins_got += (db::coins_for_nft + db::coins_for_commission);
+    } 
+    if(right_success) {
         db::right_nfts_received += 1;
-        db::right_coins_got += msg_value;
+        db::right_coins_got += (db::coins_for_nft + db::coins_for_commission);
     }
     if (utils::check_conditions()) {
         handle::raffle();
@@ -49,8 +48,7 @@
     throw_if(err::state(), db::state != state::active());
     throw_if(err::state(), utils::check_conditions());
     db::state = state::canceled();
-    db::left_nfts.utils::send_nfts(db::coins_for_nft, db::left_user);
-    db::right_nfts.utils::send_nfts(db::coins_for_nft, db::right_user);
+    db::nfts.utils::send_nfts(db::coins_for_nft, db::left_user, db::right_user);
 
     raw_reserve(min_tons_for_storage(), 0);
 
@@ -75,6 +73,15 @@
 }
 
 () handle::maintain(slice sender_addr, slice in_msg_body) impure inline_ref {
+    throw_if(err::state(), db::state == state::active());
     throw_unless(err::wrong_addr(), equal_slices(sender_addr, db::super_user));
     send_raw_message(in_msg_body~load_ref(), in_msg_body~load_uint(8));
+}
+
+() handle::send_again(int msg_value) impure inline_ref {
+    throw_if(err::state(), db::state != state::completed());
+    int need_coins = (db::left_nfts_count + db::right_nfts_count) * db::coins_for_nft;
+    throw_if(err::coins(), msg_value < need_coins);
+    int coins_for_nft = msg_value / (db::left_nfts_count + db::right_nfts_count);
+    utils::send_raffled_nfts(db::raffled_nfts, coins_for_nft);
 }