@tonappchain/sdk 0.7.0-rc9 → 0.7.1

package/dist/artifacts/mainnet/ton/internal/wrappers/JettonProxy.d.ts

@@ -0,0 +1,80 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+export type JettonProxyConfig = {
+    crossChainLayerAddress: string;
+    adminAddress: string;
+    newAdminAddress?: string;
+};
+export declare const JettonProxyOpCodes: {
+    jettonWallet_transfer: number;
+    jettonWallet_transferNotification: number;
+    crossChainLayerAddress_evmMsgToTVMproxy: number;
+    crossChainLayerAddress_errorNotification: number;
+    anyone_tvmMsgToEVM: number;
+    admin_changeAdminAddress: number;
+    admin_cancelChangingAdminAddress: number;
+    admin_updateCode: number;
+    newAdmin_confirmChangingAdminAddress: number;
+};
+export declare const JettonProxyErrors: {
+    noErrors: number;
+    notFromCrossChainLayer: number;
+    notFromAdmin: number;
+    notFromNewAdmin: number;
+    newAdminAddressIsNone: number;
+    notEnoughTon: number;
+    invalidPayload: number;
+};
+export declare function jettonProxyConfigToCell(config: JettonProxyConfig): Cell;
+export declare class JettonProxy 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): JettonProxy;
+    static createFromConfig(config: JettonProxyConfig, code: Cell, workchain?: number): JettonProxy;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendTransferNotification(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        receivedJettonAmount: number;
+        depositorAddress: string;
+        crossChainTonAmount?: number;
+        feeData?: Cell;
+        evmData?: Cell;
+    }): Promise<void>;
+    sendErrorNotification(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        jettonWalletAddress: string;
+        ownerAddress: string;
+        receivedJettonAmount: number;
+    }): Promise<void>;
+    sendProxy(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        jettonWalletAddress: string;
+        toOwnerAddress: string;
+        jettonAmount: number;
+        responseAddress: string;
+        forwardTonAmount?: number;
+        forwardPayload?: Cell;
+    }): Promise<void>;
+    sendChangeAdmin(provider: ContractProvider, via: Sender, value: bigint, opts?: {
+        queryId?: number;
+        adminAddress?: string;
+    }): Promise<void>;
+    sendCancelChangingAdmin(provider: ContractProvider, via: Sender, value: bigint, opts?: {
+        queryId?: number;
+    }): Promise<void>;
+    sendConfirmNewAdmin(provider: ContractProvider, via: Sender, value: bigint, opts?: {
+        queryId?: number;
+    }): Promise<void>;
+    sendUpdateCode(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        code: Cell;
+        data: Cell;
+    }): Promise<void>;
+    getFullData(provider: ContractProvider): Promise<JettonProxyConfig>;
+}

package/dist/artifacts/mainnet/ton/internal/wrappers/JettonProxy.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonProxy = exports.JettonProxyErrors = exports.JettonProxyOpCodes = void 0;
+exports.jettonProxyConfigToCell = jettonProxyConfigToCell;
+const core_1 = require("@ton/core");
+const CrossChainLayer_1 = require("./CrossChainLayer");
+const Constants_1 = require("./Constants");
+exports.JettonProxyOpCodes = {
+    jettonWallet_transfer: 0xf8a7ea5,
+    jettonWallet_transferNotification: 0x7362d09c,
+    crossChainLayerAddress_evmMsgToTVMproxy: 0x7817b330,
+    crossChainLayerAddress_errorNotification: 0xae7df95b,
+    anyone_tvmMsgToEVM: 0x6c582059,
+    admin_changeAdminAddress: 0x581879bc,
+    admin_cancelChangingAdminAddress: 0x60094a1b,
+    admin_updateCode: 0x20faec53,
+    newAdmin_confirmChangingAdminAddress: 0x6a4fbe34,
+};
+exports.JettonProxyErrors = {
+    noErrors: 0,
+    notFromCrossChainLayer: 70,
+    notFromAdmin: 71,
+    notFromNewAdmin: 72,
+    newAdminAddressIsNone: 80,
+    notEnoughTon: 100,
+    invalidPayload: 200,
+};
+function jettonProxyConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(core_1.Address.parse(config.crossChainLayerAddress))
+        .storeAddress(core_1.Address.parse(config.adminAddress))
+        .storeAddress(config.newAdminAddress ? core_1.Address.parse(config.adminAddress) : null)
+        .endCell();
+}
+class JettonProxy {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new JettonProxy(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jettonProxyConfigToCell(config);
+        const init = { code, data };
+        return new JettonProxy((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 sendTransferNotification(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.JettonProxyOpCodes.jettonWallet_transferNotification, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeCoins((0, core_1.toNano)(opts.receivedJettonAmount.toFixed(9)))
+                .storeAddress(core_1.Address.parse(opts.depositorAddress))
+                .storeMaybeRef((0, core_1.beginCell)()
+                .storeCoins((0, core_1.toNano)(opts.crossChainTonAmount?.toFixed(9) ?? 0))
+                .storeMaybeRef(opts.feeData)
+                .storeMaybeRef(opts.evmData))
+                .endCell(),
+        });
+    }
+    async sendErrorNotification(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.JettonProxyOpCodes.crossChainLayerAddress_errorNotification, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeUint(CrossChainLayer_1.MsgType.jettonTransfer, 32)
+                .storeRef((0, core_1.beginCell)()
+                .storeAddress(core_1.Address.parse(opts.jettonWalletAddress))
+                .storeAddress(core_1.Address.parse(opts.ownerAddress))
+                .storeCoins((0, core_1.toNano)(opts.receivedJettonAmount.toFixed(9)))
+                .endCell())
+                .endCell(),
+        });
+    }
+    async sendProxy(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.JettonProxyOpCodes.crossChainLayerAddress_evmMsgToTVMproxy, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeAddress(core_1.Address.parse(opts.jettonWalletAddress))
+                .storeAddress(core_1.Address.parse(opts.toOwnerAddress))
+                .storeCoins((0, core_1.toNano)(opts.jettonAmount.toFixed(9)))
+                .storeAddress(core_1.Address.parse(opts.responseAddress))
+                .storeCoins((0, core_1.toNano)(opts.forwardTonAmount?.toFixed(9) || 0))
+                .storeMaybeRef(opts.forwardPayload)
+                .endCell(),
+        });
+    }
+    async sendChangeAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.JettonProxyOpCodes.admin_changeAdminAddress, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeAddress(opts?.adminAddress ? core_1.Address.parse(opts.adminAddress) : null)
+                .endCell(),
+        });
+    }
+    async sendCancelChangingAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.JettonProxyOpCodes.admin_cancelChangingAdminAddress, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendConfirmNewAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.JettonProxyOpCodes.newAdmin_confirmChangingAdminAddress, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendUpdateCode(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.JettonProxyOpCodes.admin_updateCode, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeRef(opts.code)
+                .storeRef(opts.data)
+                .endCell(),
+        });
+    }
+    async getFullData(provider) {
+        const result = await provider.get('get_full_data', []);
+        const crossChainLayerAddress = result.stack.readAddress().toString();
+        const adminAddress = result.stack.readAddress().toString();
+        const newAdminAddress = result.stack.readAddressOpt()?.toString();
+        return {
+            crossChainLayerAddress,
+            adminAddress,
+            newAdminAddress,
+        };
+    }
+}
+exports.JettonProxy = JettonProxy;

package/dist/artifacts/mainnet/ton/internal/wrappers/JettonWallet.d.ts

@@ -0,0 +1,95 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+import { StorageStats } from './utils/GasUtils';
+export type JettonWalletConfig = {
+    balance: bigint;
+    ownerAddress: string;
+    jettonMasterAddress: string;
+};
+export type JettonWalletData = {
+    balance: bigint;
+    ownerAddress: string;
+    jettonMasterAddress: string;
+    jettonWalletCode: Cell;
+};
+export declare enum JettonWalletOpCodes {
+    Burn = 1499400124,
+    InternalTransfer = 395134233,
+    Transfer = 260734629,
+    TransferNotification = 1935855772,
+    Excesses = 3576854235,
+    ReturnTon = 89105253,
+    BurnNotification = 2078119902
+}
+export declare const JettonWalletErrors: {
+    noErrors: number;
+    notEnoughGas: number;
+    notBounceableOp: number;
+    notWorkchain: number;
+    notMasterchain: number;
+    notFromJettonMaster: number;
+    notFromOwner: number;
+    insufficientJettonBalance: number;
+    notFromJettonMasterOrWallet: number;
+    emptyForwardPayload: number;
+    insufficientMsgValue: number;
+    invalidReceiverAddress: number;
+    unknownOp: number;
+};
+export declare function jettonWalletConfigToCell(config: JettonWalletConfig): Cell;
+export declare class JettonWallet implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    static storageStats: StorageStats;
+    static stateInitStats: StorageStats;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): JettonWallet;
+    static createFromConfig(config: JettonWalletConfig, code: Cell, workchain?: number): JettonWallet;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendBurn(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        jettonAmount: number;
+        receiverAddress?: string;
+        crossChainTonAmount?: number;
+        feeData?: Cell | null;
+        crossChainPayload?: Cell | null;
+    }): Promise<void>;
+    sendCrossChainTransfer(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        jettonAmount: number;
+        toOwnerAddress: string;
+        responseAddress?: string;
+        customPayload?: Cell | null;
+        forwardTonAmount?: number;
+        crossChainTonAmount?: number;
+        feeData?: Cell | null;
+        crossChainPayload?: Cell | null;
+    }): Promise<void>;
+    sendTransfer(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        jettonAmount: number;
+        toOwnerAddress: string;
+        responseAddress?: string;
+        customPayload?: Cell | null;
+        forwardTonAmount?: number;
+        forwardPayload?: Cell | null;
+    }): Promise<void>;
+    sendReceive(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        jettonAmount: number;
+        fromOwnerAddress?: string;
+        responseAddress?: string;
+        forwardTonAmount?: number;
+        forwardPayload?: Cell;
+    }): Promise<void>;
+    sendReturnTon(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static transferMessage(jettonAmount: bigint, to: string, responseAddress: string | null, forwardTonAmount?: bigint, crossChainTonAmount?: bigint, feeData?: Cell | null, crossChainPayload?: Cell | null, queryId?: number): Cell;
+    static burnMessage(jettonAmount: bigint, receiverAddress?: string, crossChainTonAmount?: bigint, feeData?: Cell | null, crossChainPayload?: Cell | null, queryId?: number): Cell;
+    getWalletData(provider: ContractProvider): Promise<JettonWalletData>;
+    getJettonBalance(provider: ContractProvider): Promise<bigint>;
+}

package/dist/artifacts/mainnet/ton/internal/wrappers/JettonWallet.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonWallet = exports.JettonWalletErrors = exports.JettonWalletOpCodes = void 0;
+exports.jettonWalletConfigToCell = jettonWalletConfigToCell;
+const core_1 = require("@ton/core");
+const GasUtils_1 = require("./utils/GasUtils");
+var JettonWalletOpCodes;
+(function (JettonWalletOpCodes) {
+    JettonWalletOpCodes[JettonWalletOpCodes["Burn"] = 1499400124] = "Burn";
+    JettonWalletOpCodes[JettonWalletOpCodes["InternalTransfer"] = 395134233] = "InternalTransfer";
+    JettonWalletOpCodes[JettonWalletOpCodes["Transfer"] = 260734629] = "Transfer";
+    JettonWalletOpCodes[JettonWalletOpCodes["TransferNotification"] = 1935855772] = "TransferNotification";
+    JettonWalletOpCodes[JettonWalletOpCodes["Excesses"] = 3576854235] = "Excesses";
+    JettonWalletOpCodes[JettonWalletOpCodes["ReturnTon"] = 89105253] = "ReturnTon";
+    JettonWalletOpCodes[JettonWalletOpCodes["BurnNotification"] = 2078119902] = "BurnNotification";
+})(JettonWalletOpCodes || (exports.JettonWalletOpCodes = JettonWalletOpCodes = {}));
+exports.JettonWalletErrors = {
+    noErrors: 0,
+    notEnoughGas: 48,
+    notBounceableOp: 200,
+    notWorkchain: 333,
+    notMasterchain: 334,
+    notFromJettonMaster: 704,
+    notFromOwner: 705,
+    insufficientJettonBalance: 706,
+    notFromJettonMasterOrWallet: 707,
+    emptyForwardPayload: 708,
+    insufficientMsgValue: 709,
+    invalidReceiverAddress: 710,
+    unknownOp: 0xffff,
+};
+function jettonWalletConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeCoins(config.balance)
+        .storeAddress(core_1.Address.parse(config.ownerAddress))
+        .storeAddress(core_1.Address.parse(config.jettonMasterAddress))
+        .endCell();
+}
+class JettonWallet {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new JettonWallet(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jettonWalletConfigToCell(config);
+        const init = { code, data };
+        return new JettonWallet((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 sendBurn(provider, via, value, opts) {
+        let body = (0, core_1.beginCell)()
+            .storeUint(JettonWalletOpCodes.Burn, 32)
+            .storeUint(opts.queryId || 0, 64)
+            .storeCoins((0, core_1.toNano)(opts.jettonAmount.toFixed(9)))
+            .storeAddress(opts.receiverAddress ? core_1.Address.parse(opts.receiverAddress) : null);
+        if (opts.crossChainTonAmount || opts.crossChainPayload || opts.feeData) {
+            body.storeMaybeRef((0, core_1.beginCell)()
+                .storeCoins((0, core_1.toNano)(opts.crossChainTonAmount?.toFixed(9) ?? 0))
+                .storeMaybeRef(opts.feeData)
+                .storeMaybeRef(opts.crossChainPayload)
+                .endCell());
+        }
+        else {
+            body.storeMaybeRef(null);
+        }
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body.endCell(),
+        });
+    }
+    async sendCrossChainTransfer(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(JettonWalletOpCodes.Transfer, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeCoins((0, core_1.toNano)(opts.jettonAmount.toFixed(9)))
+                .storeAddress(core_1.Address.parse(opts.toOwnerAddress))
+                .storeAddress(opts.responseAddress ? core_1.Address.parse(opts.responseAddress) : null)
+                .storeMaybeRef(opts.customPayload)
+                .storeCoins((0, core_1.toNano)(opts.forwardTonAmount?.toFixed(9) || 0))
+                .storeMaybeRef((0, core_1.beginCell)()
+                .storeCoins((0, core_1.toNano)(opts.crossChainTonAmount?.toFixed(9) ?? 0))
+                .storeMaybeRef(opts.feeData)
+                .storeMaybeRef(opts.crossChainPayload)
+                .endCell())
+                .endCell(),
+        });
+    }
+    async sendTransfer(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(JettonWalletOpCodes.Transfer, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeCoins((0, core_1.toNano)(opts.jettonAmount.toFixed(9)))
+                .storeAddress(core_1.Address.parse(opts.toOwnerAddress))
+                .storeAddress(opts.responseAddress ? core_1.Address.parse(opts.responseAddress) : null)
+                .storeMaybeRef(opts.customPayload)
+                .storeCoins((0, core_1.toNano)(opts.forwardTonAmount?.toFixed(9) || 0))
+                .storeMaybeRef(opts.forwardPayload)
+                .endCell(),
+        });
+    }
+    async sendReceive(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(JettonWalletOpCodes.InternalTransfer, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeCoins((0, core_1.toNano)(opts.jettonAmount.toFixed(9)))
+                .storeAddress(opts.fromOwnerAddress ? core_1.Address.parse(opts.fromOwnerAddress) : null)
+                .storeAddress(opts.responseAddress ? core_1.Address.parse(opts.responseAddress) : null)
+                .storeCoins(opts.forwardTonAmount || 0)
+                .storeMaybeRef(opts.forwardPayload)
+                .endCell(),
+        });
+    }
+    async sendReturnTon(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().storeUint(JettonWalletOpCodes.ReturnTon, 32).endCell(),
+        });
+    }
+    static transferMessage(jettonAmount, to, responseAddress, forwardTonAmount, crossChainTonAmount, feeData, crossChainPayload, queryId) {
+        return (0, core_1.beginCell)()
+            .storeUint(JettonWalletOpCodes.Transfer, 32)
+            .storeUint(queryId ?? 0, 64)
+            .storeCoins(jettonAmount)
+            .storeAddress(core_1.Address.parse(to))
+            .storeAddress(responseAddress ? core_1.Address.parse(responseAddress) : null)
+            .storeMaybeRef(null)
+            .storeCoins(forwardTonAmount || 0n)
+            .storeMaybeRef((0, core_1.beginCell)()
+            .storeCoins(crossChainTonAmount ?? 0n)
+            .storeMaybeRef(feeData)
+            .storeMaybeRef(crossChainPayload)
+            .endCell())
+            .endCell();
+    }
+    static burnMessage(jettonAmount, receiverAddress, crossChainTonAmount, feeData, crossChainPayload, queryId) {
+        const body = (0, core_1.beginCell)()
+            .storeUint(JettonWalletOpCodes.Burn, 32)
+            .storeUint(queryId || 0, 64)
+            .storeCoins(jettonAmount)
+            .storeAddress(receiverAddress ? core_1.Address.parse(receiverAddress) : null);
+        if (crossChainTonAmount || crossChainPayload) {
+            body.storeMaybeRef((0, core_1.beginCell)()
+                .storeCoins(crossChainTonAmount ?? 0n)
+                .storeMaybeRef(feeData)
+                .storeMaybeRef(crossChainPayload)
+                .endCell());
+        }
+        else {
+            body.storeMaybeRef(null);
+        }
+        return body.endCell();
+    }
+    async getWalletData(provider) {
+        const result = await provider.get('get_wallet_data', []);
+        return {
+            balance: result.stack.readBigNumber(),
+            ownerAddress: result.stack.readAddress().toString(),
+            jettonMasterAddress: result.stack.readAddress().toString(),
+            jettonWalletCode: result.stack.readCell(),
+        };
+    }
+    async getJettonBalance(provider) {
+        let state = await provider.getState();
+        if (state.state.type !== 'active') {
+            return 0n;
+        }
+        let res = await provider.get('get_wallet_data', []);
+        return res.stack.readBigNumber();
+    }
+}
+exports.JettonWallet = JettonWallet;
+JettonWallet.storageStats = new GasUtils_1.StorageStats(949, 3);
+JettonWallet.stateInitStats = new GasUtils_1.StorageStats(847, 3);

package/dist/artifacts/mainnet/ton/internal/wrappers/NFTCollection.d.ts

@@ -0,0 +1,75 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+export declare const NFTCollectionOpCodes: {
+    admin_deployNFTItem: number;
+    admin_batchDeployNFTItems: number;
+    admin_changeAdmin: number;
+    admin_cancelChangingAdmin: number;
+    newAdmin_confirmChangingAdmin: number;
+    admin_withdrawExtraTon: number;
+    collection_init: number;
+};
+export declare const NFTCollectionErrors: {
+    notFromAdmin: number;
+    notFromNewAdmin: number;
+    newAdminAddressIsNone: number;
+};
+export type NFTCollectionConfig = {
+    adminAddress: Address;
+    newAdminAddress: Address | null;
+    collectionContent: Cell;
+    commonContent: Cell;
+    nftItemCode: Cell;
+    originalAddress: string;
+};
+export type NFTCollectionData = {
+    nextIndex: bigint;
+    content: Cell;
+    adminAddress: Address;
+};
+export declare function nftCollectionConfigToCell(config: NFTCollectionConfig): Cell;
+export declare class NFTCollection 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): NFTCollection;
+    static createFromConfig(config: NFTCollectionConfig, code: Cell, workchain?: number): NFTCollection;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static deployNFTItemMessage(queryId: number | bigint, itemIndex: number, itemOwner: Address, nftContent: Cell, maybeNewContent?: Cell): Cell;
+    sendDeployNFTItem(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        itemIndex: number;
+        itemOwner: Address;
+        nftContent: Cell;
+        maybeNewContent?: Cell;
+    }): Promise<void>;
+    static changeAdminMessage(newAdmin: Address | null, queryId: number | bigint): Cell;
+    sendChangeAdmin(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        newAdminAddress: Address | null;
+    }): Promise<void>;
+    sendCancelChangingAdmin(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        queryId?: number;
+    }): Promise<void>;
+    sendConfirmNewAdmin(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        queryId?: number;
+    }): Promise<void>;
+    sendWithdrawExtraTon(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        queryId?: bigint | number;
+    }): Promise<void>;
+    getCollectionData(provider: ContractProvider): Promise<NFTCollectionData>;
+    getFullData(provider: ContractProvider): Promise<{
+        nextIndex: number;
+        content: Cell;
+        adminAddress: Address;
+        newAdminAddress: Address | null;
+    }>;
+    getNFTAddressByIndex(provider: ContractProvider, index: number | bigint): Promise<Address>;
+    getNFTContent(provider: ContractProvider, index: number | bigint, individualNFTContent: Cell): Promise<Cell>;
+    getOriginalAddress(provider: ContractProvider): Promise<String>;
+}