@metoncash/sdk-v1 0.1.0

package/dist/wrappers/Minter.gen.js

@@ -0,0 +1,700 @@
+"use strict";
+// AUTO-GENERATED, do not edit
+// It's a TypeScript wrapper for a Minter 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.Minter = exports.Proof = exports.Point = exports.InternalFlipWalletStatus = exports.InternalRegister = exports.InternalDeposit = exports.InternalResetGas = exports.FlipWalletStatus = exports.InternalWithdraw = exports.Register = exports.InternalInitMinter = exports.MinterStorage = exports.MinterStorageAdditionalData = exports.MinterRuntimeStorage = exports.ExcessMessage = exports.JettonTransferNotification = exports.JettonTransfer = 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 storeTolkAddressAny(a, b) {
+    let maybe_addr = a === 'none' ? null : a;
+    b.storeAddress(maybe_addr);
+}
+function loadTolkAddressAny(s) {
+    let maybe_addr = s.loadAddressAny();
+    return maybe_addr === null ? 'none' : maybe_addr;
+}
+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();
+    }
+    readNullable(readFn_T) {
+        if (this.tuple[0].type === 'null') {
+            this.tuple.shift();
+            return null;
+        }
+        return readFn_T(this);
+    }
+}
+exports.JettonTransfer = {
+    PREFIX: 0x0f8a7ea5,
+    create(args) {
+        return {
+            $: 'JettonTransfer',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x0f8a7ea5, 'JettonTransfer');
+        return {
+            $: 'JettonTransfer',
+            queryId: s.loadUintBig(64),
+            jettonAmount: s.loadCoins(),
+            transferRecipient: s.loadAddress(),
+            sendExcessesTo: s.loadMaybeAddress(),
+            customPayload: s.loadBoolean() ? s.loadRef() : null,
+            forwardTonAmount: s.loadCoins(),
+            forwardPayload: loadTolkRemaining(s),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x0f8a7ea5, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeCoins(self.jettonAmount);
+        b.storeAddress(self.transferRecipient);
+        b.storeAddress(self.sendExcessesTo);
+        storeTolkNullable(self.customPayload, b, (v, b) => b.storeRef(v));
+        b.storeCoins(self.forwardTonAmount);
+        storeTolkRemaining(self.forwardPayload, b);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonTransfer.store);
+    }
+};
+exports.JettonTransferNotification = {
+    PREFIX: 0x7362d09c,
+    create(args) {
+        return {
+            $: 'JettonTransferNotification',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x7362d09c, 'JettonTransferNotification');
+        return {
+            $: 'JettonTransferNotification',
+            queryId: s.loadUintBig(64),
+            jettonAmount: s.loadCoins(),
+            from: s.loadAddress(),
+            forwardPayload: loadTolkRemaining(s),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x7362d09c, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeCoins(self.jettonAmount);
+        b.storeAddress(self.from);
+        storeTolkRemaining(self.forwardPayload, b);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.JettonTransferNotification.store);
+    }
+};
+exports.ExcessMessage = {
+    PREFIX: 0xd53276db,
+    create(args) {
+        return {
+            $: 'ExcessMessage',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0xd53276db, 'ExcessMessage');
+        return {
+            $: 'ExcessMessage',
+            queryId: s.loadUintBig(64),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0xd53276db, 32);
+        b.storeUint(self.queryId, 64);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.ExcessMessage.store);
+    }
+};
+exports.MinterRuntimeStorage = {
+    create(args) {
+        return {
+            $: 'MinterRuntimeStorage',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'MinterRuntimeStorage',
+            id: s.loadUintBig(32),
+            factory: s.loadAddress(),
+            manager: s.loadAddress(),
+            jettonMinter: s.loadAddress(),
+            jettonBalace: s.loadCoins(),
+            jettonWallet: s.loadMaybeAddress(),
+            walletCode: s.loadRef(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(self.id, 32);
+        b.storeAddress(self.factory);
+        b.storeAddress(self.manager);
+        b.storeAddress(self.jettonMinter);
+        b.storeCoins(self.jettonBalace);
+        b.storeAddress(self.jettonWallet);
+        b.storeRef(self.walletCode);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.MinterRuntimeStorage.store);
+    }
+};
+exports.MinterStorageAdditionalData = {
+    create(args) {
+        return {
+            $: 'MinterStorageAdditionalData',
+            jettonBalace: 0n,
+            jettonWallet: null,
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'MinterStorageAdditionalData',
+            jettonBalace: s.loadCoins(),
+            jettonWallet: s.loadMaybeAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeCoins(self.jettonBalace);
+        b.storeAddress(self.jettonWallet);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.MinterStorageAdditionalData.store);
+    }
+};
+exports.MinterStorage = {
+    create(args) {
+        return {
+            $: 'MinterStorage',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'MinterStorage',
+            id: s.loadUintBig(32),
+            factory: s.loadAddress(),
+            manager: s.loadAddress(),
+            jettonMinter: s.loadAddress(),
+            additionalData: loadCellRef(s, exports.MinterStorageAdditionalData.fromSlice),
+            walletCode: s.loadRef(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(self.id, 32);
+        b.storeAddress(self.factory);
+        b.storeAddress(self.manager);
+        b.storeAddress(self.jettonMinter);
+        storeCellRef(self.additionalData, b, exports.MinterStorageAdditionalData.store);
+        b.storeRef(self.walletCode);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.MinterStorage.store);
+    }
+};
+exports.InternalInitMinter = {
+    PREFIX: 0x537e7304,
+    create(args) {
+        return {
+            $: 'InternalInitMinter',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x537e7304, 'InternalInitMinter');
+        return {
+            $: 'InternalInitMinter',
+            queryId: s.loadUintBig(64),
+            jettonWallet: s.loadAddress(),
+            excesses: s.loadAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x537e7304, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.jettonWallet);
+        b.storeAddress(self.excesses);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.InternalInitMinter.store);
+    }
+};
+exports.Register = {
+    PREFIX: 0xa68f2242,
+    create(args) {
+        return {
+            $: 'Register',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0xa68f2242, 'Register');
+        return {
+            $: 'Register',
+            queryId: s.loadUintBig(64),
+            publicViewKey: exports.Point.fromSlice(s),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0xa68f2242, 32);
+        b.storeUint(self.queryId, 64);
+        exports.Point.store(self.publicViewKey, b);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.Register.store);
+    }
+};
+exports.InternalWithdraw = {
+    PREFIX: 0x37c7e6fe,
+    create(args) {
+        return {
+            $: 'InternalWithdraw',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x37c7e6fe, 'InternalWithdraw');
+        return {
+            $: 'InternalWithdraw',
+            queryId: s.loadUintBig(64),
+            from: s.loadAddress(),
+            amount: s.loadCoins(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x37c7e6fe, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.from);
+        b.storeCoins(self.amount);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.InternalWithdraw.store);
+    }
+};
+exports.FlipWalletStatus = {
+    PREFIX: 0x0fccc477,
+    create(args) {
+        return {
+            $: 'FlipWalletStatus',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x0fccc477, 'FlipWalletStatus');
+        return {
+            $: 'FlipWalletStatus',
+            queryId: s.loadUintBig(64),
+            owner: s.loadAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x0fccc477, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.owner);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.FlipWalletStatus.store);
+    }
+};
+exports.InternalResetGas = {
+    PREFIX: 0x28c6c21a,
+    create(args) {
+        return {
+            $: 'InternalResetGas',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x28c6c21a, 'InternalResetGas');
+        return {
+            $: 'InternalResetGas',
+            queryId: s.loadUintBig(64),
+            excess: s.loadAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x28c6c21a, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.excess);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.InternalResetGas.store);
+    }
+};
+exports.InternalDeposit = {
+    PREFIX: 0xde913221,
+    create(args) {
+        return {
+            $: 'InternalDeposit',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0xde913221, 'InternalDeposit');
+        return {
+            $: 'InternalDeposit',
+            queryId: s.loadUintBig(64),
+            amount: s.loadCoins(),
+            commitment: exports.Point.fromSlice(s),
+            proof: loadCellRef(s, exports.Proof.fromSlice),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0xde913221, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeCoins(self.amount);
+        exports.Point.store(self.commitment, b);
+        storeCellRef(self.proof, b, exports.Proof.store);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.InternalDeposit.store);
+    }
+};
+exports.InternalRegister = {
+    PREFIX: 0xdde0f974,
+    create(args) {
+        return {
+            $: 'InternalRegister',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0xdde0f974, 'InternalRegister');
+        return {
+            $: 'InternalRegister',
+            queryId: s.loadUintBig(64),
+            publicViewKey: exports.Point.fromSlice(s),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0xdde0f974, 32);
+        b.storeUint(self.queryId, 64);
+        exports.Point.store(self.publicViewKey, b);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.InternalRegister.store);
+    }
+};
+exports.InternalFlipWalletStatus = {
+    PREFIX: 0x158bd66b,
+    create(args) {
+        return {
+            $: 'InternalFlipWalletStatus',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x158bd66b, 'InternalFlipWalletStatus');
+        return {
+            $: 'InternalFlipWalletStatus',
+            queryId: s.loadUintBig(64),
+            excess: s.loadAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x158bd66b, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.excess);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.InternalFlipWalletStatus.store);
+    }
+};
+exports.Point = {
+    create(args) {
+        return {
+            $: 'Point',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'Point',
+            x: s.loadUintBig(256),
+            y: s.loadUintBig(256),
+        };
+    },
+    store(self, b) {
+        b.storeUint(self.x, 256);
+        b.storeUint(self.y, 256);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.Point.store);
+    }
+};
+exports.Proof = {
+    create(args) {
+        return {
+            $: 'Proof',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'Proof',
+            piA: s.loadRef(),
+            piB: s.loadRef(),
+            piC: s.loadRef(),
+        };
+    },
+    store(self, b) {
+        b.storeRef(self.piA);
+        b.storeRef(self.piB);
+        b.storeRef(self.piC);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.Proof.store);
+    }
+};
+class Minter {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static fromAddress(address) {
+        return new Minter(address);
+    }
+    static createCellOfInternalInitMinter(body) {
+        return exports.InternalInitMinter.toCell(exports.InternalInitMinter.create(body));
+    }
+    static createCellOfJettonTransferNotification(body) {
+        return exports.JettonTransferNotification.toCell(exports.JettonTransferNotification.create(body));
+    }
+    static createCellOfRegister(body) {
+        return exports.Register.toCell(exports.Register.create(body));
+    }
+    static createCellOfInternalWithdraw(body) {
+        return exports.InternalWithdraw.toCell(exports.InternalWithdraw.create(body));
+    }
+    static createCellOfFlipWalletStatus(body) {
+        return exports.FlipWalletStatus.toCell(exports.FlipWalletStatus.create(body));
+    }
+    static createCellOfInternalResetGas(body) {
+        return exports.InternalResetGas.toCell(exports.InternalResetGas.create(body));
+    }
+    static createCellOfExcessMessage(body) {
+        return exports.ExcessMessage.toCell(exports.ExcessMessage.create(body));
+    }
+    async sendDeploy(provider, via, msgValue, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: c.Cell.EMPTY,
+            ...extraOptions
+        });
+    }
+    async sendInternalInitMinter(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.InternalInitMinter.toCell(exports.InternalInitMinter.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendJettonTransferNotification(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.JettonTransferNotification.toCell(exports.JettonTransferNotification.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendRegister(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.Register.toCell(exports.Register.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendInternalWithdraw(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.InternalWithdraw.toCell(exports.InternalWithdraw.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendFlipWalletStatus(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.FlipWalletStatus.toCell(exports.FlipWalletStatus.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendInternalResetGas(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.InternalResetGas.toCell(exports.InternalResetGas.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendExcessMessage(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.ExcessMessage.toCell(exports.ExcessMessage.create(body)),
+            ...extraOptions
+        });
+    }
+    async getMinterData(provider) {
+        const r = StackReader.fromGetMethod(7, await provider.get('getMinterData', []));
+        return ({
+            $: 'MinterRuntimeStorage',
+            id: r.readBigInt(),
+            factory: r.readSlice().loadAddress(),
+            manager: r.readSlice().loadAddress(),
+            jettonMinter: r.readSlice().loadAddress(),
+            jettonBalace: r.readBigInt(),
+            jettonWallet: r.readNullable((r) => r.readSlice().loadAddress()),
+            walletCode: r.readCell(),
+        });
+    }
+    async getWalletAddress(provider, owner) {
+        const r = StackReader.fromGetMethod(1, await provider.get('get_wallet_address', [
+            { type: 'slice', cell: makeCellFrom(owner, (v, b) => b.storeAddress(v)) },
+        ]));
+        return r.readSlice().loadAddress();
+    }
+    async getJettonData(provider) {
+        const r = StackReader.fromGetMethod(5, await provider.get('get_jetton_data', []));
+        return [
+            r.readBigInt(),
+            r.readBigInt(),
+            loadTolkAddressAny(r.readSlice()),
+            r.readCell(),
+            r.readCell(),
+        ];
+    }
+}
+exports.Minter = Minter;
+Minter.Errors = {
+    'Errors.InvalidEitherBit': 1598,
+    'Errors.InvalidAmount': 3775,
+    'Errors.AlreadyInitialized': 16689,
+    'Errors.NotAlreadyInitialized': 22161,
+    'Errors.NotEnoughGas': 29432,
+    'Errors.InvalidPoint': 37828,
+    'Errors.InvalidWorkchain': 38296,
+    'Errors.WrongSender': 45881,
+    'Errors.WrongOp': 65535,
+};