@simplenft/api 0.1.0

package/contracts/packages/misc/distributor_messages.tact

@@ -0,0 +1,154 @@
+message TransferJettonDistributor {
+    tokenJettonAddress: Address;
+    tokenJettonAmount: Int as coins;
+}
+
+message JettonBurnDistributor {
+    tokenJettonAddress: Address;
+    tokenJettonAmount: Int as coins;
+}
+
+message(0x595f07bc) JettonBurn {
+    queryId: Int as uint64;
+    amount: Int as coins;
+    responseDestination: Address?;
+    customPayload: Cell? = null;
+}
+
+message NativeSwapDistributor {
+    poolAddress: Address;
+    amount: Int as coins;
+    limit: Int as coins;
+}
+
+message(0xea06185d) NativeSwap {
+    // Unique identifier used to trace transactions across multiple contracts
+    // Defaults to 0, which means we don't mark messages to trace their chains
+    queryId: Int as uint64 = 0;
+
+    // Toncoin amount for the swap
+    amount: Int as coins;
+
+    // Inlined fields of SwapStep Struct
+    poolAddress: Address;
+    kind: Int as uint1 = 0;
+    limit: Int as coins = 0;
+    nextStep: SwapStep? = null;
+
+    // Set of parameters relevant for the whole swap
+    swapParams: SwapParams;
+}
+
+message JettonSwapDistributor{
+    poolAddress: Address;
+    vaultAddress: Address;
+    tokenJettonAddress: Address;
+    tokenJettonAmount: Int as coins;
+    limit: Int as coins;
+}
+
+message(0xe3a0d482) JettonSwapPayload {
+    // Inlined fields of SwapStep Struct
+    poolAddress: Address;
+    kind: Int as uint1 = 0;
+    limit: Int as coins = 0;
+    nextStep: SwapStep? = null;
+
+    // Set of parameters relevant for the whole swap
+    swapParams: SwapParams;
+}
+
+struct SwapStep {
+    poolAddress: Address;
+    kind: Int as uint1 = 0;
+    limit: Int as coins = 0;
+    nextStep: Cell?;
+}
+
+struct SwapParams {
+    deadline: Int as uint32 = 0;
+    recipientAddress: Address? = null;
+    referralAddress: Address? = null;
+    fulfillPayload: Cell? = null;
+    rejectPayload: Cell? = null;
+}
+
+message JettonProvideLiquidityDistributor {
+    poolAddress: Address;
+    tokenAJettonAddress: Address;
+    tokenBJettonAddress: Address;
+    tokenAJettonAmount: Int as coins;
+    tokenBJettonAmount: Int as coins;
+    minimalLpAmount: Int as coins;
+}
+
+/// https://docs.dedust.io/reference/tlb-schemes#message-deposit_liquidity-1
+message(0x40e108d6) JettonDepositLiquidity {
+    // Pool type: 0 for volatile, 1 for stable
+    // Volatile pool is based on the "Constant Product" formula
+    // Stable-swap pool is optimized for assets of near-equal value,
+    // e.g. USDT/USDC, TON/stTON, etc.
+    poolType: Int as uint1;
+
+    // Provided assets
+    asset0: Asset;
+    asset1: Asset;
+
+    // Minimal amount of LP tokens to be received
+    // If there's less liquidity provided, the provisioning will be rejected
+    // Defaults to 0, makes this value ignored
+    minimalLpAmount: Int as coins = 0;
+
+    // Target amount of the first asset
+    targetBalances0: Int as coins;
+
+    // Target amount of the second asset
+    targetBalances1: Int as coins;
+
+    // Custom payload attached to the transaction if the provisioning is successful
+    // Defaults to `null`, which means no payload
+    fulfillPayload: Cell? = null;
+
+    // Custom payload attached to the transaction if the provisioning is rejected
+    // Defaults to `null`, which means no payload
+    rejectPayload: Cell? = null;
+}
+
+message NativeProvideLiquidityDistributor {
+    jettonWalletAddress: Address;
+    jettonMasterAddress: Address;
+    jettonAmount: Int as coins;
+    nativeAmount: Int as coins;
+    minimalLpAmount: Int as coins;
+    vaultAddress: Address;
+}
+
+/// https://docs.dedust.io/reference/tlb-schemes#message-deposit_liquidity
+message(0xd55e4686) NativeDepositLiquidity {
+    // Unique identifier used to trace transactions across multiple contracts
+    // Defaults to 0, which means we don't mark messages to trace their chains
+    queryId: Int as uint64 = 0;
+
+    // Toncoin amount for the deposit
+    amount: Int as coins;
+
+    // Inlined fields of JettonDepositLiquidity Message without the opcode prefix
+    poolType: Int as uint1;
+    asset0: Asset;
+    asset1: Asset;
+    minimalLpAmount: Int as coins = 0;
+    targetBalances0: Int as coins;
+    targetBalances1: Int as coins;
+    fulfillPayload: Cell? = null;
+    rejectPayload: Cell? = null;
+}
+
+/// https://docs.dedust.io/reference/tlb-schemes#asset
+struct Asset {
+    // Specify 0 for native (TON) and omit all following fields
+    // Specify 1 for Jetton and then you must set non-null values for the following fields
+    type: Int as uint4;
+
+    workchain: Int as uint8 = 0; // Both this zeroes will be removed during .build() function. Only type will remain.
+    address: Int as uint256 = 0;
+}

package/contracts/packages/nap/errcodes.tact

@@ -0,0 +1,5 @@
+const codeInflowValueNotSufficient  : Int = 50001;
+const codeUnauthorizedWallet        : Int = 50002;
+const codeUnauthorizedNFT           : Int = 50003;
+const codeNotImplemented            : Int = 50004;
+// const codeUnauthorizedCaller        

package/contracts/packages/nap/messages.tact

@@ -0,0 +1,34 @@
+message WithdrawMessage {
+    amount: Int as coins;
+    receiver: Address;
+}
+
+message SetFees {
+    newNapFee: Int as coins;
+}
+
+message(0xe3a0d482) JettonSwapPayload {
+    // Inlined fields of SwapStep Struct
+    poolAddress: Address;
+    kind: Int as uint1 = 0;
+    limit: Int as coins = 0;
+    nextStep: SwapStep? = null;
+
+    // Set of parameters relevant for the whole swap
+    swapParams: SwapParams;
+}
+
+struct SwapStep {
+    poolAddress: Address;
+    kind: Int as uint1 = 0;
+    limit: Int as coins = 0;
+    nextStep: Cell?;
+}
+
+struct SwapParams {
+    deadline: Int as uint32 = 0;
+    recipientAddress: Address? = null;
+    referralAddress: Address? = null;
+    fulfillPayload: Cell? = null;
+    rejectPayload: Cell? = null;
+}

package/contracts/packages/token/jetton/JettonMaster.tact

@@ -0,0 +1,127 @@
+/*
+    This file provides traits for TEP-0074, TEP-0064 jetton standard
+
+    [TEP0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md)
+    [Official FunC implementation](https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-wallet.fc)
+    [Ton Minter Contract](https://github.com/ton-blockchain/minter-contract)
+    [Tact Template](https://github.com/howardpen9/jetton-implementation-in-tact/blob/main/sources/contract.tact)
+*/
+import "./JettonWallet";
+
+struct JettonData {
+    total_supply: Int as coins; // the total number of issues jettons
+    mintable: Bool;             // flag which indicates whether number of jettons can increase admin_address
+    admin_address: Address;     // address of smart-contrac which control Jetton
+    jetton_content: Cell;       // data in accordance to Token Data Standard #64
+    jetton_wallet_code: Cell;   // code of wallet for that jetton
+}
+
+message JettonMint {
+    origin: Address;        // address of origin mint request (may be wallet v4)
+    receiver: Address;      // address of receiver
+    amount: Int;            // amount of jettons to mint
+    custom_payload: Cell?;  // optional custom data
+    forward_ton_amount: Int as coins;
+    forward_payload: Slice as remaining;
+}
+
+trait JettonMaster {
+    total_supply: Int;      // the total number of issued jettons
+    mintable: Bool;         // flag which indicates whether minting is allowed
+    owner: Address;         // owner of this jetton
+    jetton_content: Cell;   // data in accordance to Token Data Standard #64
+
+    //********************************************//
+    //                  Messages                  //
+    //********************************************//
+
+    // @dev  JettonBurnNotification is sent from Jetton wallet after burning jettons
+    receive(msg: JettonBurnNotification) {
+        let ctx: Context = context();
+        self._burn_notification_validate(ctx, msg);
+        self._burn_notification(ctx, msg);
+    }
+
+    // @dev  JettonMint is sent from user to mint jettons
+    receive(msg: JettonMint) {
+        let ctx: Context = context();
+        self._mint_validate(ctx, msg);
+        self._mint(ctx, msg);
+    }
+
+    //********************************************//
+    //             Internal functions             //
+    //********************************************//
+
+    // @dev  calculate_jetton_wallet_init retrieve init code of a jetton wallet
+    // @note one MUST override this function in inherited contract
+    abstract inline fun calculate_jetton_wallet_init(owner_address: Address): StateInit;
+
+    // @dev  _mint_validate conduct some custom validating before mint
+    virtual inline fun _mint_validate(ctx: Context, msg: JettonMint) {
+        require(ctx.sender == self.owner, "JettonMaster: Sender is not a Jetton owner");
+        require(self.mintable, "JettonMaster: Jetton is not mintable");
+    }
+
+    // @dev  _mint mint jettons
+    virtual inline fun _mint(ctx: Context, msg: JettonMint) {
+        let initCode: StateInit = self.calculate_jetton_wallet_init(msg.receiver);
+        self.total_supply = self.total_supply + msg.amount;
+        send(SendParameters{
+            to: contractAddress(initCode),
+            value: 0,
+            bounce: true,
+            mode: SendRemainingValue,
+            body: JettonInternalTransfer{ 
+                query_id: 0,
+                amount: msg.amount,
+                response_address: msg.origin,
+                from: myAddress(),
+                forward_ton_amount: msg.forward_ton_amount,
+                forward_payload: msg.forward_payload
+            }.toCell(),
+            code: initCode.code,
+            data: initCode.data
+        });
+    }
+
+    // @dev  _burn_notification_validate perform some custom validation after receiving JettonBurnNotification sent from Jetton wallet
+    virtual inline fun _burn_notification_validate(ctx: Context, msg: JettonBurnNotification) {
+        let initCode: StateInit = self.calculate_jetton_wallet_init(msg.sender);
+        require(ctx.sender == contractAddress(initCode), "Sender is not a Jetton wallet");
+    } 
+
+    // @dev  _burn_notification dwindles total_supply and send notification to wallet after receiving JettonBurnNotification
+    inline fun _burn_notification(ctx: Context, msg: JettonBurnNotification) {
+        self.total_supply = self.total_supply - msg.amount;
+        if(msg.response_destination != newAddress(0, 0)){
+            send(SendParameters{
+                to: msg.response_destination,
+                value: 0,
+                bounce: false,
+                mode: SendRemainingValue + SendIgnoreErrors
+            });
+        }
+    }
+
+    //*********************************//
+    //             Getters             //
+    //*********************************//
+
+    // @dev get_jetton_data retrieve information of this jetton
+    get fun get_jetton_data(): JettonData {
+        return JettonData{
+            total_supply: self.total_supply,
+            mintable: self.mintable,
+            admin_address: self.owner,
+            jetton_content: self.jetton_content,
+            jetton_wallet_code: self.calculate_jetton_wallet_init(myAddress()).code
+        };
+    }
+
+    // @dev get_wallet_address call calculate_jetton_wallet_init and return address of wallet
+    get fun get_wallet_address(owner_address: Address): Address {
+        let initCode: StateInit = self.calculate_jetton_wallet_init(owner_address);
+        return contractAddress(initCode);
+    }
+}

package/contracts/packages/token/jetton/JettonWallet.tact

@@ -0,0 +1,248 @@
+/*
+    This file provides traits for TEP-0074 jetton standard
+
+    [TEP0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md)
+    [Official FunC implementation](https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-wallet.fc)
+    [Ton Minter Contract](https://github.com/ton-blockchain/minter-contract)
+    [Tact Template](https://github.com/howardpen9/jetton-implementation-in-tact/blob/main/sources/contract.tact)
+*/
+
+message(0x0f8a7ea5) JettonTransfer {
+    query_id: Int as uint64;                // arbitrary request number
+    amount: Int as coins;                   // amount of jettons to transfer
+    destination: Address;                   // address of the new owner of the jettons
+    response_destination: Address;          // address where to send a response with confirmation of a successful transfer and the rest of the incoming message Toncoins.
+    custom_payload: Cell?;                  // optional custom payload
+    forward_ton_amount: Int as coins;       // the amount of nanotons to be sent to the destination address.
+    forward_payload: Slice as remaining;    // optional custom data that should be sent to the destination address.
+}
+
+message(0x7362d09c) JettonTransferNotification {
+    query_id: Int as uint64;                // arbitrary request number
+    amount: Int as coins;                   // amount of jettons to transfer
+    sender: Address;                        // address of the sender of the jettons
+    forward_payload: Slice as remaining;    // optional custom payload
+}
+
+message(0x595f07bc) JettonBurn {
+    query_id: Int as uint64;        // arbitrary request number
+    amount: Int as coins;           // amount of jettons to burn
+    response_destination: Address;  // address where to send a response with confirmation of a successful burn and the rest of the incoming message coins.
+    custom_payload: Cell?;          // optional custom payload
+}
+
+message(0xd53276db) JettonExcesses {
+    query_id: Int as uint64;        // arbitrary request number
+}
+
+message(0x178d4519) JettonInternalTransfer {
+    query_id: Int as uint64;                // arbitrary request number
+    amount: Int as coins;                   // amount of jettons to transfer
+    from: Address;                          // address of the sender of the jettons 
+    response_address: Address;              // address where to send a response with confirmation of a successful transfer and the rest of the incoming message coins.
+    forward_ton_amount: Int as coins;       // the amount of nanotons to be sent to the destination address.
+    forward_payload: Slice as remaining;    // optional custom data that should be sent to the destination address.
+}
+
+message(0x7bdd97de) JettonBurnNotification {
+    query_id: Int as uint64;          // arbitrary request number
+    amount: Int as coins;             // amount of jettons to burn
+    sender: Address;                  // address of the sender of the jettons
+    response_destination: Address;    // address where to send a response with confirmation of a successful burn and the rest of the incoming message coins.
+}
+
+struct WalletData {
+    balance: Int as coins;      // amount of jettons on wallet
+    owner: Address;             // address of wallet owner;
+    jetton: Address;            // address of Jetton master-address
+    jetton_wallet_code: Cell;   // with code of this wallet
+}
+
+
+trait JettonWallet {
+    balance: Int;
+    owner: Address;
+    jetton_master: Address;
+    virtual const gasConsumption: Int = ton("0.01");
+    virtual const minTonsForStorage: Int = ton("0.01");
+
+    //********************************************//
+    //                  Messages                  //
+    //********************************************//
+
+    // @dev  JettonTransfer is send from the owner of the jetton wallet to the jetton wallet itself to transfer jettons to another user
+    receive(msg: JettonTransfer) {
+        let ctx: Context = context();
+        self.balance = self.balance - msg.amount;
+        require(self.balance >= 0, "JettonWallet: Not enough jettons to transfer");
+        self._transfer_validate(ctx, msg);
+        self._transfer_estimate_remain_value(ctx, msg);
+        self._transfer_jetton(ctx, msg);
+    }
+
+    // @dev  JettonBurn is send from the owner of the jetton wallet to the jetton wallet itself to burn jettons
+    receive(msg: JettonBurn) {
+        let ctx: Context = context();
+        self.balance = self.balance - msg.amount;
+        require(self.balance >= 0, "JettonWallet: Not enough balance to burn tokens");
+        self._burn_validate(ctx, msg);
+        self._burn_tokens(ctx, msg);
+    }
+
+    // @dev  JettonInternalTransfer is send from the jetton master or jetton wallet to the jetton wallet itself to transfer jettons to this jetton wallet
+    receive(msg: JettonInternalTransfer) {
+        let ctx: Context = context();
+        self.balance = self.balance + msg.amount;
+        require(self.balance >= 0, "JettonWallet: Not allow negative balance after internal transfer");
+        self._internal_transfer_validate(ctx, msg);
+        let remain: Int = self._internal_transfer_estimate_remain_value(ctx, msg);
+        if (msg.forward_ton_amount > 0){
+            self._internal_transfer_notification(ctx, msg);
+        }
+        self._internal_transfer_excesses(ctx, msg, remain);
+    }
+
+    bounced(src: bounced<JettonInternalTransfer>) {
+        self.balance = self.balance + src.amount;
+    }
+
+    bounced(src: bounced<JettonBurnNotification>) {
+        self.balance = self.balance + src.amount;
+    }
+
+
+    //********************************************//
+    //             Internal functions             //
+    //********************************************//
+
+    // @dev  calculate_jetton_wallet_init will get init code of a jetton wallet by provided it's owner address
+    // @note one MUST override this function and return state init of the inherited jetton wallet implementation
+    abstract inline fun calculate_jetton_wallet_init(owner_address: Address): StateInit;
+
+    // @dev  _internal_tranfer_validate will validate internal transfer message, usually it will check that sender is a jetton master or jetton wallet
+    // @note this function will triggered on receiving JettonTransfer message
+    virtual inline fun _internal_transfer_validate(ctx: Context, msg: JettonInternalTransfer) {
+        if(ctx.sender != self.jetton_master){
+            let init: StateInit = self.calculate_jetton_wallet_init(msg.from);
+            require(ctx.sender == contractAddress(init), "JettonWallet: Only Jetton master or Jetton wallet can call this function");
+        }
+    }
+
+    // @dev  _internal_transfer_estimate_remain_value will estimate remain value after deducting storage fee, forward fee and gas consumption
+    virtual inline fun _internal_transfer_estimate_remain_value(ctx: Context, msg: JettonInternalTransfer): Int {
+        let tonBalanceBeforeMsg: Int = myBalance() - ctx.value;
+        let storage_fee: Int =  self.minTonsForStorage - min(tonBalanceBeforeMsg, self.minTonsForStorage);
+        let remain: Int = ctx.value - (storage_fee + self.gasConsumption);
+        if (msg.forward_ton_amount > 0) {
+            remain = remain - (ctx.readForwardFee() + msg.forward_ton_amount);
+        }
+        return remain;
+    }
+
+    // @dev  _internal_transfer_notification will send notification to the owner of the jetton wallet
+    virtual inline fun _internal_transfer_notification(ctx: Context, msg: JettonInternalTransfer) {
+        if (msg.forward_ton_amount > 0) {
+            send(SendParameters{
+                to: self.owner,
+                value: msg.forward_ton_amount,
+                mode: SendPayGasSeparately,
+                bounce: false,
+                body: JettonTransferNotification{
+                    query_id: msg.query_id,
+                    amount: msg.amount,
+                    sender: msg.from,
+                    forward_payload: msg.forward_payload
+                }.toCell()
+            });
+        }
+    }
+
+    // @dev  _internal_transfer_excesses will send excesses message back after transfer action completed
+    virtual inline fun _internal_transfer_excesses(ctx: Context, msg: JettonInternalTransfer, remain: Int){
+        if((msg.response_address != newAddress(0, 0)) && remain > 0){
+            send(SendParameters{
+                to: msg.response_address,
+                value: remain,
+                bounce: false,
+                mode: SendIgnoreErrors,
+                body: JettonExcesses{
+                    query_id: msg.query_id
+                }.toCell()
+            });
+        }
+    }
+    
+    // @dev  _burn_validate will conduct custom checking when receiving JettonBurn message
+    virtual inline fun _burn_validate(ctx: Context, msg: JettonBurn) {
+        require(ctx.sender == self.owner, "JettonWallet: Only owner can burn tokens");
+    }
+
+    // @dev  _burn_tokens will burn tokens and send JettonBurnNotification back to the jetton master
+    // @note this message is bounceable, if burn action failed, the message will be bounced back, you should increase the balance of the wallet
+    virtual inline fun _burn_tokens(ctx: Context, msg: JettonBurn) {
+        send(SendParameters{
+            to: self.jetton_master,
+            value: 0,
+            mode: SendRemainingValue,
+            bounce: true,
+            body: JettonBurnNotification{
+                query_id: msg.query_id,
+                amount: msg.amount,
+                sender: self.owner,
+                response_destination: msg.response_destination
+            }.toCell()
+        });
+    }
+
+    // @dev  _transfer_validate will conduct custom checking when receiving JettonTransfer message
+    virtual inline fun _transfer_validate(ctx: Context, msg: JettonTransfer) {
+        require(ctx.sender == self.owner, "Only owner can call this function");
+        
+    }
+
+    // @dev  _transfer_estimate_remain_value will estimate remain value after deducting storage fee, forward fee and gas consumption
+    virtual inline fun _transfer_estimate_remain_value(ctx: Context, msg: JettonTransfer) {
+        let fwd_count: Int = 1;
+        if (msg.forward_ton_amount > 0) {
+            fwd_count = 2;
+        }
+        require(ctx.value > fwd_count * ctx.readForwardFee() + 2 * self.gasConsumption + self.minTonsForStorage, "Not enough funds to transfer");
+    }
+
+    // @dev  _transfer_jetton will transfer jettons to the jetton wallet of the destination address (owner of jetton wallet)
+    // @note  this message is bounceable, if transfer action failed, the message will be bounced back, you should increase the balance of the wallet
+    virtual inline fun _transfer_jetton(ctx: Context, msg: JettonTransfer) {
+        let init: StateInit = self.calculate_jetton_wallet_init(msg.destination);
+        let receiver: Address = contractAddress(init);
+        send(SendParameters{
+            to: receiver,
+            value: 0,
+            bounce: true,
+            mode: SendRemainingValue,
+            body: JettonInternalTransfer{
+                query_id: msg.query_id,
+                amount: msg.amount,
+                response_address: msg.response_destination,
+                from: self.owner,
+                forward_ton_amount: msg.forward_ton_amount,
+                forward_payload: msg.forward_payload
+            }.toCell(),
+            code: init.code,
+            data: init.data
+        });
+    }
+
+    //*********************************//
+    //             Getters             //
+    //*********************************//
+
+    // @dev  get_wallet_data will return wallet data, which follows TEP 0074 standard
+    get fun get_wallet_data(): WalletData{
+        return WalletData { 
+            balance: self.balance,
+            owner: self.owner,
+            jetton: self.jetton_master,
+            jetton_wallet_code: self.calculate_jetton_wallet_init(self.owner).code
+        };
+    }    
+}

package/contracts/packages/token/nft/AuctionErrorCode.tact

@@ -0,0 +1,55 @@
+/* 
+    NFT Auciton Market Error Code :
+    3724: Bid doesn't meet the minimum increase requirement
+    11017: Contract is already initialized
+    19941: Only owner can build nft auction contract
+    20805: Only owner can init auction end time.
+    20844: BuyNowPrice must be greater than reservePrice
+    24136: Auction was not set before.
+    37031: NFT Seller cannot bid
+    42237: Contract is not initialized
+    42345: Only owner can revise auction contract
+    45065: Auction not yet ended
+    46984: Auction ended
+    50905: Auction bid period ended
+    54143: This NFT didn't transfer to NFT Auction Market Contract yet.
+    55234: BuyNowPrice must be greater than reservePrice.
+    58706: Auction was already set for this NFT.
+    59374: Cannot update reserve price and buy now price at the same time.
+*/
+
+/* 
+    NFT Auction Error Code :
+    3724: Bid doesn't meet the minimum increase requirement
+    11017: Contract is already initialized
+    19941: Only owner can build nft auction contract
+    20805: Only owner can init auction end time.
+    20844: BuyNowPrice must be greater than reservePrice
+    24136: Auction was not set before.
+    37031: NFT Seller cannot bid
+    42237: Contract is not initialized
+    42345: Only owner can revise auction contract
+    45065: Auction not yet ended
+    46984: Auction ended
+    50905: Auction bid period ended
+    54143: This NFT didn't transfer to NFT Auction Market Contract yet.
+    55234: BuyNowPrice must be greater than reservePrice.
+    58706: Auction was already set for this NFT.
+    59374: Cannot update reserve price and buy now price at the same time.
+*/
+
+/* 
+    Error code Old Version :
+    1000: Auction not yet ended.
+    1001: Only owner can do this.
+    1002: Auction was not set before.
+    1003: This NFT didn't transfer to NFT Auction Market Contract yet.
+    1004: Contract is already initialized.
+    1005: Auction ended.
+    1006: NFT Seller cannot bid.
+    1007: Bid doesn't meet the minimum increase requirement.
+    1008: Auction was already set for this NFT.
+    1009: Auction did not set up before.
+    1010: BuyNowPrice must be greater than reservePrice.
+    1011: Cannot update reserve price and buy now price at the same time.
+*/