@affluent-org/sdk 0.0.1

package/dist/contracts/liquid_token/dedust/wallet.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LFDedustJettonWallet = exports.Opcodes = void 0;
+exports.jettonWalletConfigToCell = jettonWalletConfigToCell;
+const core_1 = require("@ton/core");
+function jettonWalletConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeCoins(0)
+        .storeCoins(0)
+        .storeAddress(config.owner)
+        .storeUint(0, 4)
+        .storeRef((0, core_1.beginCell)().storeAddress(config.minter).storeAddress(config.lockedAsset).storeAddress(config.pool).endCell())
+        .endCell();
+}
+exports.Opcodes = {
+    Mint: 21,
+    InternalTransfer: 0x178d4519,
+    Transfer: 0xf8a7ea5,
+    Burn: 0x595f07bc,
+};
+class LFDedustJettonWallet {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        Mint: 21,
+        InternalTransfer: 0x178d4519,
+        Transfer: 0xf8a7ea5,
+        Burn: 0x595f07bc,
+        Initialize: 0xbe5a7595,
+        Seize: 0x7df57cb6,
+        SeizeInternal: 0x64486eca,
+        SeizeFail: 0x4cf20f42,
+        ConnectPoolAccount: 0x8d989d7d,
+        TransferNotification: 0x7362d09c,
+        ClaimRewards: 0x78d9f109,
+        WithdrawTons: 0x6d8e5e3c,
+        WithdrawJettons: 0x768a50b2,
+        DedustClaim: 0xc077194f,
+    };
+    static Error = {
+        InvalidWalletAddress: 1000,
+        Unauthorized: 1001,
+        NotEnoughBalance: 1002,
+        NotEnoughLockedAssetBalance: 1003,
+        EnoughLockedAssetBalance: 1004,
+    };
+    static createFromAddress(address) {
+        return new LFDedustJettonWallet(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jettonWalletConfigToCell(config);
+        const init = { code, data };
+        return new LFDedustJettonWallet((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 sendInitialize(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(LFDedustJettonWallet.Op.Initialize, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendConnectPoolAccount(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(LFDedustJettonWallet.Op.ConnectPoolAccount, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    async sendTransfer(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.Transfer, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeCoins(opts.amount)
+                .storeAddress(opts.recipient) //
+                .storeAddress(opts.response || opts.recipient)
+                .storeDict(null)
+                .storeCoins(opts.notificationGas ? opts.notificationGas : (0, core_1.toNano)(0.05)) // forward-ton-amount 이게 없으면 transfer_notification 호출 안될수도.
+                .storeMaybeRef(opts.additional)
+                .endCell(),
+        });
+    }
+    async sendBurn(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opts.opcode ? opts.opcode : exports.Opcodes.Burn, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeCoins(opts.amount) //
+                .storeAddress(opts.recipientAddress)
+                .storeAddress(opts.responseAddress)
+                .endCell(),
+        });
+    }
+    async sendSeize(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opts.opcode ? opts.opcode : LFDedustJettonWallet.Op.Seize, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeCoins(opts.amount) //
+                .storeAddress(opts.targetAddress)
+                .storeAddress(opts.responseAddress)
+                .endCell(),
+        });
+    }
+    async sendClaimRewards(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFDedustJettonWallet.Op.ClaimRewards, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeAddress(opts.distributorAddress)
+                .storeRef(opts.proof)
+                .endCell(),
+        });
+    }
+    async sendWithdrawTons(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFDedustJettonWallet.Op.WithdrawTons, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .endCell(),
+        });
+    }
+    async sendWithdrawJettons(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(LFDedustJettonWallet.Op.WithdrawJettons, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeAddress(opts.wallet)
+                .storeCoins(opts.amount)
+                .storeBit(0)
+                .endCell(),
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getWalletData(provider) {
+        try {
+            const _result = await provider.get("get_wallet_data", []);
+            const balance = _result.stack.readBigNumber();
+            const owner = _result.stack.readAddress();
+            const jetton = _result.stack.readAddress();
+            return {
+                balance,
+                owner,
+                jetton,
+            };
+        }
+        catch (e) {
+            return {
+                balance: 0n,
+            };
+        }
+    }
+    async getLiquidFarmData(provider) {
+        try {
+            const _result = await provider.get("get_liquid_farm_data", []);
+            const balance = _result.stack.readBigNumber();
+            const lockedAssetBalance = _result.stack.readBigNumber();
+            const jettonAddress = _result.stack.readAddress();
+            const assetWalletAddress = _result.stack.readAddressOpt();
+            const poolAccountAddress = _result.stack.readAddressOpt();
+            const connectedWithPoolAccount = _result.stack.readBoolean();
+            const ownerAddress = _result.stack.readAddress();
+            const assetAddress = _result.stack.readAddress();
+            const poolAddress = _result.stack.readAddress();
+            return {
+                deployed: true,
+                balance,
+                lockedAssetBalance,
+                jettonAddress,
+                assetWalletAddress,
+                poolAccountAddress,
+                connectedWithPoolAccount,
+                ownerAddress,
+                assetAddress,
+                poolAddress,
+            };
+        }
+        catch (e) {
+            console.log(e);
+            return {
+                deployed: false,
+                balance: 0n,
+                lockedAssetBalance: 0n,
+            };
+        }
+    }
+}
+exports.LFDedustJettonWallet = LFDedustJettonWallet;

package/dist/contracts/liquid_token/stonfi/LFStonfiJettonMinter.d.ts

@@ -0,0 +1,53 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type JettonMinterConfig = {
+    admin: Address;
+    content?: Cell;
+    walletCode: Cell;
+    asset: Address;
+    pool: Address;
+    farm: Address;
+};
+export type JettonMinterContent = {
+    type: 0 | 1;
+    uri: string;
+};
+export declare function jettonContentToCell(content: JettonMinterContent): Cell;
+export declare function jettonMinterConfigToCell(config: JettonMinterConfig): Cell;
+export declare const Opcodes: {
+    Mint: number;
+    InternalTransfer: number;
+    DeployWallet: number;
+};
+export declare class LFStonfiJettonMinter 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): LFStonfiJettonMinter;
+    static createFromConfig(config: JettonMinterConfig, code: Cell, workchain?: number): LFStonfiJettonMinter;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendDeployWallet(provider: ContractProvider, via: Sender, opts: {
+        recipient: Address;
+        value: bigint;
+        opcode?: number;
+        queryId?: bigint;
+    }): Promise<void>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    getWLPJettonData(provider: ContractProvider): Promise<{
+        totalSupply: bigint;
+        adminAddress: Address;
+        assetAddress: Address;
+        poolAddress: Address;
+        farmAddress: Address;
+    }>;
+    getWalletAddress(provider: ContractProvider, address: Address): Promise<Address>;
+    getJettonData(provider: ContractProvider): Promise<{
+        totalSupply: bigint;
+        admin: Address;
+    }>;
+}

package/dist/contracts/liquid_token/stonfi/LFStonfiJettonMinter.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LFStonfiJettonMinter = exports.Opcodes = void 0;
+exports.jettonContentToCell = jettonContentToCell;
+exports.jettonMinterConfigToCell = jettonMinterConfigToCell;
+const core_1 = require("@ton/core");
+function jettonContentToCell(content) {
+    return (0, core_1.beginCell)()
+        .storeUint(content.type, 8)
+        .storeStringTail(content.uri) //Snake logic under the hood
+        .endCell();
+}
+function jettonMinterConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeCoins(0)
+        .storeAddress(config.admin)
+        .storeRef(config.content ? config.content : (0, core_1.beginCell)().endCell())
+        .storeRef(config.walletCode)
+        .storeRef((0, core_1.beginCell)().storeAddress(config.asset).storeAddress(config.pool).storeAddress(config.farm).endCell())
+        .endCell();
+}
+exports.Opcodes = {
+    Mint: 0x1674b0a0,
+    InternalTransfer: 0x178d4519,
+    DeployWallet: 0x12171766,
+};
+class LFStonfiJettonMinter {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new LFStonfiJettonMinter(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jettonMinterConfigToCell(config);
+        const init = { code, data };
+        return new LFStonfiJettonMinter((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 sendDeployWallet(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opts.opcode ? opts.opcode : exports.Opcodes.DeployWallet, 32) // opcode
+                .storeUint(opts.queryId ?? 0, 64) // query id
+                .storeAddress(opts.recipient) //
+                .endCell(),
+        });
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getWLPJettonData(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].beginParse();
+        const totalSupply = data.loadCoins();
+        const adminAddress = data.loadAddress();
+        const content = data.loadRef();
+        const jettonWalletCode = data.loadRef();
+        const addressCell = data.loadRef();
+        const addressData = addressCell.beginParse();
+        const assetAddress = addressData.loadAddress();
+        const poolAddress = addressData.loadAddress();
+        const farmAddress = addressData.loadAddress();
+        return {
+            totalSupply,
+            adminAddress,
+            // content,
+            // jettonWalletCode,
+            assetAddress,
+            poolAddress,
+            farmAddress,
+            // addressCell,
+        };
+    }
+    async getWalletAddress(provider, address) {
+        const tis = {
+            type: "slice",
+            cell: (0, core_1.beginCell)().storeAddress(address).endCell(),
+        };
+        const result = await provider.get("get_wallet_address", [tis]);
+        return result.stack.readAddress();
+    }
+    async getJettonData(provider) {
+        const _result = await provider.get("get_jetton_data", []);
+        // console.log(_result);
+        const totalSupply = _result.stack.readBigNumber();
+        _result.stack.readBigNumber();
+        const admin = _result.stack.readAddress();
+        return {
+            totalSupply,
+            admin,
+        };
+    }
+}
+exports.LFStonfiJettonMinter = LFStonfiJettonMinter;

package/dist/contracts/liquid_token/stonfi/LFStonfiJettonWallet.d.ts

@@ -0,0 +1,169 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type JettonWalletConfig = {
+    owner: Address;
+    minter: Address;
+    lockedAsset: Address;
+    pool: Address;
+};
+export declare function jettonWalletConfigToCell(config: JettonWalletConfig): Cell;
+export declare const Opcodes: {
+    Mint: number;
+    InternalTransfer: number;
+    Transfer: number;
+    Burn: number;
+};
+export declare class LFStonfiJettonWallet implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        Mint: number;
+        InternalTransfer: number;
+        Transfer: number;
+        Burn: number;
+        Initialize: number;
+        Seize: number;
+        SeizeInternal: number;
+        SeizeFail: number;
+        Farm: number;
+        Unfarm: number;
+        ConnectPoolAccount: number;
+        TransferNotification: number;
+        SyncLockedAssetCash: number;
+        ClaimRewards: number;
+        WithdrawTons: number;
+        WithdrawJettons: number;
+    };
+    static Error: {
+        UnknownOp: number;
+        WrongWorkchain: number;
+        UnauthorizedTransfer: number;
+        NotEnoughJettons: number;
+        UnauthorizedIncomingTransfer: number;
+        MalformedForwardPayload: number;
+        NotEnoughTons: number;
+        BurnFeeNotMatched: number;
+        UnknownAction: number;
+        UnknownActionBounced: number;
+        DiscoveryFeeNotMatched: number;
+        UnauthorizedMintRequest: number;
+        UnauthorizedBurnRequest: number;
+        UnauthorizedChangeAdminRequest: number;
+        UnauthorizedChangeContentRequest: number;
+        InvalidWalletAddress: number;
+        Unauthorized: number;
+        NotEnoughBalance: number;
+        NotEnoughLockedAssetBalance: number;
+        EnoughLockedAssetBalance: number;
+        NotEnoughLockedAssetCash: number;
+        SyncInProcess: number;
+        InvalidExpectCash: number;
+    };
+    static createFromAddress(address: Address): LFStonfiJettonWallet;
+    static createFromConfig(config: JettonWalletConfig, code: Cell, workchain?: number): LFStonfiJettonWallet;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendInitialize(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendConnectPoolAccount(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendFarm(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: bigint;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+    }): Promise<void>;
+    sendUnfarm(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: bigint;
+        nftAddress: Address;
+    }): Promise<void>;
+    sendSyncLockedAssetCash(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: bigint;
+    }): Promise<void>;
+    sendTransferNotification(provider: ContractProvider, via: Sender, opts: {
+        amount: bigint;
+        value: bigint;
+        fromAddress: Address;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendTransfer(provider: ContractProvider, via: Sender, opts: {
+        notificationGas?: bigint;
+        recipient: Address;
+        response?: Address;
+        amount: bigint;
+        value: bigint;
+        additional?: Cell;
+        queryId?: number;
+    }): Promise<void>;
+    sendBurn(provider: ContractProvider, via: Sender, opts: {
+        amount: bigint;
+        value: bigint;
+        recipientAddress: Address;
+        responseAddress: Address;
+        opcode?: number;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendSeize(provider: ContractProvider, via: Sender, opts: {
+        amount: bigint;
+        value: bigint;
+        targetAddress: Address;
+        responseAddress: Address;
+        opcode?: number;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendClaimRewards(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        nftAddress: Address;
+        claimAll: boolean;
+        poolIndex: number;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendWithdrawTons(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: bigint;
+    }): Promise<void>;
+    sendWithdrawJettons(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        wallet: Address;
+        amount: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    getWalletData(provider: ContractProvider): Promise<{
+        balance: bigint;
+        owner: Address;
+        jetton: Address;
+    } | {
+        balance: bigint;
+        owner?: undefined;
+        jetton?: undefined;
+    }>;
+    getLiquidFarmData(provider: ContractProvider): Promise<{
+        deployed: boolean;
+        balance: bigint;
+        lockedAssetBalance: bigint;
+        lockedAssetCash: bigint;
+        lockedAssetCashBeforeSync: bigint;
+        jettonAddress: Address;
+        assetWalletAddress: Address | null;
+        poolAccountAddress: Address | null;
+        connectedWithPoolAccount: boolean;
+        ownerAddress: Address;
+        assetAddress: Address;
+        poolAddress: Address;
+    } | {
+        deployed: boolean;
+        balance: bigint;
+        lockedAssetBalance: bigint;
+        lockedAssetCash: bigint;
+        lockedAssetCashBeforeSync: bigint;
+        jettonAddress?: undefined;
+        assetWalletAddress?: undefined;
+        poolAccountAddress?: undefined;
+        connectedWithPoolAccount?: undefined;
+        ownerAddress?: undefined;
+        assetAddress?: undefined;
+        poolAddress?: undefined;
+    }>;
+}