@affluent-org/sdk 0.0.1

package/dist/contracts/rfq/rfq_auction/index.d.ts

@@ -0,0 +1,216 @@
+import { Address, Builder, Cell, Contract, ContractProvider, Sender, Slice } from "@ton/core";
+export type RFQActionConfig = {
+    requesterAddress: Address;
+    index: number;
+};
+export type RFQAuctionInitializeConfig = {
+    sellAssetAddress: Address;
+    buyAssetAddress: Address;
+    sellAssetAmount: bigint;
+    config: {
+        auctionMode: number;
+        bidCloseTimestamp: number;
+        minBuyAssetValue: bigint;
+        maxBuyAssetValue: bigint;
+        allowSellerCancel: boolean;
+        allowBidderCancel: boolean;
+        priceDeviationTolerance: number;
+    };
+    sellAssetWalletAddress: Address;
+    buyAssetWalletAddress: Address;
+    rfqEventEmitterAddress: Address;
+    dataAggregatorCode: Cell;
+    oracleConfig?: Cell | null;
+    responseAddress: Address;
+    jettonForwardTonAmount?: bigint;
+    jettonForwardPayload?: Cell | null;
+    rfqNotiForwardTonAmount?: bigint;
+    rfqNotiForwardPayload?: Cell | null;
+};
+export declare class RFQAuction implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static State: {
+        Active: number;
+        Closed: number;
+        VerifiedAllAssetWallet: number;
+        VerifiedOnlySellAssetWallet: number;
+        VerifiedOnlyBuyAssetWallet: number;
+        Bidable: number;
+        Open: number;
+        Success: number;
+        Failure: number;
+    };
+    static AuctionMode: {
+        AmountBid: number;
+        SlippageBid: number;
+    };
+    static Constants: {
+        MIN_STORAGE_FEE: bigint;
+        BID_FEE: bigint;
+        SETTLE_FEE: bigint;
+        JETTON_TRANSFER_FEE: bigint;
+        RFQ_EVENT_EMITTER_FEE: bigint;
+    };
+    static Op: {
+        Initialize: number;
+        Settle: number;
+        Deposit: number;
+        Bid: number;
+        RFQNotification: number;
+        CancelRFQ: number;
+        CancelBid: number;
+        ClearBids: number;
+        VerifiedWallet: number;
+    };
+    static Error: {
+        UnknownOp: number;
+        CellUnderflow: number;
+        Unauthorized: number;
+        InvalidAsset: number;
+        InvalidBalance: number;
+        InvalidState: number;
+        AlreadyDeposited: number;
+        AlreadyBid: number;
+        BidClosed: number;
+        InvalidMinBuyAssetValue: number;
+        InvalidImmediateExecutionBuyAssetValue: number;
+        PeriodNotOverYet: number;
+        InvalidAssetAmount: number;
+        NotDepositable: number;
+        InvalidAssetWallet: number;
+        NotBidable: number;
+        NotSettleableState: number;
+        NoBids: number;
+        BidNotClosed: number;
+        BidValueTooLow: number;
+        BidValueTooHigh: number;
+        InvalidStorage: number;
+        InvalidInitState: number;
+        InvalidInitVerifiedSellWallet: number;
+        InvalidInitVerifiedBuyWallet: number;
+        InvalidInitDepositedSellAsset: number;
+        InvalidInitBids: number;
+        NotEnoughTon: number;
+        UnverifiedBuyAssetWallet: number;
+        UnverifiedSellAssetWallet: number;
+        NotDepositedSellAsset: number;
+        NotOpenState: number;
+        ExistBids: number;
+        NotAllowBidderCancel: number;
+        NotFoundBid: number;
+        CountTooLarge: number;
+        OpenedAuction: number;
+        NotFoundAssetPrice: number;
+        NotFoundPrice: number;
+    };
+    static computeBidReserveFee(forwardTonAmount: bigint, isFirstBid: boolean): bigint;
+    static computeSellReserveFee(forwardTonAmount: bigint, rfqNotiForwardTonAmount: bigint): bigint;
+    static createFromAddress(address: Address): RFQAuction;
+    static createFromConfig(config: RFQActionConfig, code: Cell, workchain?: number): RFQAuction;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static createInitializeMsg(config: RFQAuctionInitializeConfig): Cell;
+    sendInitialize(provider: ContractProvider, via: Sender, value: bigint, config: RFQAuctionInitializeConfig): Promise<void>;
+    static createDepositMsg(): Cell;
+    static createBidMsg(bidValue: bigint, responseAddress: Address, jettonForwardTonAmount?: bigint, jettonForwardPayload?: Cell | null): Cell;
+    sendDeposit(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendSetEventEmitterForTesting(provider: ContractProvider, via: Sender, value: bigint, eventEmitterAddress: Address): Promise<void>;
+    sendMsgBody(provider: ContractProvider, via: Sender, value: bigint, body: Cell): Promise<void>;
+    sendSettle(provider: ContractProvider, via: Sender, value: bigint, { oracleParams, }: {
+        oracleParams: Cell;
+    }): Promise<void>;
+    sendCancelRFQ(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendCancelBid(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendClearBids(provider: ContractProvider, via: Sender, value: bigint, count: number): Promise<void>;
+    static Dictionary: {
+        Values: {
+            Bid: () => {
+                serialize: (src: Bid, builder: Builder) => void;
+                parse: (src: Slice) => Bid;
+            };
+        };
+    };
+    static parseRFQStorage(dataCell: Cell): {
+        initialized: boolean;
+        index: bigint;
+        state: number;
+        sellerAddress: Address;
+        verifiedSellWallet: boolean;
+        verifiedBuyWallet: boolean;
+        depositedSellAsset: boolean;
+        bids: Record<string, Bid>;
+        sellAssetAddress: Address;
+        buyAssetAddress: Address;
+        sellAssetAmount: bigint;
+        config: {
+            auctionMode: number;
+            bidCloseTimestamp: number;
+            minBuyAssetValue: bigint;
+            maxBuyAssetValue: bigint;
+            allowSellerCancel: boolean;
+            allowBidderCancel: boolean;
+            priceDeviationTolerance: bigint;
+        };
+        sellAssetWalletAddress: Address | null;
+        buyAssetWalletAddress: Address | null;
+        rfqEventEmitterAddress: Address | null;
+        dataAggregatorCodeHash: string | null;
+        dataAggregatorIndex: bigint;
+        oracleConfig: Cell | import("../../oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../oracle/redstone-oracle/type").RedstonOracleConfig | null;
+        jettonForwardTonAmount: bigint;
+        jettonForwardPayloadHash: string | null;
+        responseAddress: Address;
+        rfqNotiForwardTonAmount: bigint;
+        rfqNotiForwardPayloadHash: string | null;
+    };
+    getRFQData(provider: ContractProvider): Promise<{
+        initialized: boolean;
+        index: bigint;
+        state: number;
+        sellerAddress: Address;
+        verifiedSellWallet: boolean;
+        verifiedBuyWallet: boolean;
+        depositedSellAsset: boolean;
+        bids: Record<string, Bid>;
+        sellAssetAddress: Address;
+        buyAssetAddress: Address;
+        sellAssetAmount: bigint;
+        config: {
+            auctionMode: number;
+            bidCloseTimestamp: number;
+            minBuyAssetValue: bigint;
+            maxBuyAssetValue: bigint;
+            allowSellerCancel: boolean;
+            allowBidderCancel: boolean;
+            priceDeviationTolerance: bigint;
+        };
+        sellAssetWalletAddress: Address | null;
+        buyAssetWalletAddress: Address | null;
+        rfqEventEmitterAddress: Address | null;
+        dataAggregatorCodeHash: string | null;
+        dataAggregatorIndex: bigint;
+        oracleConfig: Cell | import("../../oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../oracle/redstone-oracle/type").RedstonOracleConfig | null;
+        jettonForwardTonAmount: bigint;
+        jettonForwardPayloadHash: string | null;
+        responseAddress: Address;
+        rfqNotiForwardTonAmount: bigint;
+        rfqNotiForwardPayloadHash: string | null;
+    }>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+}
+type Bid = {
+    bidValue: bigint;
+    escrowAmount: bigint;
+    lt: bigint;
+    responseAddress: Address;
+    forwardTonAmount: bigint;
+    forwardPayload: string | null;
+};
+export {};

package/dist/contracts/rfq/rfq_auction/index.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFQAuction = void 0;
+const core_1 = require("@ton/core");
+const parser_1 = require("../../oracle/parser");
+class RFQAuction {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static State = {
+        Active: 0,
+        Closed: 1,
+        VerifiedAllAssetWallet: 3,
+        VerifiedOnlySellAssetWallet: 1,
+        VerifiedOnlyBuyAssetWallet: 2,
+        Bidable: 7,
+        Open: 0,
+        Success: 1,
+        Failure: 2,
+    };
+    static AuctionMode = {
+        AmountBid: 0,
+        SlippageBid: 1,
+    };
+    static Constants = {
+        MIN_STORAGE_FEE: (0, core_1.toNano)("0.01"),
+        BID_FEE: (0, core_1.toNano)("0.04"),
+        SETTLE_FEE: (0, core_1.toNano)("0.01"),
+        JETTON_TRANSFER_FEE: (0, core_1.toNano)("0.06"),
+        RFQ_EVENT_EMITTER_FEE: (0, core_1.toNano)("0.02"),
+    };
+    static Op = {
+        Initialize: 0xbe5a7595,
+        Settle: 0xb48a809e,
+        Deposit: 0xf9471134,
+        Bid: 0x2a043cb0,
+        RFQNotification: 0xeb27e847,
+        CancelRFQ: 0x5f6f17e0,
+        CancelBid: 0xa90c4cb4,
+        ClearBids: 0x528d62fe,
+        VerifiedWallet: 0xb97c1901,
+    };
+    static Error = {
+        UnknownOp: 0xffff,
+        CellUnderflow: 9,
+        Unauthorized: 1000,
+        InvalidAsset: 1001,
+        InvalidBalance: 1002,
+        InvalidState: 1003,
+        AlreadyDeposited: 1004,
+        AlreadyBid: 1005,
+        BidClosed: 1006,
+        InvalidMinBuyAssetValue: 1007,
+        InvalidImmediateExecutionBuyAssetValue: 1008,
+        PeriodNotOverYet: 1009,
+        InvalidAssetAmount: 1010,
+        NotDepositable: 1011,
+        InvalidAssetWallet: 1012,
+        NotBidable: 1013,
+        NotSettleableState: 1015,
+        NoBids: 1016,
+        BidNotClosed: 1017,
+        BidValueTooLow: 1019,
+        BidValueTooHigh: 1020,
+        InvalidStorage: 0x2000,
+        InvalidInitState: 1021,
+        InvalidInitVerifiedSellWallet: 1022,
+        InvalidInitVerifiedBuyWallet: 1023,
+        InvalidInitDepositedSellAsset: 1024,
+        InvalidInitBids: 1025,
+        NotEnoughTon: 1026,
+        UnverifiedBuyAssetWallet: 1027,
+        UnverifiedSellAssetWallet: 1028,
+        NotDepositedSellAsset: 1029,
+        NotOpenState: 1030,
+        ExistBids: 1031,
+        NotAllowBidderCancel: 1032,
+        NotFoundBid: 1033,
+        CountTooLarge: 1034,
+        OpenedAuction: 1035,
+        NotFoundAssetPrice: 9999,
+        NotFoundPrice: 7300,
+    };
+    static computeBidReserveFee(forwardTonAmount, isFirstBid) {
+        let reserveFee = forwardTonAmount * 2n;
+        if (isFirstBid) {
+            reserveFee += RFQAuction.Constants.SETTLE_FEE + RFQAuction.Constants.JETTON_TRANSFER_FEE * 2n;
+        }
+        return reserveFee;
+    }
+    static computeSellReserveFee(forwardTonAmount, rfqNotiForwardTonAmount) {
+        return (forwardTonAmount +
+            RFQAuction.Constants.JETTON_TRANSFER_FEE +
+            RFQAuction.Constants.MIN_STORAGE_FEE +
+            rfqNotiForwardTonAmount);
+    }
+    static createFromAddress(address) {
+        return new RFQAuction(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = (0, core_1.beginCell)()
+            .storeUint(0, 1) // initialized
+            .storeAddress(config.requesterAddress)
+            .storeCoins(config.index)
+            .endCell();
+        const init = { code, data };
+        return new RFQAuction((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQAuction.Op.Initialize, 32).endCell(),
+        });
+    }
+    static createInitializeMsg(config) {
+        return (0, core_1.beginCell)()
+            .storeUint(RFQAuction.Op.Initialize, 32) // [op]
+            .storeUint(0, 64) // [query_id]
+            .storeUint(0, 4) // 3: state
+            .storeUint(0, 1) // 4: verified_sell_wallet
+            .storeUint(0, 1) // 5: verified_buy_wallet
+            .storeUint(0, 1) // 6: deposited_sell_asset
+            .storeMaybeRef(null) // 7: bids
+            .storeAddress(config.sellAssetAddress) // 8: sell_asset_address
+            .storeAddress(config.buyAssetAddress) // 9: buy_asset_address
+            .storeCoins(config.sellAssetAmount) // 10: sell_asset_amount
+            .storeRef((0, core_1.beginCell)()
+            .storeUint(config.config.auctionMode, 4) // 11: auction_mode
+            .storeUint(config.config.bidCloseTimestamp, 40) // 12: bid_close_timestamp
+            .storeCoins(config.config.minBuyAssetValue) // 13: min_buy_asset_value
+            .storeCoins(config.config.maxBuyAssetValue) // 14: max_buy_asset_value
+            .storeBit(config.config.allowSellerCancel) // 15: allow_seller_cancel
+            .storeBit(config.config.allowBidderCancel) // 16: allow_bidder_cancel
+            .storeCoins(config.config.priceDeviationTolerance) // 17: price_deviation_tolerance
+            .endCell())
+            .storeRef((0, core_1.beginCell)()
+            .storeAddress(config.sellAssetWalletAddress) // 18: sell_asset_wallet_address
+            .storeAddress(config.buyAssetWalletAddress) // 19: buy_asset_wallet_address
+            .storeAddress(config.rfqEventEmitterAddress) // 20: rfq_event_emiter_address
+            .storeRef(config.dataAggregatorCode) // 21: data_aggregator_code
+            .storeCoins(0) // 22: data_aggregator_index
+            .storeMaybeRef(config.oracleConfig) // 23: oracle_config
+            .endCell())
+            .storeRef((0, core_1.beginCell)()
+            .storeAddress(config.responseAddress)
+            .storeCoins(config.jettonForwardTonAmount ?? 0n)
+            .storeMaybeRef(config.jettonForwardPayload)
+            .storeCoins(config.rfqNotiForwardTonAmount ?? 0n)
+            .storeMaybeRef(config.rfqNotiForwardPayload))
+            .endCell();
+    }
+    async sendInitialize(provider, via, value, config) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: RFQAuction.createInitializeMsg(config),
+        });
+    }
+    static createDepositMsg() {
+        return (0, core_1.beginCell)().storeUint(RFQAuction.Op.Deposit, 32).endCell();
+    }
+    static createBidMsg(bidValue, responseAddress, jettonForwardTonAmount = 0n, jettonForwardPayload = null) {
+        return (0, core_1.beginCell)()
+            .storeUint(RFQAuction.Op.Bid, 32)
+            .storeCoins(bidValue)
+            .storeAddress(responseAddress)
+            .storeCoins(jettonForwardTonAmount)
+            .storeMaybeRef(jettonForwardPayload)
+            .endCell();
+    }
+    async sendDeposit(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQAuction.Op.Deposit, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendSetEventEmitterForTesting(provider, via, value, eventEmitterAddress) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(0x123123, 32).storeUint(0, 64).storeAddress(eventEmitterAddress).endCell(),
+        });
+    }
+    async sendMsgBody(provider, via, value, body) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body,
+        });
+    }
+    async sendSettle(provider, via, value, { oracleParams, }) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQAuction.Op.Settle, 32).storeUint(0, 64).storeMaybeRef(oracleParams).endCell(),
+        });
+    }
+    async sendCancelRFQ(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQAuction.Op.CancelRFQ, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendCancelBid(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQAuction.Op.CancelBid, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendClearBids(provider, via, value, count) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQAuction.Op.ClearBids, 32).storeUint(0, 64).storeCoins(count).endCell(),
+        });
+    }
+    static Dictionary = {
+        Values: {
+            Bid: () => ({
+                serialize: (src, builder) => { },
+                parse: (src) => {
+                    const bidValue = src.loadCoins();
+                    const escrowAmount = src.loadCoins();
+                    const lt = src.loadUintBig(256);
+                    const responseAddress = src.loadAddress();
+                    const forwardTonAmount = src.loadCoins();
+                    const forwardPayload = src.loadMaybeRef();
+                    return {
+                        bidValue,
+                        escrowAmount,
+                        lt,
+                        responseAddress,
+                        forwardTonAmount,
+                        forwardPayload: forwardPayload ? forwardPayload.hash().toString("hex") : null,
+                    };
+                },
+            }),
+        },
+    };
+    static parseRFQStorage(dataCell) {
+        const data = dataCell.beginParse();
+        const initialized = data.loadBoolean();
+        const sellerAddress = data.loadAddress();
+        const index = data.loadCoins();
+        const state = data.loadUint(4);
+        const verifiedSellWallet = data.loadBoolean();
+        const verifiedBuyWallet = data.loadBoolean();
+        const depositedSellAsset = data.loadBoolean();
+        const _bids = data.loadMaybeRef();
+        let bids = {};
+        if (_bids) {
+            const __bids = _bids.beginParse().loadDictDirect(core_1.Dictionary.Keys.Address(), RFQAuction.Dictionary.Values.Bid());
+            __bids.keys().forEach((key) => {
+                const bid = __bids.get(key);
+                if (bid) {
+                    bids[key.toString()] = bid;
+                }
+            });
+        }
+        const sellAssetAddress = data.loadAddress();
+        const buyAssetAddress = data.loadAddress();
+        const sellAssetAmount = data.loadCoins();
+        const _config = data.loadRef().beginParse();
+        const config = {
+            auctionMode: _config.loadUint(4),
+            bidCloseTimestamp: _config.loadUint(40),
+            minBuyAssetValue: _config.loadCoins(),
+            maxBuyAssetValue: _config.loadCoins(),
+            allowSellerCancel: _config.loadBit(),
+            allowBidderCancel: _config.loadBit(),
+            priceDeviationTolerance: _config.loadCoins(),
+        };
+        const additional1CS = data.loadRef().beginParse();
+        const sellAssetWalletAddress = additional1CS.loadMaybeAddress();
+        const buyAssetWalletAddress = additional1CS.loadMaybeAddress();
+        const rfqEventEmitterAddress = additional1CS.loadMaybeAddress();
+        const dataAggregatorCode = additional1CS.loadRef();
+        const dataAggregatorIndex = additional1CS.loadCoins();
+        const oracleConfigRaw = additional1CS.loadMaybeRef();
+        const oracleConfig = oracleConfigRaw ? (0, parser_1.parseOracleConfig)(oracleConfigRaw) : null;
+        const forwardPayloadCS = data.loadRef().beginParse();
+        const responseAddress = forwardPayloadCS.loadAddress();
+        const jettonForwardTonAmount = forwardPayloadCS.loadCoins();
+        const jettonForwardPayload = forwardPayloadCS.loadMaybeRef();
+        const rfqNotiForwardTonAmount = forwardPayloadCS.loadCoins();
+        const rfqNotiForwardPayload = forwardPayloadCS.loadMaybeRef();
+        return {
+            initialized,
+            index,
+            state,
+            sellerAddress,
+            verifiedSellWallet,
+            verifiedBuyWallet,
+            depositedSellAsset,
+            bids,
+            sellAssetAddress,
+            buyAssetAddress,
+            sellAssetAmount,
+            config,
+            sellAssetWalletAddress,
+            buyAssetWalletAddress,
+            rfqEventEmitterAddress,
+            dataAggregatorCodeHash: dataAggregatorCode ? dataAggregatorCode.hash().toString("hex") : null,
+            dataAggregatorIndex,
+            oracleConfig: oracleConfig,
+            jettonForwardTonAmount,
+            jettonForwardPayloadHash: jettonForwardPayload ? jettonForwardPayload.hash().toString("hex") : null,
+            responseAddress,
+            rfqNotiForwardTonAmount,
+            rfqNotiForwardPayloadHash: rfqNotiForwardPayload ? rfqNotiForwardPayload.hash().toString("hex") : null,
+        };
+    }
+    async getRFQData(provider) {
+        const _state = await provider.getState();
+        if (_state.state.type !== "active")
+            throw "not active";
+        if (!_state.state.data)
+            throw "not active";
+        const data = core_1.Cell.fromBoc(_state.state.data)[0];
+        return RFQAuction.parseRFQStorage(data);
+    }
+    async getState(provider) {
+        const _state = await provider.getState();
+        return _state;
+    }
+}
+exports.RFQAuction = RFQAuction;