@metoncash/sdk-v1 0.1.0

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

@@ -0,0 +1,265 @@
+import * as c from '@ton/core';
+import { ContractProvider, Sender, SendMode } from '@ton/core';
+export type CellRef<T> = {
+    ref: T;
+};
+type coins = bigint;
+type uint32 = bigint;
+type uint64 = bigint;
+/**
+ > struct (0xd53276db) ExcessMessage {
+ >     queryId: uint64
+ > }
+ */
+export interface ExcessMessage {
+    readonly $: 'ExcessMessage';
+    queryId: uint64;
+}
+export declare const ExcessMessage: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+    }): ExcessMessage;
+    fromSlice(s: c.Slice): ExcessMessage;
+    store(self: ExcessMessage, b: c.Builder): void;
+    toCell(self: ExcessMessage): c.Cell;
+};
+/**
+ > struct FactoryRuntimeStorage {
+ >     id: uint32
+ >     owner: address
+ >     minterCode: cell
+ >     walletCode: cell
+ > }
+ */
+export interface FactoryRuntimeStorage {
+    readonly $: 'FactoryRuntimeStorage';
+    id: uint32;
+    owner: c.Address;
+    minterCode: c.Cell;
+    walletCode: c.Cell;
+}
+export declare const FactoryRuntimeStorage: {
+    create(args: {
+        id: uint32;
+        owner: c.Address;
+        minterCode: c.Cell;
+        walletCode: c.Cell;
+    }): FactoryRuntimeStorage;
+    fromSlice(s: c.Slice): FactoryRuntimeStorage;
+    store(self: FactoryRuntimeStorage, b: c.Builder): void;
+    toCell(self: FactoryRuntimeStorage): c.Cell;
+};
+/**
+ > struct FactoryStorage {
+ >     id: uint32
+ >     owner: address
+ >     minterCode: cell
+ >     walletCode: cell
+ > }
+ */
+export interface FactoryStorage {
+    readonly $: 'FactoryStorage';
+    id: uint32;
+    owner: c.Address;
+    minterCode: c.Cell;
+    walletCode: c.Cell;
+}
+export declare const FactoryStorage: {
+    create(args: {
+        id: uint32;
+        owner: c.Address;
+        minterCode: c.Cell;
+        walletCode: c.Cell;
+    }): FactoryStorage;
+    fromSlice(s: c.Slice): FactoryStorage;
+    store(self: FactoryStorage, b: c.Builder): void;
+    toCell(self: FactoryStorage): c.Cell;
+};
+/**
+ > struct (0xcb639242) InitMinter {
+ >     queryId: uint64
+ >     minterId: uint32
+ >     jettonMinter: address
+ >     jettonWallet: address
+ > }
+ */
+export interface InitMinter {
+    readonly $: 'InitMinter';
+    queryId: uint64;
+    minterId: uint32;
+    jettonMinter: c.Address;
+    jettonWallet: c.Address;
+}
+export declare const InitMinter: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        minterId: uint32;
+        jettonMinter: c.Address;
+        jettonWallet: c.Address;
+    }): InitMinter;
+    fromSlice(s: c.Slice): InitMinter;
+    store(self: InitMinter, b: c.Builder): void;
+    toCell(self: InitMinter): c.Cell;
+};
+/**
+ > struct (0x53a9192c) ResetGas {
+ >     queryId: uint64
+ >     excess: address
+ > }
+ */
+export interface ResetGas {
+    readonly $: 'ResetGas';
+    queryId: uint64;
+    excess: c.Address;
+}
+export declare const ResetGas: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        excess: c.Address;
+    }): ResetGas;
+    fromSlice(s: c.Slice): ResetGas;
+    store(self: ResetGas, b: c.Builder): void;
+    toCell(self: ResetGas): c.Cell;
+};
+/**
+ > struct (0x726f0586) ResetMinterGas {
+ >     queryId: uint64
+ >     minterId: uint32
+ >     jettonMinter: address
+ >     manager: address
+ > }
+ */
+export interface ResetMinterGas {
+    readonly $: 'ResetMinterGas';
+    queryId: uint64;
+    minterId: uint32;
+    jettonMinter: c.Address;
+    manager: c.Address;
+}
+export declare const ResetMinterGas: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        minterId: uint32;
+        jettonMinter: c.Address;
+        manager: c.Address;
+    }): ResetMinterGas;
+    fromSlice(s: c.Slice): ResetMinterGas;
+    store(self: ResetMinterGas, b: c.Builder): void;
+    toCell(self: ResetMinterGas): c.Cell;
+};
+/**
+ > struct (0x537e7304) InternalInitMinter {
+ >     queryId: uint64
+ >     jettonWallet: address
+ >     excesses: address
+ > }
+ */
+export interface InternalInitMinter {
+    readonly $: 'InternalInitMinter';
+    queryId: uint64;
+    jettonWallet: c.Address;
+    excesses: c.Address;
+}
+export declare const InternalInitMinter: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonWallet: c.Address;
+        excesses: c.Address;
+    }): InternalInitMinter;
+    fromSlice(s: c.Slice): InternalInitMinter;
+    store(self: InternalInitMinter, b: c.Builder): void;
+    toCell(self: InternalInitMinter): c.Cell;
+};
+/**
+ > struct (0x28c6c21a) InternalResetGas {
+ >     queryId: uint64
+ >     excess: address
+ > }
+ */
+export interface InternalResetGas {
+    readonly $: 'InternalResetGas';
+    queryId: uint64;
+    excess: c.Address;
+}
+export declare const InternalResetGas: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        excess: c.Address;
+    }): InternalResetGas;
+    fromSlice(s: c.Slice): InternalResetGas;
+    store(self: InternalResetGas, b: c.Builder): void;
+    toCell(self: InternalResetGas): 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 Factory implements c.Contract {
+    static Errors: {
+        'Errors.NotEnoughGas': number;
+        'Errors.InvalidWorkchain': number;
+        'Errors.WrongSender': number;
+        'Errors.WrongOp': 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): Factory;
+    static createCellOfInitMinter(body: {
+        queryId: uint64;
+        minterId: uint32;
+        jettonMinter: c.Address;
+        jettonWallet: c.Address;
+    }): c.Cell;
+    static createCellOfResetGas(body: {
+        queryId: uint64;
+        excess: c.Address;
+    }): c.Cell;
+    static createCellOfResetMinterGas(body: {
+        queryId: uint64;
+        minterId: uint32;
+        jettonMinter: c.Address;
+        manager: c.Address;
+    }): c.Cell;
+    sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInitMinter(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        minterId: uint32;
+        jettonMinter: c.Address;
+        jettonWallet: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendResetGas(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        excess: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendResetMinterGas(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        minterId: uint32;
+        jettonMinter: c.Address;
+        manager: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    getFactoryData(provider: ContractProvider): Promise<FactoryRuntimeStorage>;
+    getMinterAddress(provider: ContractProvider, id: bigint, jettonMinter: c.Address, manager: c.Address): Promise<c.Address>;
+}
+export {};

package/dist/wrappers/Factory.gen.js

@@ -0,0 +1,401 @@
+"use strict";
+// AUTO-GENERATED, do not edit
+// It's a TypeScript wrapper for a Factory 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.Factory = exports.InternalResetGas = exports.InternalInitMinter = exports.ResetMinterGas = exports.ResetGas = exports.InitMinter = exports.FactoryStorage = exports.FactoryRuntimeStorage = exports.ExcessMessage = 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 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.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.FactoryRuntimeStorage = {
+    create(args) {
+        return {
+            $: 'FactoryRuntimeStorage',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'FactoryRuntimeStorage',
+            id: s.loadUintBig(32),
+            owner: s.loadAddress(),
+            minterCode: s.loadRef(),
+            walletCode: s.loadRef(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(self.id, 32);
+        b.storeAddress(self.owner);
+        b.storeRef(self.minterCode);
+        b.storeRef(self.walletCode);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.FactoryRuntimeStorage.store);
+    }
+};
+exports.FactoryStorage = {
+    create(args) {
+        return {
+            $: 'FactoryStorage',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'FactoryStorage',
+            id: s.loadUintBig(32),
+            owner: s.loadAddress(),
+            minterCode: s.loadRef(),
+            walletCode: s.loadRef(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(self.id, 32);
+        b.storeAddress(self.owner);
+        b.storeRef(self.minterCode);
+        b.storeRef(self.walletCode);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.FactoryStorage.store);
+    }
+};
+exports.InitMinter = {
+    PREFIX: 0xcb639242,
+    create(args) {
+        return {
+            $: 'InitMinter',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0xcb639242, 'InitMinter');
+        return {
+            $: 'InitMinter',
+            queryId: s.loadUintBig(64),
+            minterId: s.loadUintBig(32),
+            jettonMinter: s.loadAddress(),
+            jettonWallet: s.loadAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0xcb639242, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeUint(self.minterId, 32);
+        b.storeAddress(self.jettonMinter);
+        b.storeAddress(self.jettonWallet);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.InitMinter.store);
+    }
+};
+exports.ResetGas = {
+    PREFIX: 0x53a9192c,
+    create(args) {
+        return {
+            $: 'ResetGas',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x53a9192c, 'ResetGas');
+        return {
+            $: 'ResetGas',
+            queryId: s.loadUintBig(64),
+            excess: s.loadAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x53a9192c, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeAddress(self.excess);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.ResetGas.store);
+    }
+};
+exports.ResetMinterGas = {
+    PREFIX: 0x726f0586,
+    create(args) {
+        return {
+            $: 'ResetMinterGas',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        loadAndCheckPrefix32(s, 0x726f0586, 'ResetMinterGas');
+        return {
+            $: 'ResetMinterGas',
+            queryId: s.loadUintBig(64),
+            minterId: s.loadUintBig(32),
+            jettonMinter: s.loadAddress(),
+            manager: s.loadAddress(),
+        };
+    },
+    store(self, b) {
+        b.storeUint(0x726f0586, 32);
+        b.storeUint(self.queryId, 64);
+        b.storeUint(self.minterId, 32);
+        b.storeAddress(self.jettonMinter);
+        b.storeAddress(self.manager);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.ResetMinterGas.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.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);
+    }
+};
+class Factory {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static fromAddress(address) {
+        return new Factory(address);
+    }
+    static createCellOfInitMinter(body) {
+        return exports.InitMinter.toCell(exports.InitMinter.create(body));
+    }
+    static createCellOfResetGas(body) {
+        return exports.ResetGas.toCell(exports.ResetGas.create(body));
+    }
+    static createCellOfResetMinterGas(body) {
+        return exports.ResetMinterGas.toCell(exports.ResetMinterGas.create(body));
+    }
+    async sendDeploy(provider, via, msgValue, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: c.Cell.EMPTY,
+            ...extraOptions
+        });
+    }
+    async sendInitMinter(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.InitMinter.toCell(exports.InitMinter.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendResetGas(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.ResetGas.toCell(exports.ResetGas.create(body)),
+            ...extraOptions
+        });
+    }
+    async sendResetMinterGas(provider, via, msgValue, body, extraOptions) {
+        return provider.internal(via, {
+            value: msgValue,
+            body: exports.ResetMinterGas.toCell(exports.ResetMinterGas.create(body)),
+            ...extraOptions
+        });
+    }
+    async getFactoryData(provider) {
+        const r = StackReader.fromGetMethod(4, await provider.get('getFactoryData', []));
+        return ({
+            $: 'FactoryRuntimeStorage',
+            id: r.readBigInt(),
+            owner: r.readSlice().loadAddress(),
+            minterCode: r.readCell(),
+            walletCode: r.readCell(),
+        });
+    }
+    async getMinterAddress(provider, id, jettonMinter, manager) {
+        const r = StackReader.fromGetMethod(1, await provider.get('getMinterAddress', [
+            { type: 'int', value: id },
+            { type: 'slice', cell: makeCellFrom(jettonMinter, (v, b) => b.storeAddress(v)) },
+            { type: 'slice', cell: makeCellFrom(manager, (v, b) => b.storeAddress(v)) },
+        ]));
+        return r.readSlice().loadAddress();
+    }
+}
+exports.Factory = Factory;
+Factory.Errors = {
+    'Errors.NotEnoughGas': 29432,
+    'Errors.InvalidWorkchain': 38296,
+    'Errors.WrongSender': 45881,
+    'Errors.WrongOp': 65535,
+};