@affluent-org/sdk 0.0.1

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

@@ -0,0 +1,448 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFQBatch = void 0;
+const core_1 = require("@ton/core");
+const parser_1 = require("../../oracle/parser");
+class RFQBatch {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static State = {
+        Open: 0,
+        Closed: 1,
+    };
+    static Constant = {
+        Open: 0,
+        Closed: 1,
+    };
+    static Fee = {
+        AddOrder: 20000000n,
+        Settle: 20000000n,
+        JettonTransfer: 60000000n,
+    };
+    static Op = {
+        Initialize: 0xbe5a7595,
+        AddOrder: 0x193a4483,
+        IterOrders: 0x45f879fa,
+        Settle: 0xb48a809e,
+        ProvideAggregatedData: 0xb0c69ffe,
+        TakeAggregatedData: 0x77c65602,
+        Distribute: 0xf0bf073f,
+        Lock: 0x683a7dab,
+        CancelOrder: 0x67134629,
+        Reset: 0xf6ce5dcc,
+        Payout: 0xd4374956,
+        Reopen: 0xb9d749b8,
+        CollectFee: 0x9d21f1da,
+        VerifiedWallet: 0xb97c1901,
+    };
+    static Error = {
+        UnknownOp: 0xffff,
+        Unauthorized: 1000,
+        Locked: 1001,
+        NotEnoughGas: 1002,
+        OrderNotFound: 1003,
+        Closed: 1004,
+        Opened: 1005,
+        // NotFoundPrice: 1006,
+        NotWhitelistedSettler: 1007,
+        WrongDepositAsset: 1008,
+        NotEnoughDepositAsset: 1009,
+        ExistOrder: 1010,
+        NotLocked: 1011,
+        NotLockOwner: 1012,
+        CellUnderflow: 9,
+        CountTooLarge: 1034,
+        OrderLimitReached: 1013,
+        NotFoundPrice: 7300,
+    };
+    static computeOrderReserveFee(forwardTonAmount, isFirst) {
+        let fee = forwardTonAmount;
+        if (isFirst) {
+            fee = forwardTonAmount + RFQBatch.Fee.JettonTransfer + RFQBatch.Fee.Settle;
+        }
+        return fee;
+    }
+    static createFromAddress(address) {
+        return new RFQBatch(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = (0, core_1.beginCell)()
+            .storeCoins(config.index ?? 0n)
+            .storeAddress(config.asset0Address)
+            .storeAddress(config.asset1Address)
+            .storeCoins(0)
+            .storeCoins(0)
+            .storeMaybeRef(null)
+            .storeMaybeRef(null)
+            .storeUint(0, 8)
+            .storeUint(0, 40)
+            .storeRef((0, core_1.beginCell)()
+            .storeAddress(null)
+            .storeAddress(null)
+            .storeRef(config.aggregatorCode)
+            .storeCoins(0)
+            .storeMaybeRef(config.oracleConfig)
+            .storeCoins(config.feeRate)
+            .storeAddress(config.feeConfigurer)
+            .storeMaybeRef(config.whitelistedSettlers)
+            .storeUint(config.lockPeriod, 32)
+            .storeUint(config.lockCooldown, 32)
+            .endCell())
+            .storeRef((0, core_1.beginCell)()
+            .storeAddress(null)
+            .storeCoins(0)
+            .storeCoins(0)
+            .storeCoins(0)
+            .storeCoins(config.orderLimit ?? 1000n)
+            .storeCoins(config.asset0MinAmount ?? 0n)
+            .storeCoins(config.asset1MinAmount ?? 0n)
+            .storeRef((0, core_1.beginCell)()
+            .storeCoins(config.asset0MaxAmount ?? 0n)
+            .storeCoins(config.asset1MaxAmount ?? 0n)
+            .storeAddress(config.guardianAddress ?? null)
+            .storeCoins(0)
+            .storeCoins(0)
+            .endCell())
+            .endCell())
+            .endCell();
+        const init = { code, data };
+        return new RFQBatch((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendLock(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQBatch.Op.Lock, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQBatch.Op.Initialize, 32).endCell(),
+        });
+    }
+    static createOrderMsg(response, forwardTonAmount = 0n, forwardPayload) {
+        return (0, core_1.beginCell)()
+            .storeUint(RFQBatch.Op.AddOrder, 32)
+            .storeAddress(response)
+            .storeCoins(forwardTonAmount)
+            .storeMaybeRef(forwardPayload)
+            .endCell();
+    }
+    static createSettleMsg(oracleParams) {
+        return (0, core_1.beginCell)().storeUint(RFQBatch.Op.Settle, 32).storeMaybeRef(oracleParams).endCell();
+    }
+    async sendInitialize(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQBatch.Op.Initialize, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendAddOrder(provider, via, value, { isAsset0, amount, }) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(RFQBatch.Op.AddOrder, 32)
+                .storeUint(0, 64)
+                .storeBit(isAsset0)
+                .storeCoins(amount)
+                .endCell(),
+        });
+    }
+    async sendCancelOrder(provider, via, value, { assetIdx, }) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQBatch.Op.CancelOrder, 32).storeUint(0, 64).storeUint(assetIdx, 1).endCell(),
+        });
+    }
+    async sendIterOrders(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQBatch.Op.IterOrders, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendSettle(provider, via, value, { oracleParams, }) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQBatch.Op.Settle, 32).storeUint(0, 64).storeRef(oracleParams).endCell(),
+        });
+    }
+    async sendPayout(provider, via, value, { assetIdx, count, }) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(RFQBatch.Op.Payout, 32)
+                .storeUint(0, 64)
+                .storeUint(assetIdx, 1)
+                .storeCoins(count)
+                .endCell(),
+        });
+    }
+    async sendReopen(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQBatch.Op.Reopen, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendCollectFee(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(RFQBatch.Op.CollectFee, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    static parseRFQBatchEvent(externals) {
+        const msg = externals.map((item) => {
+            try {
+                if (item.info.dest?.value) {
+                    const op = Number(item.info.dest.value);
+                    const ds = item.body.asSlice();
+                    if (op === RFQBatch.Op.Initialize) {
+                        const storage = RFQBatch.parseRFQBatchStorage(ds.loadRef());
+                        return {
+                            name: "RFQBatch.Op.Initialize",
+                            op,
+                            success: true,
+                            storage,
+                        };
+                    }
+                    else if (op === RFQBatch.Op.VerifiedWallet) {
+                        const asset = ds.loadAddress();
+                        return {
+                            name: "RFQBatch.Op.VerifiedWallet",
+                            op,
+                            success: true,
+                            asset,
+                        };
+                    }
+                    else if (op === RFQBatch.Op.AddOrder) {
+                        const assetIdx = ds.loadUint(1);
+                        const amount = ds.loadCoins();
+                        const fromAddress = ds.loadAddress();
+                        return {
+                            name: "RFQBatch.Op.AddOrder",
+                            op,
+                            success: true,
+                            assetIdx,
+                            amount,
+                            fromAddress,
+                        };
+                    }
+                    else if (op === RFQBatch.Op.Lock) {
+                        const lockedTimestamp = ds.loadUint(40);
+                        const lockOwner = ds.loadAddress();
+                        return {
+                            name: "RFQBatch.Op.Lock",
+                            op,
+                            success: true,
+                            lockOwner,
+                            lockedTimestamp,
+                        };
+                    }
+                    else if (op === RFQBatch.Op.CancelOrder) {
+                        const assetIdx = ds.loadUint(1);
+                        const amount = ds.loadCoins();
+                        const fromAddress = ds.loadAddress();
+                        return {
+                            name: "RFQBatch.Op.CancelOrder",
+                            op,
+                            success: true,
+                            assetIdx,
+                            amount,
+                            fromAddress,
+                        };
+                    }
+                    else if (op === RFQBatch.Op.Settle) {
+                        const assetIdx = ds.loadUint(1);
+                        const fromAddress = ds.loadAddress();
+                        const currentPrice = ds.loadCoins();
+                        const targetPrice = ds.loadCoins();
+                        return {
+                            name: "RFQBatch.Op.Settle",
+                            op,
+                            success: true,
+                            assetIdx,
+                            fromAddress,
+                            currentPrice,
+                            targetPrice,
+                        };
+                    }
+                    else if (op === RFQBatch.Op.Payout) {
+                        const assetIdx = ds.loadUint(1);
+                        const count = ds.loadUint(16);
+                        const isRest = ds.loadBit();
+                        return {
+                            name: "RFQBatch.Op.Payout",
+                            op,
+                            success: true,
+                            assetIdx,
+                            count,
+                            isRest,
+                        };
+                    }
+                    else if (op === RFQBatch.Op.Reopen) {
+                        return {
+                            name: "RFQBatch.Op.Reopen",
+                            op,
+                            success: true,
+                        };
+                    }
+                }
+            }
+            catch (e) { }
+            return {
+                name: "Unknown op",
+                op: item.info.dest?.value ?? 0,
+                dest: item.info.dest?.value,
+            };
+        });
+        return msg;
+    }
+    static parseRFQBatchStorage(dataCell) {
+        const data = dataCell.beginParse();
+        const index = data.loadCoins();
+        const asset0Address = data.loadAddress();
+        const asset1Address = data.loadAddress();
+        const asset0TotalAmount = data.loadCoins();
+        const asset1TotalAmount = data.loadCoins();
+        const _asset0Orders = data.loadMaybeRef();
+        const _asset1Orders = data.loadMaybeRef();
+        const status = data.loadUint(8);
+        const lockedTimestamp = data.loadUint(40);
+        const additional1DS = data.loadRef().beginParse();
+        const asset0WalletAddress = additional1DS.loadMaybeAddress();
+        const asset1WalletAddress = additional1DS.loadMaybeAddress();
+        const aggregatorCode = additional1DS.loadRef();
+        const aggregatorIndex = additional1DS.loadCoins();
+        const oracleConfigRaw = additional1DS.loadMaybeRef();
+        const oracleConfig = oracleConfigRaw ? (0, parser_1.parseOracleConfig)(oracleConfigRaw) : null;
+        const feeRate = additional1DS.loadCoins();
+        const feeManager = additional1DS.loadMaybeAddress();
+        const _whitelistedSettlers = additional1DS.loadMaybeRef();
+        const lockPeriod = additional1DS.loadUint(32);
+        const lockCooldown = additional1DS.loadUint(32);
+        const additional2DS = data.loadRef().beginParse();
+        const lockOwner = additional2DS.loadMaybeAddress();
+        const asset0CollectedFee = additional2DS.loadCoins();
+        const asset1CollectedFee = additional2DS.loadCoins();
+        const orderCount = additional2DS.loadCoins();
+        const orderLimit = additional2DS.loadCoins();
+        const asset0MinAmount = additional2DS.loadCoins();
+        const asset1MinAmount = additional2DS.loadCoins();
+        const additional3DS = additional2DS.loadRef().beginParse();
+        const asset0MaxAmount = additional3DS.loadCoins();
+        const asset1MaxAmount = additional3DS.loadCoins();
+        const guardianAddress = additional3DS.loadMaybeAddress();
+        const asset0Price = additional3DS.loadCoins();
+        const asset1Price = additional3DS.loadCoins();
+        let asset0Orders = {};
+        let asset1Orders = {};
+        if (_asset0Orders) {
+            const _orders = _asset0Orders
+                .beginParse()
+                .loadDictDirect(core_1.Dictionary.Keys.Address(), RFQBatch.Dictionary.Values.Order());
+            _orders.keys().forEach((key) => {
+                asset0Orders[key.toString()] = _orders.get(key);
+            });
+        }
+        if (_asset1Orders) {
+            const _orders = _asset1Orders
+                .beginParse()
+                .loadDictDirect(core_1.Dictionary.Keys.Address(), RFQBatch.Dictionary.Values.Order());
+            _orders.keys().forEach((key) => {
+                asset1Orders[key.toString()] = _orders.get(key);
+            });
+        }
+        let whitelistedSettlers = {};
+        if (_whitelistedSettlers) {
+            const _settlers = _whitelistedSettlers
+                .beginParse()
+                .loadDictDirect(core_1.Dictionary.Keys.Address(), RFQBatch.Dictionary.Values.Empty());
+            _settlers.keys().forEach((key) => {
+                whitelistedSettlers[key.toString()] = true;
+            });
+        }
+        return {
+            index,
+            asset0Address,
+            asset1Address,
+            asset0TotalAmount,
+            asset1TotalAmount,
+            asset0Orders,
+            asset1Orders,
+            status,
+            lockedTimestamp,
+            lockOwner,
+            asset0WalletAddress,
+            asset1WalletAddress,
+            aggregatorIndex,
+            feeRate,
+            feeManager,
+            whitelistedSettlers,
+            lockPeriod,
+            lockCooldown,
+            asset0CollectedFee,
+            asset1CollectedFee,
+            orderCount,
+            orderLimit,
+            asset0MinAmount,
+            asset1MinAmount,
+            asset0MaxAmount,
+            asset1MaxAmount,
+            guardianAddress,
+            asset0Price,
+            asset1Price,
+            oracleConfig,
+        };
+    }
+    static Dictionary = {
+        Values: {
+            Order: () => ({
+                serialize: (src, builder) => { },
+                parse: (src) => {
+                    const amount = src.loadCoins();
+                    const response = src.loadAddress();
+                    const forwardTonAmount = src.loadCoins();
+                    const forwardPayload = src.loadMaybeRef();
+                    return {
+                        amount,
+                        response,
+                        forwardTonAmount,
+                        forwardPayload: forwardPayload ? forwardPayload.hash().toString("hex") : null,
+                    };
+                },
+            }),
+            Empty: () => ({
+                serialize: (src, builder) => { },
+                parse: (src) => {
+                    return null;
+                },
+            }),
+        },
+    };
+    async getRFQData(provider) {
+        const _state = await provider.getState();
+        if (_state.state.type !== "active")
+            throw "not active";
+        if (!_state.state.data)
+            throw "not active";
+        return RFQBatch.parseRFQBatchStorage(core_1.Cell.fromBoc(_state.state.data)[0]);
+    }
+    async getState(provider) {
+        const _state = await provider.getState();
+        return _state;
+    }
+}
+exports.RFQBatch = RFQBatch;

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

@@ -0,0 +1,132 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type RFQActionConfig = {
+    rfqAuctionCode: Cell;
+    rfqBatchCode: Cell;
+};
+export declare class RFQEventEmitter implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        EmitEvent: number;
+    };
+    static Error: {
+        UnknownOp: number;
+        Unauthorized: number;
+    };
+    static createFromAddress(address: Address): RFQEventEmitter;
+    static createFromConfig(config: RFQActionConfig, code: Cell, workchain?: number): RFQEventEmitter;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static parseRFQEvent(cell: Cell): {
+        parsed: boolean;
+        storage: {
+            initialized: boolean;
+            index: bigint;
+            state: number;
+            sellerAddress: Address;
+            verifiedSellWallet: boolean;
+            verifiedBuyWallet: boolean;
+            depositedSellAsset: boolean;
+            bids: Record<string, {
+                bidValue: bigint;
+                escrowAmount: bigint;
+                lt: bigint;
+                responseAddress: Address;
+                forwardTonAmount: bigint;
+                forwardPayload: string | null;
+            }>;
+            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;
+        };
+        rfqIndex: bigint;
+        ownerAddress: Address;
+        excessesAddress: Address;
+        op: number;
+        type: string;
+    } | {
+        parsed: boolean;
+        asset: Address;
+        rfqIndex: bigint;
+        ownerAddress: Address;
+        excessesAddress: Address;
+        op: number;
+        type: string;
+    } | {
+        parsed: boolean;
+        rfqIndex: bigint;
+        ownerAddress: Address;
+        excessesAddress: Address;
+        op: number;
+        type: string;
+    } | {
+        parsed: boolean;
+        bidder: Address;
+        bidValue: bigint;
+        escrowAmount: bigint;
+        lt: number;
+        rfqIndex: bigint;
+        ownerAddress: Address;
+        excessesAddress: Address;
+        op: number;
+        type: string;
+    } | {
+        parsed: boolean;
+        bidder: Address | null;
+        settleAmount: bigint;
+        rfqIndex: bigint;
+        ownerAddress: Address;
+        excessesAddress: Address;
+        op: number;
+        type: string;
+    } | {
+        parsed: boolean;
+        bidder: Address;
+        rfqIndex: bigint;
+        ownerAddress: Address;
+        excessesAddress: Address;
+        op: number;
+        type: string;
+    } | {
+        parsed: boolean;
+        count: bigint;
+        isRemaining: boolean;
+        rfqIndex: bigint;
+        ownerAddress: Address;
+        excessesAddress: Address;
+        op: number;
+        type: string;
+    } | {
+        rfqIndex: bigint;
+        ownerAddress: Address;
+        excessesAddress: Address;
+        op: number;
+        parsed: boolean;
+    } | null;
+}