@metoncash/sdk-v1 0.1.0

package/dist/wrappers/JettonMinter.gen.d.ts

@@ -0,0 +1,288 @@
+import * as c from '@ton/core';
+import { ContractProvider, Sender, SendMode } from '@ton/core';
+type RemainingBitsAndRefs = c.Slice;
+export type CellRef<T> = {
+    ref: T;
+};
+type coins = bigint;
+type uint64 = bigint;
+/**
+ > struct JettonMinterStorage {
+ >     totalSupply: coins
+ >     admin: address
+ >     content: cell
+ >     walletCode: cell
+ > }
+ */
+export interface JettonMinterStorage {
+    readonly $: 'JettonMinterStorage';
+    totalSupply: coins;
+    admin: c.Address;
+    content: c.Cell;
+    walletCode: c.Cell;
+}
+export declare const JettonMinterStorage: {
+    create(args: {
+        totalSupply?: coins;
+        admin: c.Address;
+        content: c.Cell;
+        walletCode: c.Cell;
+    }): JettonMinterStorage;
+    fromSlice(s: c.Slice): JettonMinterStorage;
+    store(self: JettonMinterStorage, b: c.Builder): void;
+    toCell(self: JettonMinterStorage): c.Cell;
+};
+/**
+ > struct JettonMinterStorageRuntime {
+ >     totalSupply: coins
+ >     admin: address
+ >     content: cell
+ >     walletCode: cell
+ > }
+ */
+export interface JettonMinterStorageRuntime {
+    readonly $: 'JettonMinterStorageRuntime';
+    totalSupply: coins;
+    admin: c.Address;
+    content: c.Cell;
+    walletCode: c.Cell;
+}
+export declare const JettonMinterStorageRuntime: {
+    create(args: {
+        totalSupply: coins;
+        admin: c.Address;
+        content: c.Cell;
+        walletCode: c.Cell;
+    }): JettonMinterStorageRuntime;
+    fromSlice(s: c.Slice): JettonMinterStorageRuntime;
+    store(self: JettonMinterStorageRuntime, b: c.Builder): void;
+    toCell(self: JettonMinterStorageRuntime): c.Cell;
+};
+/**
+ > struct (0x642b7d07) JettonMintMessage {
+ >     queryId: uint64
+ >     toAddress: address
+ >     jettonAmount: coins
+ >     forwardTonAmount: coins
+ > }
+ */
+export interface JettonMintMessage {
+    readonly $: 'JettonMintMessage';
+    queryId: uint64;
+    toAddress: c.Address;
+    jettonAmount: coins;
+    forwardTonAmount: coins;
+}
+export declare const JettonMintMessage: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        toAddress: c.Address;
+        jettonAmount: coins;
+        forwardTonAmount: coins;
+    }): JettonMintMessage;
+    fromSlice(s: c.Slice): JettonMintMessage;
+    store(self: JettonMintMessage, b: c.Builder): void;
+    toCell(self: JettonMintMessage): c.Cell;
+};
+/**
+ > struct (0x178d4519) JettonInternalTransfer {
+ >     queryId: uint64
+ >     jettonAmount: coins
+ >     transferInitiator: address
+ >     sendExcessesTo: address?
+ >     forwardTonAmount: coins
+ >     forwardPayload: RemainingBitsAndRefs
+ > }
+ */
+export interface JettonInternalTransfer {
+    readonly $: 'JettonInternalTransfer';
+    queryId: uint64;
+    jettonAmount: coins;
+    transferInitiator: c.Address;
+    sendExcessesTo: c.Address | null;
+    forwardTonAmount: coins;
+    forwardPayload: RemainingBitsAndRefs;
+}
+export declare const JettonInternalTransfer: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonAmount: coins;
+        transferInitiator: c.Address;
+        sendExcessesTo: c.Address | null;
+        forwardTonAmount: coins;
+        forwardPayload: RemainingBitsAndRefs;
+    }): JettonInternalTransfer;
+    fromSlice(s: c.Slice): JettonInternalTransfer;
+    store(self: JettonInternalTransfer, b: c.Builder): void;
+    toCell(self: JettonInternalTransfer): c.Cell;
+};
+/**
+ > struct (0xd53276db) JettonExcesses {
+ >     queryId: uint64
+ > }
+ */
+export interface JettonExcesses {
+    readonly $: 'JettonExcesses';
+    queryId: uint64;
+}
+export declare const JettonExcesses: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+    }): JettonExcesses;
+    fromSlice(s: c.Slice): JettonExcesses;
+    store(self: JettonExcesses, b: c.Builder): void;
+    toCell(self: JettonExcesses): c.Cell;
+};
+/**
+ > struct (0x7bdd97de) JettonBurnNotification {
+ >     queryId: uint64
+ >     jettonAmount: coins
+ >     burnInitiator: address
+ >     sendExcessesTo: address?
+ > }
+ */
+export interface JettonBurnNotification {
+    readonly $: 'JettonBurnNotification';
+    queryId: uint64;
+    jettonAmount: coins;
+    burnInitiator: c.Address;
+    sendExcessesTo: c.Address | null;
+}
+export declare const JettonBurnNotification: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonAmount: coins;
+        burnInitiator: c.Address;
+        sendExcessesTo: c.Address | null;
+    }): JettonBurnNotification;
+    fromSlice(s: c.Slice): JettonBurnNotification;
+    store(self: JettonBurnNotification, b: c.Builder): void;
+    toCell(self: JettonBurnNotification): c.Cell;
+};
+/**
+ > struct (0x2c76b973) JettonProvideWalletAddress {
+ >     queryId: uint64
+ >     ownerAddress: address
+ >     includeOwnerAddress: bool
+ > }
+ */
+export interface JettonProvideWalletAddress {
+    readonly $: 'JettonProvideWalletAddress';
+    queryId: uint64;
+    ownerAddress: c.Address;
+    includeOwnerAddress: boolean;
+}
+export declare const JettonProvideWalletAddress: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        ownerAddress: c.Address;
+        includeOwnerAddress: boolean;
+    }): JettonProvideWalletAddress;
+    fromSlice(s: c.Slice): JettonProvideWalletAddress;
+    store(self: JettonProvideWalletAddress, b: c.Builder): void;
+    toCell(self: JettonProvideWalletAddress): c.Cell;
+};
+/**
+ > struct (0xd1735400) TakeWalletAddress {
+ >     queryId: uint64
+ >     jettonWalletAddress: address
+ >     ownerAddress: Cell<address>?
+ > }
+ */
+export interface TakeWalletAddress {
+    readonly $: 'TakeWalletAddress';
+    queryId: uint64;
+    jettonWalletAddress: c.Address;
+    ownerAddress: CellRef<c.Address> | null;
+}
+export declare const TakeWalletAddress: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonWalletAddress: c.Address;
+        ownerAddress: CellRef<c.Address> | null;
+    }): TakeWalletAddress;
+    fromSlice(s: c.Slice): TakeWalletAddress;
+    store(self: TakeWalletAddress, b: c.Builder): void;
+    toCell(self: TakeWalletAddress): c.Cell;
+};
+interface ExtraSendOptions {
+    bounce?: boolean;
+    sendMode?: SendMode;
+    extraCurrencies?: c.ExtraCurrency;
+}
+interface DeployedAddrOptions {
+    workchain?: number;
+    toShard?: {
+        fixedPrefixLength: number;
+        closeTo: c.Address;
+    };
+    overrideContractCode?: c.Cell;
+}
+export declare class JettonMinter implements c.Contract {
+    static Errors: {
+        ERR_NOT_ADMIN: number;
+        ERR_NOT_FROM_WALLET: number;
+        'Errors.InvalidWorkchain': number;
+    };
+    readonly address: c.Address;
+    readonly init: {
+        code: c.Cell;
+        data: c.Cell;
+    } | undefined;
+    protected constructor(address: c.Address, init?: {
+        code: c.Cell;
+        data: c.Cell;
+    });
+    static fromAddress(address: c.Address): JettonMinter;
+    static createCellOfJettonMintMessage(body: {
+        queryId: uint64;
+        toAddress: c.Address;
+        jettonAmount: coins;
+        forwardTonAmount: coins;
+    }): c.Cell;
+    static createCellOfJettonBurnNotification(body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        burnInitiator: c.Address;
+        sendExcessesTo: c.Address | null;
+    }): c.Cell;
+    static createCellOfJettonProvideWalletAddress(body: {
+        queryId: uint64;
+        ownerAddress: c.Address;
+        includeOwnerAddress: boolean;
+    }): c.Cell;
+    sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendJettonMintMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        toAddress: c.Address;
+        jettonAmount: coins;
+        forwardTonAmount: coins;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendJettonBurnNotification(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        burnInitiator: c.Address;
+        sendExcessesTo: c.Address | null;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendJettonProvideWalletAddress(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        ownerAddress: c.Address;
+        includeOwnerAddress: boolean;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    getMinterStorage(provider: ContractProvider): Promise<JettonMinterStorageRuntime>;
+    getJettonData(provider: ContractProvider): Promise<[
+        coins,
+        bigint,
+        c.Address,
+        c.Cell,
+        c.Cell
+    ]>;
+    getWalletAddress(provider: ContractProvider, ownerAddress: c.Address): Promise<c.Address>;
+}
+export {};

package/dist/wrappers/JettonMinter.gen.js

@@ -0,0 +1,432 @@
+"use strict";
+// AUTO-GENERATED, do not edit
+// It's a TypeScript wrapper for a JettonMinter contract in Tolk.
+/* eslint-disable */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonMinter = exports.TakeWalletAddress = exports.JettonProvideWalletAddress = exports.JettonBurnNotification = exports.JettonExcesses = exports.JettonInternalTransfer = exports.JettonMintMessage = exports.JettonMinterStorageRuntime = exports.JettonMinterStorage = void 0;
+const c = __importStar(require("@ton/core"));
+const core_1 = require("@ton/core");
+function makeCellFrom(self, storeFn_T) {
+    let b = (0, core_1.beginCell)();
+    storeFn_T(self, b);
+    return b.endCell();
+}
+function loadAndCheckPrefix32(s, expected, structName) {
+    let prefix = s.loadUint(32);
+    if (prefix !== expected) {
+        throw new Error(`Incorrect prefix for '${structName}': expected 0x${expected.toString(16).padStart(8, '0')}, got 0x${prefix.toString(16).padStart(8, '0')}`);
+    }
+}
+function lookupPrefix(s, expected, prefixLen) {
+    return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;
+}
+function throwNonePrefixMatch(fieldPath) {
+    throw new Error(`Incorrect prefix for '${fieldPath}': none of variants matched`);
+}
+function storeCellRef(cell, b, storeFn_T) {
+    let b_ref = c.beginCell();
+    storeFn_T(cell.ref, b_ref);
+    b.storeRef(b_ref.endCell());
+}
+function loadCellRef(s, loadFn_T) {
+    let s_ref = s.loadRef().beginParse();
+    return { ref: loadFn_T(s_ref) };
+}
+function storeTolkRemaining(v, b) {
+    b.storeSlice(v);
+}
+function loadTolkRemaining(s) {
+    let rest = s.clone();
+    s.loadBits(s.remainingBits);
+    while (s.remainingRefs) {
+        s.loadRef();
+    }
+    return rest;
+}
+function storeTolkNullable(v, b, storeFn_T) {
+    if (v === null) {
+        b.storeUint(0, 1);
+    }
+    else {
+        b.storeUint(1, 1);
+        storeFn_T(v, b);
+    }
+}
+// ————————————————————————————————————————————
+//   parse get methods result from a TVM stack
+//
+class StackReader {
+    constructor(tuple) {
+        this.tuple = tuple;
+    }
+    static fromGetMethod(expectedN, getMethodResult) {
+        let tuple = [];
+        while (getMethodResult.stack.remaining) {
+            tuple.push(getMethodResult.stack.pop());
+        }
+        if (tuple.length !== expectedN) {
+            throw new Error(`expected ${expectedN} stack width, got ${tuple.length}`);
+        }
+        return new StackReader(tuple);
+    }
+    popExpecting(itemType) {
+        const item = this.tuple.shift();
+        if (item?.type === itemType) {
+            return item;
+        }
+        throw new Error(`not '${itemType}' on a stack`);
+    }
+    popCellLike() {
+        const item = this.tuple.shift();
+        if (item && (item.type === 'cell' || item.type === 'slice' || item.type === 'builder')) {
+            return item.cell;
+        }
+        throw new Error(`not cell/slice on a stack`);
+    }
+    readBigInt() {
+        return this.popExpecting('int').value;
+    }
+    readBoolean() {
+        return this.popExpecting('int').value !== 0n;
+    }
+    readCell() {
+        return this.popCellLike();
+    }
+    readSlice() {
+        return this.popCellLike().beginParse();
+    }
+}
+exports.JettonMinterStorage = {
+    create(args) {
+        return {
+            $: 'JettonMinterStorage',
+            totalSupply: 0n,
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'JettonMinterStorage',
+            totalSupply: s.loadCoins(),
+            admin: s.loadAddress(),
+            content: s.loadRef(),
+            walletCode: s.loadRef(),
+        };
+    },
+    store(self, b) {
+        b.storeCoins(self.totalSupply);
+        b.storeAddress(self.admin);
+        b.storeRef(self.content);
+        b.storeRef(self.walletCode);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonMinterStorage.store);
+    }
+};
+exports.JettonMinterStorageRuntime = {
+    create(args) {
+        return {
+            $: 'JettonMinterStorageRuntime',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'JettonMinterStorageRuntime',
+            totalSupply: s.loadCoins(),
+            admin: s.loadAddress(),
+            content: s.loadRef(),
+            walletCode: s.loadRef(),
+        };
+    },
+    store(self, b) {
+        b.storeCoins(self.totalSupply);
+        b.storeAddress(self.admin);
+        b.storeRef(self.content);
+        b.storeRef(self.walletCode);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonMinterStorageRuntime.store);
+    }
+};
+exports.JettonMintMessage = {
+    PREFIX: 0x642b7d07,
+    create(args) {
+        return {
+            $: 'JettonMintMessage',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x642b7d07, 'JettonMintMessage');
+        return {
+            $: 'JettonMintMessage',
+            queryId: s.loadUintBig(64),
+            toAddress: s.loadAddress(),
+            jettonAmount: s.loadCoins(),
+            forwardTonAmount: s.loadCoins(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x642b7d07, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.toAddress);
+        b.storeCoins(self.jettonAmount);
+        b.storeCoins(self.forwardTonAmount);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonMintMessage.store);
+    }
+};
+exports.JettonInternalTransfer = {
+    PREFIX: 0x178d4519,
+    create(args) {
+        return {
+            $: 'JettonInternalTransfer',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x178d4519, 'JettonInternalTransfer');
+        return {
+            $: 'JettonInternalTransfer',
+            queryId: s.loadUintBig(64),
+            jettonAmount: s.loadCoins(),
+            transferInitiator: s.loadAddress(),
+            sendExcessesTo: s.loadMaybeAddress(),
+            forwardTonAmount: s.loadCoins(),
+            forwardPayload: loadTolkRemaining(s),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x178d4519, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeCoins(self.jettonAmount);
+        b.storeAddress(self.transferInitiator);
+        b.storeAddress(self.sendExcessesTo);
+        b.storeCoins(self.forwardTonAmount);
+        storeTolkRemaining(self.forwardPayload, b);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonInternalTransfer.store);
+    }
+};
+exports.JettonExcesses = {
+    PREFIX: 0xd53276db,
+    create(args) {
+        return {
+            $: 'JettonExcesses',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0xd53276db, 'JettonExcesses');
+        return {
+            $: 'JettonExcesses',
+            queryId: s.loadUintBig(64),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0xd53276db, 32);
+        b.storeUint(self.queryId, 64);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonExcesses.store);
+    }
+};
+exports.JettonBurnNotification = {
+    PREFIX: 0x7bdd97de,
+    create(args) {
+        return {
+            $: 'JettonBurnNotification',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x7bdd97de, 'JettonBurnNotification');
+        return {
+            $: 'JettonBurnNotification',
+            queryId: s.loadUintBig(64),
+            jettonAmount: s.loadCoins(),
+            burnInitiator: s.loadAddress(),
+            sendExcessesTo: s.loadMaybeAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x7bdd97de, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeCoins(self.jettonAmount);
+        b.storeAddress(self.burnInitiator);
+        b.storeAddress(self.sendExcessesTo);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonBurnNotification.store);
+    }
+};
+exports.JettonProvideWalletAddress = {
+    PREFIX: 0x2c76b973,
+    create(args) {
+        return {
+            $: 'JettonProvideWalletAddress',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x2c76b973, 'JettonProvideWalletAddress');
+        return {
+            $: 'JettonProvideWalletAddress',
+            queryId: s.loadUintBig(64),
+            ownerAddress: s.loadAddress(),
+            includeOwnerAddress: s.loadBoolean(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x2c76b973, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.ownerAddress);
+        b.storeBit(self.includeOwnerAddress);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonProvideWalletAddress.store);
+    }
+};
+exports.TakeWalletAddress = {
+    PREFIX: 0xd1735400,
+    create(args) {
+        return {
+            $: 'TakeWalletAddress',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0xd1735400, 'TakeWalletAddress');
+        return {
+            $: 'TakeWalletAddress',
+            queryId: s.loadUintBig(64),
+            jettonWalletAddress: s.loadAddress(),
+            ownerAddress: s.loadBoolean() ? loadCellRef(s, (s) => s.loadAddress()) : null,
+        };
+    },
+    store(self, b) {
+        b.storeUint(0xd1735400, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.jettonWalletAddress);
+        storeTolkNullable(self.ownerAddress, b, (v, b) => {
+            storeCellRef(v, b, (v, b) => b.storeAddress(v));
+        });
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.TakeWalletAddress.store);
+    }
+};
+class JettonMinter {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static fromAddress(address) {
+        return new JettonMinter(address);
+    }
+    static createCellOfJettonMintMessage(body) {
+        return exports.JettonMintMessage.toCell(exports.JettonMintMessage.create(body));
+    }
+    static createCellOfJettonBurnNotification(body) {
+        return exports.JettonBurnNotification.toCell(exports.JettonBurnNotification.create(body));
+    }
+    static createCellOfJettonProvideWalletAddress(body) {
+        return exports.JettonProvideWalletAddress.toCell(exports.JettonProvideWalletAddress.create(body));
+    }
+    async sendDeploy(provider, via, msgValue, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: c.Cell.EMPTY,
+            ...extraOptions
+        });
+    }
+    async sendJettonMintMessage(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.JettonMintMessage.toCell(exports.JettonMintMessage.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendJettonBurnNotification(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.JettonBurnNotification.toCell(exports.JettonBurnNotification.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendJettonProvideWalletAddress(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.JettonProvideWalletAddress.toCell(exports.JettonProvideWalletAddress.create(body)),
+            ...extraOptions
+        });
+    }
+    async getMinterStorage(provider) {
+        const r = StackReader.fromGetMethod(4, await provider.get('getMinterStorage', []));
+        return ({
+            $: 'JettonMinterStorageRuntime',
+            totalSupply: r.readBigInt(),
+            admin: r.readSlice().loadAddress(),
+            content: r.readCell(),
+            walletCode: r.readCell(),
+        });
+    }
+    async getJettonData(provider) {
+        const r = StackReader.fromGetMethod(5, await provider.get('get_jetton_data', []));
+        return [
+            r.readBigInt(),
+            r.readBigInt(),
+            r.readSlice().loadAddress(),
+            r.readCell(),
+            r.readCell(),
+        ];
+    }
+    async getWalletAddress(provider, ownerAddress) {
+        const r = StackReader.fromGetMethod(1, await provider.get('getWalletAddress', [
+            { type: 'slice', cell: makeCellFrom(ownerAddress, (v, b) => b.storeAddress(v)) },
+        ]));
+        return r.readSlice().loadAddress();
+    }
+}
+exports.JettonMinter = JettonMinter;
+JettonMinter.Errors = {
+    'ERR_NOT_ADMIN': 73,
+    'ERR_NOT_FROM_WALLET': 74,
+    'Errors.InvalidWorkchain': 38296,
+};