@affluent-org/sdk 0.0.1

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFQEventEmitter = void 0;
+const core_1 = require("@ton/core");
+const rfq_auction_1 = require("../rfq_auction");
+class RFQEventEmitter {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        EmitEvent: 0xc8e85296,
+    };
+    static Error = {
+        UnknownOp: 0xffff,
+        Unauthorized: 1000,
+    };
+    static createFromAddress(address) {
+        return new RFQEventEmitter(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = (0, core_1.beginCell)().storeRef(config.rfqAuctionCode).storeRef(config.rfqBatchCode).endCell();
+        const init = { code, data };
+        return new RFQEventEmitter((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)().endCell(),
+        });
+    }
+    static parseRFQEvent(cell) {
+        try {
+            const body = cell.beginParse();
+            const opCode = body.loadUint(32);
+            const queryId = body.loadUintBig(64);
+            const rfqIndex = body.loadCoins();
+            const ownerAddress = body.loadAddress();
+            const excessesAddress = body.loadAddress();
+            const op = body.loadUint(32);
+            const result = {
+                rfqIndex,
+                ownerAddress,
+                excessesAddress,
+                op: op,
+            };
+            if (op === rfq_auction_1.RFQAuction.Op.Initialize) {
+                const storage = body.loadRef();
+                const data = rfq_auction_1.RFQAuction.parseRFQStorage(storage);
+                return {
+                    type: "RFQAuction.Op.Initialize",
+                    ...result,
+                    parsed: true,
+                    storage: data,
+                };
+            }
+            else if (op === rfq_auction_1.RFQAuction.Op.VerifiedWallet) {
+                const asset = body.loadAddress();
+                return {
+                    type: "RFQAuction.Op.VerifiedWallet",
+                    ...result,
+                    parsed: true,
+                    asset: asset,
+                };
+            }
+            else if (op === rfq_auction_1.RFQAuction.Op.Deposit) {
+                return {
+                    type: "RFQAuction.Op.Deposit",
+                    ...result,
+                    parsed: true,
+                };
+            }
+            else if (op === rfq_auction_1.RFQAuction.Op.Bid) {
+                const data = body.loadRef().beginParse();
+                const bidder = data.loadAddress();
+                const bidValue = data.loadCoins();
+                const escrowAmount = data.loadCoins();
+                const lt = data.loadUint(256);
+                return {
+                    type: "RFQAuction.Op.Bid",
+                    ...result,
+                    parsed: true,
+                    bidder,
+                    bidValue,
+                    escrowAmount,
+                    lt,
+                };
+            }
+            else if (op === rfq_auction_1.RFQAuction.Op.Settle) {
+                const bidder = body.loadMaybeAddress();
+                const settleAmount = body.loadCoins();
+                return {
+                    type: "RFQAuction.Op.Settle",
+                    ...result,
+                    parsed: true,
+                    bidder,
+                    settleAmount,
+                };
+            }
+            else if (op === rfq_auction_1.RFQAuction.Op.CancelRFQ) {
+                return {
+                    type: "RFQAuction.Op.CancelRFQ",
+                    ...result,
+                    parsed: true,
+                };
+            }
+            else if (op === rfq_auction_1.RFQAuction.Op.CancelBid) {
+                const bidder = body.loadAddress();
+                return {
+                    type: "RFQAuction.Op.CancelBid",
+                    ...result,
+                    parsed: true,
+                    bidder,
+                };
+            }
+            else if (op === rfq_auction_1.RFQAuction.Op.ClearBids) {
+                const count = body.loadCoins();
+                const isRemaining = body.loadBit();
+                return {
+                    type: "RFQAuction.Op.ClearBids",
+                    ...result,
+                    parsed: true,
+                    count,
+                    isRemaining,
+                };
+            }
+            return {
+                rfqIndex,
+                ownerAddress,
+                excessesAddress,
+                op: op,
+                parsed: false,
+            };
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+exports.RFQEventEmitter = RFQEventEmitter;

package/dist/contracts/stonfi-farm/MockStonfiFarmItem.d.ts

@@ -0,0 +1,41 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type StonfiFarmConfig = {
+    owner: Address;
+    lpToken: Address;
+    rewardToken: Address;
+    farmItemCode: Cell;
+};
+export declare function stonfiFarmConfigToCell(config: StonfiFarmConfig): Cell;
+export declare const Opcodes: {
+    setPrice: number;
+};
+export declare class MockStonfiFarmItem implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): MockStonfiFarmItem;
+    static createFromConfig(config: StonfiFarmConfig, code: Cell, workchain?: number): MockStonfiFarmItem;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendSetPrice(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        assetId: bigint;
+        price: bigint;
+        queryID?: number;
+    }): Promise<void>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    getFarmItemData(provider: ContractProvider): Promise<{
+        minter: Address | null;
+        index: bigint;
+        owner: Address | null;
+        amount: bigint | null;
+        reward_amount: bigint | null;
+        last_claim_time: bigint | null;
+    }>;
+    getFarmItemAddress(provider: ContractProvider, index: bigint): Promise<Address | null>;
+}

package/dist/contracts/stonfi-farm/MockStonfiFarmItem.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockStonfiFarmItem = exports.Opcodes = void 0;
+exports.stonfiFarmConfigToCell = stonfiFarmConfigToCell;
+const core_1 = require("@ton/core");
+function stonfiFarmConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeCoins(0)
+        .storeAddress(config.owner)
+        .storeAddress(config.lpToken)
+        .storeAddress(config.rewardToken)
+        .storeRef(config.farmItemCode)
+        .endCell();
+}
+exports.Opcodes = {
+    setPrice: 0xf990365,
+};
+class MockStonfiFarmItem {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new MockStonfiFarmItem(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = stonfiFarmConfigToCell(config);
+        const init = { code, data };
+        return new MockStonfiFarmItem((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)().endCell(),
+        });
+    }
+    async sendSetPrice(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.Opcodes.setPrice, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.assetId, 64)
+                .storeCoins(opts.price)
+                .endCell(),
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getFarmItemData(provider) {
+        const result = await provider.get("get_farm_item_data", []);
+        const minter = result.stack.readAddressOpt();
+        const index = result.stack.readBigNumber();
+        const owner = result.stack.readAddressOpt();
+        const amount = result.stack.readBigNumberOpt();
+        const reward_amount = result.stack.readBigNumberOpt();
+        const last_claim_time = result.stack.readBigNumberOpt();
+        return {
+            minter,
+            index,
+            owner,
+            amount,
+            reward_amount,
+            last_claim_time,
+        };
+    }
+    async getFarmItemAddress(provider, index) {
+        const result = await provider.get("get_item_address", [
+            {
+                type: "int",
+                value: index,
+            },
+        ]);
+        const address = result.stack.readAddressOpt();
+        return address;
+    }
+}
+exports.MockStonfiFarmItem = MockStonfiFarmItem;

package/dist/contracts/stonfi-farm/MockStonfiFarmMinter.d.ts

@@ -0,0 +1,45 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type StonfiFarmConfig = {
+    owner: Address;
+    lpToken: Address;
+    rewardToken: Address;
+    farmItemCode: Cell;
+};
+export declare function stonfiFarmConfigToCell(config: StonfiFarmConfig): Cell;
+export declare const Opcodes: {
+    setPrice: number;
+    setLPWallet: number;
+};
+export declare class MockStonfiFarmMinter implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): MockStonfiFarmMinter;
+    static createFromConfig(config: StonfiFarmConfig, code: Cell, workchain?: number): MockStonfiFarmMinter;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendSetLPAddr(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: bigint;
+        lp: Address;
+        reward: Address;
+    }): Promise<void>;
+    sendSetPrice(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        assetId: bigint;
+        price: bigint;
+        queryID?: number;
+    }): Promise<void>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    getFarmData(provider: ContractProvider): Promise<{
+        index: bigint;
+        owner: Address | null;
+        lpToken: Address | null;
+        rewardToken: Address | null;
+    }>;
+    getFarmItemAddress(provider: ContractProvider, index: bigint): Promise<Address>;
+}

package/dist/contracts/stonfi-farm/MockStonfiFarmMinter.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockStonfiFarmMinter = exports.Opcodes = void 0;
+exports.stonfiFarmConfigToCell = stonfiFarmConfigToCell;
+const core_1 = require("@ton/core");
+function stonfiFarmConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeCoins(0)
+        .storeAddress(config.owner)
+        .storeAddress(config.lpToken)
+        .storeAddress(config.rewardToken)
+        .storeRef(config.farmItemCode)
+        .endCell();
+}
+exports.Opcodes = {
+    setPrice: 0xf990365,
+    setLPWallet: 0xd29c540a,
+};
+class MockStonfiFarmMinter {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new MockStonfiFarmMinter(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = stonfiFarmConfigToCell(config);
+        const init = { code, data };
+        return new MockStonfiFarmMinter((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)().endCell(),
+        });
+    }
+    async sendSetLPAddr(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.Opcodes.setLPWallet, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeAddress(opts.lp)
+                .storeAddress(opts.reward)
+                .endCell(),
+        });
+    }
+    async sendSetPrice(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.Opcodes.setPrice, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.assetId, 64)
+                .storeCoins(opts.price)
+                .endCell(),
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getFarmData(provider) {
+        const result = await provider.get("get_farm_data", []);
+        const index = result.stack.readBigNumber();
+        const owner = result.stack.readAddressOpt();
+        const lpToken = result.stack.readAddressOpt();
+        const rewardToken = result.stack.readAddressOpt();
+        return {
+            index,
+            owner,
+            lpToken,
+            rewardToken,
+        };
+    }
+    async getFarmItemAddress(provider, index) {
+        const result = await provider.get("get_item_address", [
+            {
+                type: "int",
+                value: index,
+            },
+        ]);
+        const address = result.stack.readAddress();
+        return address;
+    }
+}
+exports.MockStonfiFarmMinter = MockStonfiFarmMinter;

package/dist/contracts/unknown-contract/index.d.ts

@@ -0,0 +1,14 @@
+import { Address, Cell, Contract, ContractProvider } from "@ton/core";
+export declare class UnknownContract implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): UnknownContract;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+}

package/dist/contracts/unknown-contract/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownContract = void 0;
+class UnknownContract {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new UnknownContract(address);
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+}
+exports.UnknownContract = UnknownContract;

package/dist/contracts/vault/share-vault/index.d.ts

@@ -0,0 +1,206 @@
+import { Address, Cell, Contract, Builder, ContractProvider, Sender, Slice } from "@ton/core";
+export declare class ShareVault implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        SetWhitelistPools: number;
+        SetTargetWeight: number;
+        SetGasFee: number;
+        ChangeManager: number;
+        UpgradeCode: number;
+        ChangeAdmin: number;
+        SupplyToPool: number;
+        WithdrawFromPool: number;
+        Supply: number;
+        Withdraw: number;
+        RequestAssetWalletAddress: number;
+        ActionNotification: number;
+        ProvideAggregatedPool: number;
+        TakeAggregatedPool: number;
+    };
+    static Error: {
+        UnknownOp: number;
+        InvalidWallet: number;
+        InvalidAddress: number;
+        NotFoundPoolState: number;
+        ActionTimeout: number;
+        InvalidBurnRequest: number;
+        NotWhitelistedPool: number;
+        NotEnoughCash: number;
+        NotEnoughBalance: number;
+    };
+    static Gas: {
+        baseFee: bigint;
+    };
+    static createFromAddress(address: Address): ShareVault;
+    sendMsgBody(provider: ContractProvider, via: Sender, value: bigint, body: Cell): Promise<Cell>;
+    sendSetTargetWeight(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: number;
+        pool: Address;
+        targetWeight: number;
+    }): Promise<Cell>;
+    sendSetGasFee(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: bigint;
+        gasFee: ShareVaultGasConfig;
+    }): Promise<Cell>;
+    sendSupplyToPool(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: number;
+        pool: Address;
+        amount: bigint;
+    }): Promise<Cell>;
+    sendWithdrawFromPool(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: number;
+        pool: Address;
+        isShare: Boolean;
+        amount: bigint;
+    }): Promise<Cell>;
+    sendChangeManager(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: number;
+        address: Address;
+    }): Promise<void>;
+    sendChangeAdmin(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: number;
+        address: Address;
+    }): Promise<void>;
+    static createChangeAdminMsgBody(opts: {
+        queryID?: number;
+        address: Address;
+    }): Cell;
+    static parseChangeAdminMsgBody(cell: Cell): {
+        op: number;
+        queryID: number;
+        address: Address;
+    };
+    static createSetGasConfigMsgBody(params: {
+        queryID?: bigint;
+        gasFee: ShareVaultGasConfig;
+    }): Cell;
+    static createSetWhitelistPoolsMsgBody(params: {
+        queryID?: bigint;
+        whitelists: [Address, 0 | 1][];
+    }): Cell;
+    static createChangeManagerMsgBody(params: {
+        queryID?: bigint;
+        manager: Address;
+    }): Cell;
+    static createWhitelistsCell(whitelists: [Address, 0 | 1][]): Cell;
+    getWalletAddress(provider: ContractProvider, address: Address): Promise<Address>;
+    getPoolAggregatorAddress(provider: ContractProvider, address: Address): Promise<Address>;
+    static calculateGasFee(actionOp: number, baseFee: bigint, poolCount: number, gas: ShareVaultGasConfig, isWTON?: boolean): bigint;
+    getJettonData(provider: ContractProvider): Promise<{
+        totalSupply: bigint;
+        admin: Address;
+        content: string | null;
+    }>;
+    sendUpgradeCode(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryID?: number;
+        newCode: Cell;
+    }): Promise<void>;
+    getVaultData(provider: ContractProvider): Promise<{
+        totalSupply: bigint;
+        owner: Address | null;
+        manager: Address | null;
+        asset: Address;
+        balance: bigint;
+        cash: bigint;
+        totalTargetWeight: bigint;
+        nextAggregatorIndex: bigint;
+        isWtonVault: boolean;
+        assetWallet: Address | null;
+        whitelistedPools: Record<string, {
+            isWhitelisted: boolean;
+            targetWeight: bigint;
+            supply: bigint;
+        } & {
+            address: Address;
+        }>;
+        minimumGasFee: {
+            supply: bigint;
+            withdraw: bigint;
+            factorialSupply: bigint;
+            factorialWithdraw: bigint;
+            mintVaultShareTokens: bigint;
+        };
+        code: Cell;
+        address: Address;
+    }>;
+    static parseVaultData(_data: Cell): {
+        totalSupply: bigint;
+        owner: Address | null;
+        manager: Address | null;
+        asset: Address;
+        balance: bigint;
+        cash: bigint;
+        totalTargetWeight: bigint;
+        nextAggregatorIndex: bigint;
+        isWtonVault: boolean;
+        assetWallet: Address | null;
+        whitelistedPools: Record<string, {
+            isWhitelisted: boolean;
+            targetWeight: bigint;
+            supply: bigint;
+        } & {
+            address: Address;
+        }>;
+        minimumGasFee: {
+            supply: bigint;
+            withdraw: bigint;
+            factorialSupply: bigint;
+            factorialWithdraw: bigint;
+            mintVaultShareTokens: bigint;
+        };
+    };
+    static parseGasConfig(cell: Cell): {
+        supply: bigint;
+        withdraw: bigint;
+        factorialSupply: bigint;
+        factorialWithdraw: bigint;
+        mintVaultShareTokens: bigint;
+    };
+    static createSupplyForwardPayload(opts: {
+        responseAddress: Address;
+        jettonForwardTonAmount?: bigint;
+        jettonForwardPayload?: Cell;
+        actionForwardTonAmount?: bigint;
+        actionForwardPayload?: Cell;
+    }): Cell;
+    static createWithdrawForwardPayload(opts?: {
+        jettonForwardTonAmount?: bigint;
+        jettonForwardPayload?: Cell;
+        actionForwardTonAmount?: bigint;
+        actionForwardPayload?: Cell;
+    }): Cell;
+    static createSetGasFeeMsgBody(opts: {
+        queryID?: number;
+        gasFee: Cell;
+    }): Cell;
+    static parseSetGasFeeMsgBody(cell: Cell): {
+        op: number;
+        queryID: number;
+        gasFee: Cell;
+    };
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    static createUpgradeCodeMsgBody(opts: {
+        queryID?: number;
+        newCode: Cell;
+    }): Cell;
+}
+declare const DictioryValueAccountWhitelistPool: {
+    serialize: (src: any, builder: Builder) => void;
+    parse: (src: Slice) => {
+        isWhitelisted: boolean;
+        targetWeight: bigint;
+        supply: bigint;
+    };
+};
+export type WhitelistedPoolData = ReturnType<(typeof DictioryValueAccountWhitelistPool)["parse"]>;
+export type ShareVaultState = Awaited<ReturnType<ShareVault["getVaultData"]>>;
+export type ShareVaultGasConfig = ReturnType<(typeof ShareVault)["parseGasConfig"]>;
+export {};