@affluent-org/sdk 0.0.1

package/dist/contracts/irm/jump-irm/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/jetton/jetton-minter.d.ts

@@ -0,0 +1,23 @@
+import { Address, Cell, Contract, ContractProvider, OpenedContract } from "@ton/ton";
+import { JettonWallet } from "./jetton-wallet";
+import { AddressInput } from "../common/type";
+export declare class JettonMinter 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): JettonMinter;
+    getState(provider: ContractProvider): Promise<import("@ton/ton").ContractState>;
+    getWalletAddress(provider: ContractProvider, address: Address): Promise<Address>;
+    getJettonData(provider: ContractProvider): Promise<{
+        totalSupply: bigint;
+        admin: Address;
+        content: string | null;
+    }>;
+    getWallet(provider: ContractProvider, address: AddressInput): Promise<OpenedContract<JettonWallet>>;
+}

package/dist/contracts/jetton/jetton-minter.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonMinter = void 0;
+const ton_1 = require("@ton/ton");
+const jetton_wallet_1 = require("./jetton-wallet");
+const utils_1 = require("../common/utils");
+class JettonMinter {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new JettonMinter(address);
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getWalletAddress(provider, address) {
+        const result = await provider.get("get_wallet_address", [
+            {
+                type: "slice",
+                cell: (0, ton_1.beginCell)().storeAddress(address).endCell(),
+            },
+        ]);
+        return result.stack.readAddress();
+    }
+    async getJettonData(provider) {
+        const _result = await provider.get("get_jetton_data", []);
+        const totalSupply = _result.stack.readBigNumber();
+        _result.stack.readBigNumber();
+        const admin = _result.stack.readAddress();
+        const content = _result.stack.readStringOpt();
+        return {
+            totalSupply,
+            admin,
+            content,
+        };
+    }
+    async getWallet(provider, address) {
+        const walletAddress = await this.getWalletAddress(provider, (0, utils_1.toAddress)(address));
+        return provider.open(jetton_wallet_1.JettonWallet.createFromAddress(walletAddress));
+    }
+}
+exports.JettonMinter = JettonMinter;

package/dist/contracts/jetton/jetton-wallet.d.ts

@@ -0,0 +1,67 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/ton";
+import { WalletState } from "./type";
+export declare class JettonWallet implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        TransferNotification: number;
+        InternalTransfer: number;
+        Transfer: number;
+        Burn: number;
+        Excesses: number;
+        BurnNotification: number;
+    };
+    static Gas: {
+        Transfer: bigint;
+    };
+    static createFromAddress(address: Address): JettonWallet;
+    sendTransfer(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        amount: bigint;
+        recipient: Address;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload?: Cell;
+        queryId?: bigint;
+    }): Promise<Cell>;
+    createTransferBody(opts: {
+        queryId?: bigint;
+        recipient: Address;
+        response: Address;
+        amount: bigint;
+        forwardTonAmount: bigint;
+        forwardPayload?: Cell;
+    }): Cell;
+    static createTransferBody(opts: {
+        queryId?: bigint;
+        recipient: Address;
+        response: Address;
+        amount: bigint;
+        forwardTonAmount: bigint;
+        forwardPayload?: Cell;
+    }): Cell;
+    static getBurnMsgBody(opts: {
+        amount: bigint;
+        response: Address;
+    }): Cell;
+    sendBurn(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        amount: bigint;
+        response: Address;
+        forwardPayload?: Cell;
+        queryId?: bigint;
+    }): Promise<Cell>;
+    getState(provider: ContractProvider): Promise<import("@ton/ton").ContractState>;
+    getWalletData(provider: ContractProvider): Promise<WalletState>;
+    createBurnBody(opts: {
+        amount: bigint;
+        response: Address;
+        forwardPayload?: Cell;
+        queryId?: bigint;
+    }): Cell;
+}

package/dist/contracts/jetton/jetton-wallet.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonWallet = void 0;
+const ton_1 = require("@ton/ton");
+class JettonWallet {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        TransferNotification: 0x7362d09c,
+        InternalTransfer: 0x178d4519,
+        Transfer: 0xf8a7ea5,
+        Burn: 0x595f07bc,
+        Excesses: 0xd53276db,
+        BurnNotification: 0x7bdd97de,
+    };
+    static Gas = {
+        Transfer: (0, ton_1.toNano)(0.05),
+    };
+    static createFromAddress(address) {
+        return new JettonWallet(address);
+    }
+    async sendTransfer(provider, via, value, opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(JettonWallet.Op.Transfer, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.recipient)
+            .storeAddress(opts.response)
+            .storeDict(null)
+            .storeCoins(opts.forwardTonAmount)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+        await provider.internal(via, {
+            value: value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body,
+        });
+        return body;
+    }
+    createTransferBody(opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(JettonWallet.Op.Transfer, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.recipient)
+            .storeAddress(opts.response)
+            .storeDict(null)
+            .storeCoins(opts.forwardTonAmount)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+        return body;
+    }
+    static createTransferBody(opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(JettonWallet.Op.Transfer, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.recipient)
+            .storeAddress(opts.response)
+            .storeDict(null)
+            .storeCoins(opts.forwardTonAmount)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+        return body;
+    }
+    static getBurnMsgBody(opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(JettonWallet.Op.Burn, 32)
+            .storeUint(0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.response)
+            .endCell();
+        return body;
+    }
+    async sendBurn(provider, via, value, opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(JettonWallet.Op.Burn, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.response)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+        await provider.internal(via, {
+            value: value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body,
+        });
+        return body;
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getWalletData(provider) {
+        const _result = await provider.get("get_wallet_data", []);
+        const balance = _result.stack.readBigNumber();
+        const owner = _result.stack.readAddress();
+        const jetton = _result.stack.readAddress();
+        return {
+            address: this.address,
+            balance,
+            owner,
+            jetton,
+        };
+    }
+    createBurnBody(opts) {
+        return (0, ton_1.beginCell)()
+            .storeUint(JettonWallet.Op.Burn, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.response)
+            .storeMaybeRef(opts.forwardPayload ?? null)
+            .endCell();
+    }
+}
+exports.JettonWallet = JettonWallet;

package/dist/contracts/jetton/type.d.ts

@@ -0,0 +1,7 @@
+import { Address } from "@ton/core";
+export type WalletState = {
+    address: Address;
+    balance: bigint;
+    owner: Address;
+    jetton: Address;
+};

package/dist/contracts/jetton/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/liquid_token/dedust/minter.d.ts

@@ -0,0 +1,56 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+export type JettonMinterConfig = {
+    admin: Address;
+    content?: Cell;
+    walletCode: Cell;
+    asset: Address;
+    pool: 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 LFDedustJettonMinter 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;
+        DeployWallet: number;
+    };
+    static createFromAddress(address: Address): LFDedustJettonMinter;
+    static createFromConfig(config: JettonMinterConfig, code: Cell, workchain?: number): LFDedustJettonMinter;
+    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;
+    }>;
+    getWalletAddress(provider: ContractProvider, address: Address): Promise<Address>;
+    getJettonData(provider: ContractProvider): Promise<{
+        totalSupply: bigint;
+        admin: Address;
+    }>;
+}

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LFDedustJettonMinter = 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)
+        .storeAddress(config.asset)
+        .storeAddress(config.pool)
+        .storeRef(config.content ? config.content : (0, core_1.beginCell)().endCell())
+        .storeRef(config.walletCode)
+        .endCell();
+}
+exports.Opcodes = {
+    Mint: 0x1674b0a0,
+    InternalTransfer: 0x178d4519,
+    DeployWallet: 0x12171766,
+};
+class LFDedustJettonMinter {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        Mint: 0x1674b0a0,
+        InternalTransfer: 0x178d4519,
+        DeployWallet: 0x12171766,
+    };
+    static createFromAddress(address) {
+        return new LFDedustJettonMinter(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jettonMinterConfigToCell(config);
+        const init = { code, data };
+        return new LFDedustJettonMinter((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(); // Load total supply
+        const adminAddress = data.loadAddress(); // Load admin address
+        const assetAddress = data.loadAddress(); // Load asset address
+        const poolAddress = data.loadAddress(); // Load pool address
+        const content = data.loadRef(); // Load content cell
+        const jettonWalletCode = data.loadRef(); // Load jetton wallet code cell
+        const dedustPoolWalletCode = data.loadRef(); // Load dedust pool wallet code cell
+        return {
+            totalSupply,
+            adminAddress,
+            assetAddress,
+            poolAddress,
+            // content,
+            // jettonWalletCode,
+            // dedustPoolWalletCode,
+        };
+    }
+    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", []);
+        const totalSupply = _result.stack.readBigNumber();
+        _result.stack.readBigNumber();
+        const admin = _result.stack.readAddress();
+        return {
+            totalSupply,
+            admin,
+        };
+    }
+}
+exports.LFDedustJettonMinter = LFDedustJettonMinter;

package/dist/contracts/liquid_token/dedust/wallet.d.ts

@@ -0,0 +1,127 @@
+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 LFDedustJettonWallet 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;
+        ConnectPoolAccount: number;
+        TransferNotification: number;
+        ClaimRewards: number;
+        WithdrawTons: number;
+        WithdrawJettons: number;
+        DedustClaim: number;
+    };
+    static Error: {
+        InvalidWalletAddress: number;
+        Unauthorized: number;
+        NotEnoughBalance: number;
+        NotEnoughLockedAssetBalance: number;
+        EnoughLockedAssetBalance: number;
+    };
+    static createFromAddress(address: Address): LFDedustJettonWallet;
+    static createFromConfig(config: JettonWalletConfig, code: Cell, workchain?: number): LFDedustJettonWallet;
+    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>;
+    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;
+        distributorAddress: Address;
+        proof: Cell;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendWithdrawTons(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendWithdrawJettons(provider: ContractProvider, via: Sender, opts: {
+        queryId?: bigint;
+        value: bigint;
+        wallet: Address;
+        amount: 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;
+        jettonAddress: Address;
+        assetWalletAddress: Address | null;
+        poolAccountAddress: Address | null;
+        connectedWithPoolAccount: boolean;
+        ownerAddress: Address;
+        assetAddress: Address;
+        poolAddress: Address;
+    } | {
+        deployed: boolean;
+        balance: bigint;
+        lockedAssetBalance: bigint;
+        jettonAddress?: undefined;
+        assetWalletAddress?: undefined;
+        poolAccountAddress?: undefined;
+        connectedWithPoolAccount?: undefined;
+        ownerAddress?: undefined;
+        assetAddress?: undefined;
+        poolAddress?: undefined;
+    }>;
+}