@tonappchain/sdk 0.7.0-rc9 → 0.7.1-frost-test-1

package/dist/artifacts/dev/ton/internal/wrappers/CrossChainLayer.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossChainLayer = exports.CrossChainLayerErrors = exports.CrossChainLayerOpCodes = exports.MsgType = void 0;
+exports.crossChainLayerConfigToCell = crossChainLayerConfigToCell;
+const core_1 = require("@ton/core");
+const crypto_1 = require("@ton/crypto");
+const Constants_1 = require("./Constants");
+const GasUtils_1 = require("./utils/GasUtils");
+const MerkleRoots_1 = require("./utils/MerkleRoots");
+var MsgType;
+(function (MsgType) {
+    MsgType[MsgType["tonTransfer"] = 1255570643] = "tonTransfer";
+    MsgType[MsgType["jettonTransfer"] = 688302850] = "jettonTransfer";
+    MsgType[MsgType["nftTransfer"] = 2332633442] = "nftTransfer";
+    MsgType[MsgType["jettonBurn"] = 2964301645] = "jettonBurn";
+    MsgType[MsgType["nftBurn"] = 3167851280] = "nftBurn";
+})(MsgType || (exports.MsgType = MsgType = {}));
+exports.CrossChainLayerOpCodes = {
+    anyone_tvmMsgToEVM: 0x6c582059,
+    anyone_errorNotification: 0xae7df95b,
+    anyone_excesses: 0xd53276db,
+    anyone_addProtocolFee: 0x48e660b5,
+    anyone_collectProtocolFee: 0x1f95f86c,
+    anyone_collectProtocolFeeNotification: 0xf358b6d0,
+    executor_evmMsgToTVM: 0x0e50d313,
+    executor_revertSpentParam: 0x959f183a,
+    executor_errorNotification: 0xcf6a5da4,
+    admin_changeAdminAddress: 0x581879bc,
+    admin_cancelChangingAdminAddress: 0x60094a1b,
+    admin_updateCode: 0x20faec53,
+    admin_updateExecutorCode: 0x7ee5a6d0,
+    admin_updateEpochDelay: 0xe97250b7,
+    admin_updateTonProtocolFee: 0x063199b7,
+    admin_updateTacProtocolFee: 0x3531465c,
+    newAdmin_confirmChangingAdminAddress: 0x6a4fbe34,
+    sequencerMultisig_changeSequencerMultisigAddress: 0x5cec6be0,
+    sequencerMultisig_updateMerkleRoot: 0x23b05641,
+    sequencerMultisig_updateGroupPublicKey: 0xda524dc5,
+};
+exports.CrossChainLayerErrors = {
+    noErrors: 0,
+    systemNotEnoughTon: 37,
+    notFromAdmin: 70,
+    notFromExecutor: 71,
+    notFromSequencerMultisig: 72,
+    notFromNewAdmin: 73,
+    newAdminAddressIsNone: 80,
+    notEnoughTon: 100,
+    insufficientBalance: 101,
+    zeroFeeSupply: 200,
+    invalidProof: 201,
+    votingNotActive: 202,
+    messageCollectEndTimeLow: 203,
+    notEnoughProtocolFee: 204,
+    messageCollectEndTimeHigh: 205,
+    invalidSenderSignature: 32,
+    unknownOp: 0xfffff,
+};
+function crossChainLayerConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(core_1.Address.parse(config.adminAddress))
+        .storeAddress(config.newAdminAddress ? core_1.Address.parse(config.newAdminAddress) : null)
+        .storeAddress(core_1.Address.parse(config.sequencerMultisigAddress))
+        .storeRef((0, core_1.beginCell)()
+        .storeUint(config.groupPublicKey ? config.groupPublicKey : 0n, Constants_1.Params.bitsize.hash)
+        .endCell())
+        .storeRef((0, core_1.beginCell)()
+        .storeCoins(config.tacProtocolFee ? (0, core_1.toNano)(config.tacProtocolFee.toFixed(9)) : 0)
+        .storeCoins(config.tonProtocolFee ? (0, core_1.toNano)(config.tonProtocolFee.toFixed(9)) : 0)
+        .storeCoins(config.protocolFeeSupply ? (0, core_1.toNano)(config.protocolFeeSupply.toFixed(9)) : 0)
+        .endCell())
+        .storeRef(config.executorCode)
+        .storeRef((0, core_1.beginCell)()
+        .storeUint(config.epochDelay, Constants_1.Params.bitsize.time)
+        .storeUint(config.prevEpoch ? config.prevEpoch : 0, Constants_1.Params.bitsize.time)
+        .storeUint(config.currEpoch ? config.currEpoch : 0, Constants_1.Params.bitsize.time)
+        .storeUint(config.messageCollectEndTime ? config.messageCollectEndTime : 0, Constants_1.Params.bitsize.time)
+        .storeUint(config.nextVotingTime ? config.nextVotingTime : 0, Constants_1.Params.bitsize.time)
+        .storeUint(config.maxRootsSize, 4)
+        .storeDict((0, MerkleRoots_1.arrayToCell)(config.merkleRoots ?? []))
+        .endCell())
+        .endCell();
+}
+class CrossChainLayer {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new CrossChainLayer(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = crossChainLayerConfigToCell(config);
+        const init = { code, data };
+        return new CrossChainLayer((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 sendTVMMsgToEVM(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.anyone_tvmMsgToEVM, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeUint(opts.msgType, Constants_1.Params.bitsize.op)
+                .storeCoins((0, core_1.toNano)(opts.crossChainTonAmount.toFixed(9)))
+                .storeMaybeRef(opts.feeData)
+                .storeAddress(opts.responseAddress ? core_1.Address.parse(opts.responseAddress) : null)
+                .storeSlice(opts.payload)
+                .endCell(),
+        });
+    }
+    async sendEVMMsgToTVM(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.executor_evmMsgToTVM, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeAddress(opts.feeToAddress ? core_1.Address.parse(opts.feeToAddress) : null)
+                .storeRef(opts.merkleProof)
+                .storeRef(opts.payload)
+                .storeAddress(opts.responseAddress ? core_1.Address.parse(opts.responseAddress) : null)
+                .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.CrossChainLayerOpCodes.executor_errorNotification, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeRef(opts.payload)
+                .storeAddress(opts.responseAddress)
+                .endCell(),
+        });
+    }
+    async sendUpdateGroupPublicKey(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.sequencerMultisig_updateGroupPublicKey, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeUint(opts.groupPublicKey, Constants_1.Params.bitsize.hash)
+                .endCell(),
+        });
+    }
+    buildSignedUpdateMerkleRoot(secretKey, merkleRoot, messageCollectEndTime) {
+        let msg = (0, core_1.beginCell)()
+            .storeUint(merkleRoot, Constants_1.Params.bitsize.hash)
+            .storeUint(messageCollectEndTime, Constants_1.Params.bitsize.time)
+            .endCell();
+        let signature = (0, crypto_1.sign)(msg.hash(), secretKey);
+        msg = (0, core_1.beginCell)()
+            .storeUint(exports.CrossChainLayerOpCodes.sequencerMultisig_updateMerkleRoot, 32)
+            .storeBuffer(signature)
+            .storeSlice(msg.asSlice())
+            .endCell();
+        return msg;
+    }
+    async sendUpdateMerkleRoot(provider, secretKey, opts) {
+        const msg = this.buildSignedUpdateMerkleRoot(secretKey, opts.merkleRoot, opts.messageCollectEndTime);
+        await provider.external(msg);
+    }
+    async sendAddProtocolFee(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.anyone_addProtocolFee, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId ?? 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendCollectProtocolFee(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.anyone_collectProtocolFee, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .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.CrossChainLayerOpCodes.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.CrossChainLayerOpCodes.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.CrossChainLayerOpCodes.newAdmin_confirmChangingAdminAddress, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendChangeSequencerMultisig(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.sequencerMultisig_changeSequencerMultisigAddress, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeAddress(core_1.Address.parse(opts.sequencerMultisigAddress))
+                .endCell(),
+        });
+    }
+    async sendUpdateTonProtocolFeeAmount(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.admin_updateTonProtocolFee, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeCoins((0, core_1.toNano)(opts.tonProtocolFee.toFixed(9)))
+                .endCell(),
+        });
+    }
+    async sendUpdateTacProtocolFeeAmount(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.admin_updateTacProtocolFee, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeCoins((0, core_1.toNano)(opts.tacProtocolFee.toFixed(9)))
+                .endCell(),
+        });
+    }
+    async sendUpdateEpochDelay(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.admin_updateEpochDelay, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeUint(opts.epochDelay || 0, Constants_1.Params.bitsize.time)
+                .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.CrossChainLayerOpCodes.admin_updateCode, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeRef(opts.code)
+                .storeRef(opts.data)
+                .endCell(),
+        });
+    }
+    async sendUpdateExecutorCode(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.CrossChainLayerOpCodes.admin_updateExecutorCode, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeRef(opts.code)
+                .endCell(),
+        });
+    }
+    async getFullData(provider) {
+        const result = await provider.get('get_full_data', []);
+        const adminAddress = result.stack.readAddress().toString();
+        const newAdminAddress = result.stack.readAddressOpt()?.toString();
+        const sequencerMultisigAddress = result.stack.readAddress().toString();
+        const groupPublicKey = result.stack.readBigNumber();
+        const maxRootsSize = result.stack.readNumber();
+        const merkleRoots = result.stack.readCellOpt();
+        const prevEpoch = result.stack.readNumber();
+        const currEpoch = result.stack.readNumber();
+        const messageCollectEndTime = result.stack.readNumber();
+        const epochDelay = result.stack.readNumber();
+        const nextVotingTime = result.stack.readNumber();
+        const tacProtocolFee = Number((0, core_1.fromNano)(result.stack.readNumber()));
+        const tonProtocolFee = Number((0, core_1.fromNano)(result.stack.readNumber()));
+        const protocolFeeSupply = Number((0, core_1.fromNano)(result.stack.readNumber()));
+        const executorCode = result.stack.readCell();
+        return {
+            adminAddress,
+            newAdminAddress,
+            sequencerMultisigAddress,
+            groupPublicKey,
+            maxRootsSize,
+            merkleRoots: (0, MerkleRoots_1.cellToArray)(merkleRoots),
+            prevEpoch,
+            currEpoch,
+            epochDelay,
+            messageCollectEndTime,
+            nextVotingTime,
+            tacProtocolFee,
+            tonProtocolFee,
+            protocolFeeSupply,
+            executorCode,
+        };
+    }
+    async getCurrentEpochInfo(provider) {
+        const result = await provider.get('get_current_epoch_info', []);
+        const lastMerkleRoot = result.stack.readBigNumber();
+        const prevEpoch = result.stack.readNumber();
+        const currEpoch = result.stack.readNumber();
+        const messageCollectEndTime = result.stack.readNumber();
+        const nextVotingTime = result.stack.readNumber();
+        const epochDelay = result.stack.readNumber();
+        const maxRootsSize = result.stack.readNumber();
+        const groupPublicKey = result.stack.readBigNumber();
+        return {
+            lastMerkleRoot,
+            prevEpoch,
+            currEpoch,
+            messageCollectEndTime,
+            nextVotingTime,
+            epochDelay,
+            maxRootsSize,
+            groupPublicKey,
+        };
+    }
+    async getExecutorAddress(provider, payload) {
+        const result = await provider.get('get_executor_address', [{ type: 'cell', cell: payload }]);
+        return result.stack.readAddress();
+    }
+    async getExecutorData(provider, payload) {
+        const result = await provider.get('get_executor_data', [{ type: 'cell', cell: payload }]);
+        const address = result.stack.readAddress();
+        const stateInit = result.stack.readCell();
+        return {
+            address,
+            stateInit,
+        };
+    }
+}
+exports.CrossChainLayer = CrossChainLayer;
+CrossChainLayer.minStorageDuration = 365 * 24 * 3600; //1 year
+CrossChainLayer.storageStats = new GasUtils_1.StorageStats(34518n, 87n);
+CrossChainLayer.addFeeGasConsumption = 6460n;

package/dist/artifacts/dev/ton/internal/wrappers/JettonMinter.d.ts

@@ -0,0 +1,94 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/ton';
+import { Maybe } from '@ton/core/dist/utils/maybe';
+export declare const JettonMinterOpCodes: {
+    mint: number;
+    changeAdmin: number;
+    cancelChangingAdminAddress: number;
+    confirmChangingAdminAddress: number;
+    changeContent: number;
+    burnNotification: number;
+    excesses: number;
+    withdrawExtraTon: number;
+};
+export declare const JettonMinterErrors: {
+    noErrors: number;
+    notFromAdmin: number;
+    notFromJettonWallet: number;
+    notFromNewAdmin: number;
+    newAdminAddressIsNone: number;
+};
+export type JettonMinterConfig = {
+    totalSupply: bigint;
+    adminAddress: Address;
+    newAdminAddress?: Address;
+    content: Cell;
+    jettonWalletCode: Cell;
+    evmTokenAddress: string;
+};
+export type JettonMinterData = {
+    totalSupply: bigint;
+    mintable: boolean;
+    adminAddress: Address;
+    content: Cell;
+    walletCode: Cell;
+};
+export declare function jettonMinterConfigToCell(config: JettonMinterConfig): Cell;
+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;
+    static createFromConfig(config: JettonMinterConfig, code: Cell, workchain?: number): JettonMinter;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendErrorNotification(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        operation?: number | bigint;
+        jettonOwnerAddress: Address;
+        jettonAmount: number;
+    }): Promise<void>;
+    static mintMessage(to: Address, jettonAmount: number, responseAddress?: Address, forwardTonAmount?: number, forwardPayload?: Maybe<Cell>, newContent?: Maybe<Cell>, queryId?: number | bigint): Cell;
+    sendMint(provider: ContractProvider, via: Sender, value: bigint, params: {
+        to: Address;
+        jettonAmount: number;
+        forwardTonAmount: number;
+        responseAddress?: Address;
+        forwardPayload?: Maybe<Cell>;
+        newContent?: Maybe<Cell>;
+        queryId?: number | bigint;
+    }): Promise<void>;
+    sendChangeAdmin(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        newAdmin?: Address;
+        queryId?: number | bigint;
+    }): 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>;
+    sendChangeContent(provider: ContractProvider, via: Sender, value: bigint, params: {
+        content: Cell;
+        queryId?: number | bigint;
+    }): Promise<void>;
+    sendBurnNotification(provider: ContractProvider, via: Sender, value: bigint, params: {
+        jettonAmount: number;
+        from: Address;
+        responseAddress: Address;
+        crossChainTonAmount?: number;
+        feeData?: Cell | null;
+        crossChainPayload?: Cell | null;
+    }): Promise<void>;
+    sendWithdrawExtraTon(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        queryId?: bigint | number;
+    }): Promise<void>;
+    getWalletAddress(provider: ContractProvider, owner: Address): Promise<Address>;
+    getJettonData(provider: ContractProvider): Promise<JettonMinterData>;
+    getEVMTokenAddress(provider: ContractProvider): Promise<string>;
+    getFullData(provider: ContractProvider): Promise<JettonMinterConfig>;
+}

package/dist/artifacts/dev/ton/internal/wrappers/JettonMinter.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonMinter = exports.JettonMinterErrors = exports.JettonMinterOpCodes = void 0;
+exports.jettonMinterConfigToCell = jettonMinterConfigToCell;
+// TAC jetton minter
+const ton_1 = require("@ton/ton");
+const CrossChainLayer_1 = require("./CrossChainLayer");
+const Constants_1 = require("./Constants");
+exports.JettonMinterOpCodes = {
+    mint: 0xd7b9c06e,
+    changeAdmin: 0x581879bc,
+    cancelChangingAdminAddress: 0x60094a1b,
+    confirmChangingAdminAddress: 0x6a4fbe34,
+    changeContent: 0x23f78ab7,
+    burnNotification: 0x7bdd97de,
+    excesses: 0xd53276db,
+    withdrawExtraTon: 0x1754ab63,
+};
+exports.JettonMinterErrors = {
+    noErrors: 0,
+    notFromAdmin: 73,
+    notFromJettonWallet: 74,
+    notFromNewAdmin: 75,
+    newAdminAddressIsNone: 80,
+};
+function jettonMinterConfigToCell(config) {
+    return (0, ton_1.beginCell)()
+        .storeCoins(config.totalSupply)
+        .storeAddress(config.adminAddress)
+        .storeAddress(config.newAdminAddress ?? null)
+        .storeRef(config.content)
+        .storeRef(config.jettonWalletCode)
+        .storeStringTail(config.evmTokenAddress)
+        .endCell();
+}
+class JettonMinter {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new JettonMinter(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jettonMinterConfigToCell(config);
+        const init = { code, data };
+        return new JettonMinter((0, ton_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)().endCell(),
+        });
+    }
+    async sendErrorNotification(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(CrossChainLayer_1.CrossChainLayerOpCodes.anyone_errorNotification, 32)
+                .storeUint(params.queryId || 0, 64)
+                .storeUint(params.operation || CrossChainLayer_1.MsgType.jettonBurn, 32)
+                .storeAddress(params.jettonOwnerAddress)
+                .storeCoins((0, ton_1.toNano)(params.jettonAmount.toFixed(9)))
+                .endCell(),
+        });
+    }
+    static mintMessage(to, jettonAmount, responseAddress, forwardTonAmount, forwardPayload, newContent, queryId) {
+        return (0, ton_1.beginCell)()
+            .storeUint(exports.JettonMinterOpCodes.mint, 32)
+            .storeUint(queryId ?? 0, 64)
+            .storeAddress(to)
+            .storeCoins((0, ton_1.toNano)(jettonAmount.toFixed(9)))
+            .storeAddress(responseAddress ?? null)
+            .storeCoins((0, ton_1.toNano)(forwardTonAmount?.toFixed(9) ?? 0))
+            .storeMaybeRef(forwardPayload)
+            .storeMaybeRef(newContent)
+            .endCell();
+    }
+    async sendMint(provider, via, value, params) {
+        if (value <= params.forwardTonAmount) {
+            throw new Error('totalTonAmount should be > forward amount');
+        }
+        await provider.internal(via, {
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: JettonMinter.mintMessage(params.to, params.jettonAmount, params.responseAddress, params.forwardTonAmount, params.forwardPayload, params.newContent, params.queryId || 0),
+            value,
+        });
+    }
+    async sendChangeAdmin(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(exports.JettonMinterOpCodes.changeAdmin, 32)
+                .storeUint(params?.queryId || 0, 64)
+                .storeAddress(params?.newAdmin ?? null)
+                .endCell(),
+            value,
+        });
+    }
+    async sendCancelChangingAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(exports.JettonMinterOpCodes.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: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(exports.JettonMinterOpCodes.confirmChangingAdminAddress, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendChangeContent(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(exports.JettonMinterOpCodes.changeContent, 32)
+                .storeUint(params.queryId || 0, 64)
+                .storeRef(params.content)
+                .endCell(),
+            value,
+        });
+    }
+    async sendBurnNotification(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(exports.JettonMinterOpCodes.burnNotification, 32)
+                .storeUint(0, 64)
+                .storeCoins((0, ton_1.toNano)(params.jettonAmount.toFixed(9)))
+                .storeAddress(params.from)
+                .storeAddress(params.responseAddress)
+                .storeCoins((0, ton_1.toNano)(params.crossChainTonAmount?.toFixed(9) ?? 0))
+                .storeMaybeRef(params.feeData)
+                .storeMaybeRef(params.crossChainPayload)
+                .endCell(),
+            value,
+        });
+    }
+    async sendWithdrawExtraTon(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(exports.JettonMinterOpCodes.withdrawExtraTon, 32)
+                .storeUint(params?.queryId || 0, 64)
+                .endCell(),
+            value,
+        });
+    }
+    async getWalletAddress(provider, owner) {
+        const res = await provider.get('get_wallet_address', [
+            { type: 'slice', cell: (0, ton_1.beginCell)().storeAddress(owner).endCell() },
+        ]);
+        return res.stack.readAddress();
+    }
+    async getJettonData(provider) {
+        const res = await provider.get('get_jetton_data', []);
+        const totalSupply = res.stack.readBigNumber();
+        const mintable = res.stack.readBoolean();
+        const adminAddress = res.stack.readAddress();
+        const content = res.stack.readCell();
+        const walletCode = res.stack.readCell();
+        return {
+            totalSupply,
+            mintable,
+            adminAddress,
+            content,
+            walletCode,
+        };
+    }
+    async getEVMTokenAddress(provider) {
+        const res = await provider.get('get_evm_token_address', []);
+        return res.stack.readString();
+    }
+    async getFullData(provider) {
+        const res = await provider.get('get_full_data', []);
+        const totalSupply = res.stack.readBigNumber();
+        const adminAddress = res.stack.readAddress();
+        const newAdminAddress = res.stack.readAddressOpt() ?? undefined;
+        const content = res.stack.readCell();
+        const jettonWalletCode = res.stack.readCell();
+        const evmTokenAddress = res.stack.readString();
+        return {
+            totalSupply,
+            adminAddress,
+            newAdminAddress,
+            content,
+            jettonWalletCode,
+            evmTokenAddress,
+        };
+    }
+}
+exports.JettonMinter = JettonMinter;