@metoncash/sdk-v1 0.1.0 → 0.2.0

package/dist/prover.d.ts

@@ -69,6 +69,12 @@ export declare class MetonSDK {
      *   <dir>/<c>/<c>_js/<c>.wasm  and  <dir>/<c>/<c>_final.zkey
      */
     static fromBuildDir(dir: string): MetonSDK;
+    /**
+     * Zero-config: use the proving artifacts (wasm + zkey) shipped with this
+     * package under `artifacts/` (populated at build time from the repo's `build/`).
+     * These are tied to a specific trusted setup — verify against the on-chain vkey.
+     */
+    static bundled(): MetonSDK;
     private prove;
     /** Deposit a public `amount`, producing a commitment to it. */
     deposit(args: DepositArgs): Promise<DepositResult>;

package/dist/prover.js

@@ -57,6 +57,14 @@ class MetonSDK {
         });
         return new MetonSDK({ deposit: mk("deposit"), withdraw: mk("withdraw"), transfer: mk("transfer") });
     }
+    /**
+     * Zero-config: use the proving artifacts (wasm + zkey) shipped with this
+     * package under `artifacts/` (populated at build time from the repo's `build/`).
+     * These are tied to a specific trusted setup — verify against the on-chain vkey.
+     */
+    static bundled() {
+        return MetonSDK.fromBuildDir(path.join(__dirname, "..", "artifacts"));
+    }
     prove(art, input) {
         return snarkjs.groth16.fullProve(input, art.wasm, art.zkey);
     }

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@metoncash/sdk-v1",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "artifacts"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node ../scripts/strip_sdk_dist.cjs",
+    "build": "rm -rf dist && tsc -p tsconfig.json && node ../scripts/copy_sdk_artifacts.cjs && node ../scripts/strip_sdk_dist.cjs",
     "test": "jest",
     "prepare": "npm run build"
   },

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

@@ -1,542 +0,0 @@
-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;
-type uint256 = bigint;
-/**
- > struct AccountRuntimeStorage {
- >     locked: bool
- >     minter: address
- >     owner: address
- >     seqNo: uint32
- >     publicViewKey: Point
- >     commitment: Point
- > }
- */
-export interface AccountRuntimeStorage {
-    readonly $: 'AccountRuntimeStorage';
-    locked: boolean;
-    minter: c.Address;
-    owner: c.Address;
-    seqNo: uint32;
-    publicViewKey: Point;
-    commitment: Point;
-}
-export declare const AccountRuntimeStorage: {
-    create(args: {
-        locked: boolean;
-        minter: c.Address;
-        owner: c.Address;
-        seqNo: uint32;
-        publicViewKey: Point;
-        commitment: Point;
-    }): AccountRuntimeStorage;
-    fromSlice(s: c.Slice): AccountRuntimeStorage;
-    store(self: AccountRuntimeStorage, b: c.Builder): void;
-    toCell(self: AccountRuntimeStorage): c.Cell;
-};
-/**
- > struct AccountStorage {
- >     locked: bool
- >     minter: address
- >     owner: address
- >     seqNo: uint32
- >     publicViewKey: Cell<Point>
- >     commitment: Cell<Point>
- > }
- */
-export interface AccountStorage {
-    readonly $: 'AccountStorage';
-    locked: boolean;
-    minter: c.Address;
-    owner: c.Address;
-    seqNo: uint32;
-    publicViewKey: CellRef<Point>;
-    commitment: CellRef<Point>;
-}
-export declare const AccountStorage: {
-    create(args: {
-        locked?: boolean;
-        minter: c.Address;
-        owner: c.Address;
-        seqNo?: uint32;
-        publicViewKey: CellRef<Point>;
-        commitment: CellRef<Point>;
-    }): AccountStorage;
-    fromSlice(s: c.Slice): AccountStorage;
-    store(self: AccountStorage, b: c.Builder): void;
-    toCell(self: AccountStorage): c.Cell;
-};
-/**
- > struct TransferAdditionalData {
- >     ephemeral: Point
- >     encAmount: uint256
- >     encBlind: Cell<uint256>
- > }
- */
-export interface TransferAdditionalData {
-    readonly $: 'TransferAdditionalData';
-    ephemeral: Point;
-    encAmount: uint256;
-    encBlind: CellRef<uint256>;
-}
-export declare const TransferAdditionalData: {
-    create(args: {
-        ephemeral: Point;
-        encAmount: uint256;
-        encBlind: CellRef<uint256>;
-    }): TransferAdditionalData;
-    fromSlice(s: c.Slice): TransferAdditionalData;
-    store(self: TransferAdditionalData, b: c.Builder): void;
-    toCell(self: TransferAdditionalData): c.Cell;
-};
-/**
- > struct (0x886055ac) InitTransfer {
- >     queryId: uint64
- >     to: address
- >     receiverViewKey: Point
- >     newCommitment: Cell<Point>
- >     amountCommit: Cell<Point>
- >     proof: Cell<Proof>
- >     ad: Cell<TransferAdditionalData>
- > }
- */
-export interface InitTransfer {
-    readonly $: 'InitTransfer';
-    queryId: uint64;
-    to: c.Address;
-    receiverViewKey: Point;
-    newCommitment: CellRef<Point>;
-    amountCommit: CellRef<Point>;
-    proof: CellRef<Proof>;
-    ad: CellRef<TransferAdditionalData>;
-}
-export declare const InitTransfer: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        to: c.Address;
-        receiverViewKey: Point;
-        newCommitment: CellRef<Point>;
-        amountCommit: CellRef<Point>;
-        proof: CellRef<Proof>;
-        ad: CellRef<TransferAdditionalData>;
-    }): InitTransfer;
-    fromSlice(s: c.Slice): InitTransfer;
-    store(self: InitTransfer, b: c.Builder): void;
-    toCell(self: InitTransfer): c.Cell;
-};
-/**
- > struct InternalTransferAdditionalData {
- >     ephemeral: Point
- >     encBlind: uint256
- > }
- */
-export interface InternalTransferAdditionalData {
-    readonly $: 'InternalTransferAdditionalData';
-    ephemeral: Point;
-    encBlind: uint256;
-}
-export declare const InternalTransferAdditionalData: {
-    create(args: {
-        ephemeral: Point;
-        encBlind: uint256;
-    }): InternalTransferAdditionalData;
-    fromSlice(s: c.Slice): InternalTransferAdditionalData;
-    store(self: InternalTransferAdditionalData, b: c.Builder): void;
-    toCell(self: InternalTransferAdditionalData): c.Cell;
-};
-/**
- > struct (0xc22d1aa0) InternalTransfer {
- >     queryId: uint64
- >     from: address
- >     receiverViewKey: Point
- >     encAmount: Cell<uint256>
- >     amountCommit: Cell<Point>
- >     oldStorageCommitment: Cell<Point>
- >     ad: Cell<InternalTransferAdditionalData>
- > }
- */
-export interface InternalTransfer {
-    readonly $: 'InternalTransfer';
-    queryId: uint64;
-    from: c.Address;
-    receiverViewKey: Point;
-    encAmount: CellRef<uint256>;
-    amountCommit: CellRef<Point>;
-    oldStorageCommitment: CellRef<Point>;
-    ad: CellRef<InternalTransferAdditionalData>;
-}
-export declare const InternalTransfer: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        from: c.Address;
-        receiverViewKey: Point;
-        encAmount: CellRef<uint256>;
-        amountCommit: CellRef<Point>;
-        oldStorageCommitment: CellRef<Point>;
-        ad: CellRef<InternalTransferAdditionalData>;
-    }): InternalTransfer;
-    fromSlice(s: c.Slice): InternalTransfer;
-    store(self: InternalTransfer, b: c.Builder): void;
-    toCell(self: InternalTransfer): c.Cell;
-};
-/**
- > struct (0x5c4dfe3b) TransferCallback {
- >     queryId: uint64
- >     from: address
- > }
- */
-export interface TransferCallback {
-    readonly $: 'TransferCallback';
-    queryId: uint64;
-    from: c.Address;
-}
-export declare const TransferCallback: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        from: c.Address;
-    }): TransferCallback;
-    fromSlice(s: c.Slice): TransferCallback;
-    store(self: TransferCallback, b: c.Builder): void;
-    toCell(self: TransferCallback): c.Cell;
-};
-/**
- > struct (0xde913221) InternalDeposit {
- >     queryId: uint64
- >     amount: coins
- >     commitment: Point
- >     proof: Cell<Proof>
- > }
- */
-export interface InternalDeposit {
-    readonly $: 'InternalDeposit';
-    queryId: uint64;
-    amount: coins;
-    commitment: Point;
-    proof: CellRef<Proof>;
-}
-export declare const InternalDeposit: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        amount: coins;
-        commitment: Point;
-        proof: CellRef<Proof>;
-    }): InternalDeposit;
-    fromSlice(s: c.Slice): InternalDeposit;
-    store(self: InternalDeposit, b: c.Builder): void;
-    toCell(self: InternalDeposit): c.Cell;
-};
-/**
- > struct (0xa71f12ae) InitWithdraw {
- >     queryId: uint64
- >     amount: coins
- >     newCommitment: Cell<Point>
- >     proof: Cell<Proof>
- > }
- */
-export interface InitWithdraw {
-    readonly $: 'InitWithdraw';
-    queryId: uint64;
-    amount: coins;
-    newCommitment: CellRef<Point>;
-    proof: CellRef<Proof>;
-}
-export declare const InitWithdraw: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        amount: coins;
-        newCommitment: CellRef<Point>;
-        proof: CellRef<Proof>;
-    }): InitWithdraw;
-    fromSlice(s: c.Slice): InitWithdraw;
-    store(self: InitWithdraw, b: c.Builder): void;
-    toCell(self: InitWithdraw): c.Cell;
-};
-/**
- > struct (0xdde0f974) InternalRegister {
- >     queryId: uint64
- >     publicViewKey: Point
- > }
- */
-export interface InternalRegister {
-    readonly $: 'InternalRegister';
-    queryId: uint64;
-    publicViewKey: Point;
-}
-export declare const InternalRegister: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        publicViewKey: Point;
-    }): InternalRegister;
-    fromSlice(s: c.Slice): InternalRegister;
-    store(self: InternalRegister, b: c.Builder): void;
-    toCell(self: InternalRegister): c.Cell;
-};
-/**
- > struct (0x158bd66b) InternalFlipAccountStatus {
- >     queryId: uint64
- >     excess: address
- > }
- */
-export interface InternalFlipAccountStatus {
-    readonly $: 'InternalFlipAccountStatus';
-    queryId: uint64;
-    excess: c.Address;
-}
-export declare const InternalFlipAccountStatus: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        excess: c.Address;
-    }): InternalFlipAccountStatus;
-    fromSlice(s: c.Slice): InternalFlipAccountStatus;
-    store(self: InternalFlipAccountStatus, b: c.Builder): void;
-    toCell(self: InternalFlipAccountStatus): c.Cell;
-};
-/**
- > struct Point {
- >     x: uint256
- >     y: uint256
- > }
- */
-export interface Point {
-    readonly $: 'Point';
-    x: uint256;
-    y: uint256;
-}
-export declare const Point: {
-    create(args: {
-        x: uint256;
-        y: uint256;
-    }): Point;
-    fromSlice(s: c.Slice): Point;
-    store(self: Point, b: c.Builder): void;
-    toCell(self: Point): c.Cell;
-};
-/**
- > struct Proof {
- >     piA: cell
- >     piB: cell
- >     piC: cell
- > }
- */
-export interface Proof {
-    readonly $: 'Proof';
-    piA: c.Cell;
-    piB: c.Cell;
-    piC: c.Cell;
-}
-export declare const Proof: {
-    create(args: {
-        piA: c.Cell;
-        piB: c.Cell;
-        piC: c.Cell;
-    }): Proof;
-    fromSlice(s: c.Slice): Proof;
-    store(self: Proof, b: c.Builder): void;
-    toCell(self: Proof): c.Cell;
-};
-/**
- > 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 (0x37c7e6fe) InternalWithdraw {
- >     queryId: uint64
- >     from: address
- >     amount: coins
- > }
- */
-export interface InternalWithdraw {
-    readonly $: 'InternalWithdraw';
-    queryId: uint64;
-    from: c.Address;
-    amount: coins;
-}
-export declare const InternalWithdraw: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        from: c.Address;
-        amount: coins;
-    }): InternalWithdraw;
-    fromSlice(s: c.Slice): InternalWithdraw;
-    store(self: InternalWithdraw, b: c.Builder): void;
-    toCell(self: InternalWithdraw): c.Cell;
-};
-/**
- > struct (0x4882c87b) TransferSuccessfulLog {
- >     queryId: uint64
- >     from: address
- >     data: cell
- > }
- */
-export interface TransferSuccessfulLog {
-    readonly $: 'TransferSuccessfulLog';
-    queryId: uint64;
-    from: c.Address;
-    data: c.Cell;
-}
-export declare const TransferSuccessfulLog: {
-    PREFIX: number;
-    create(args: {
-        queryId: uint64;
-        from: c.Address;
-        data: c.Cell;
-    }): TransferSuccessfulLog;
-    fromSlice(s: c.Slice): TransferSuccessfulLog;
-    store(self: TransferSuccessfulLog, b: c.Builder): void;
-    toCell(self: TransferSuccessfulLog): 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 Account implements c.Contract {
-    static Errors: {
-        'DepositErrors.InvalidInputs': number;
-        'TransferErrors.InvalidInputs': number;
-        'WithdrawErrors.InvalidInputs': number;
-        'TransferErrors.IndexOutOfRange': number;
-        'Errors.InvalidProof': number;
-        'Errors.InvalidAmount': number;
-        'Errors.AlreadyInitialized': number;
-        'Errors.NotAlreadyInitialized': number;
-        'Errors.NotEnoughGas': number;
-        'Errors.InvalidPoint': number;
-        'Errors.InvalidWorkchain': number;
-        'Errors.WrongSender': number;
-        'Errors.PositionLocked': 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): Account;
-    static createCellOfInternalDeposit(body: {
-        queryId: uint64;
-        amount: coins;
-        commitment: Point;
-        proof: CellRef<Proof>;
-    }): c.Cell;
-    static createCellOfInitTransfer(body: {
-        queryId: uint64;
-        to: c.Address;
-        receiverViewKey: Point;
-        newCommitment: CellRef<Point>;
-        amountCommit: CellRef<Point>;
-        proof: CellRef<Proof>;
-        ad: CellRef<TransferAdditionalData>;
-    }): c.Cell;
-    static createCellOfInternalTransfer(body: {
-        queryId: uint64;
-        from: c.Address;
-        receiverViewKey: Point;
-        encAmount: CellRef<uint256>;
-        amountCommit: CellRef<Point>;
-        oldStorageCommitment: CellRef<Point>;
-        ad: CellRef<InternalTransferAdditionalData>;
-    }): c.Cell;
-    static createCellOfTransferCallback(body: {
-        queryId: uint64;
-        from: c.Address;
-    }): c.Cell;
-    static createCellOfInitWithdraw(body: {
-        queryId: uint64;
-        amount: coins;
-        newCommitment: CellRef<Point>;
-        proof: CellRef<Proof>;
-    }): c.Cell;
-    static createCellOfInternalRegister(body: {
-        queryId: uint64;
-        publicViewKey: Point;
-    }): c.Cell;
-    static createCellOfInternalFlipAccountStatus(body: {
-        queryId: uint64;
-        excess: c.Address;
-    }): c.Cell;
-    sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions): Promise<void>;
-    sendInternalDeposit(provider: ContractProvider, via: Sender, msgValue: coins, body: {
-        queryId: uint64;
-        amount: coins;
-        commitment: Point;
-        proof: CellRef<Proof>;
-    }, extraOptions?: ExtraSendOptions): Promise<void>;
-    sendInitTransfer(provider: ContractProvider, via: Sender, msgValue: coins, body: {
-        queryId: uint64;
-        to: c.Address;
-        receiverViewKey: Point;
-        newCommitment: CellRef<Point>;
-        amountCommit: CellRef<Point>;
-        proof: CellRef<Proof>;
-        ad: CellRef<TransferAdditionalData>;
-    }, extraOptions?: ExtraSendOptions): Promise<void>;
-    sendInternalTransfer(provider: ContractProvider, via: Sender, msgValue: coins, body: {
-        queryId: uint64;
-        from: c.Address;
-        receiverViewKey: Point;
-        encAmount: CellRef<uint256>;
-        amountCommit: CellRef<Point>;
-        oldStorageCommitment: CellRef<Point>;
-        ad: CellRef<InternalTransferAdditionalData>;
-    }, extraOptions?: ExtraSendOptions): Promise<void>;
-    sendTransferCallback(provider: ContractProvider, via: Sender, msgValue: coins, body: {
-        queryId: uint64;
-        from: c.Address;
-    }, extraOptions?: ExtraSendOptions): Promise<void>;
-    sendInitWithdraw(provider: ContractProvider, via: Sender, msgValue: coins, body: {
-        queryId: uint64;
-        amount: coins;
-        newCommitment: CellRef<Point>;
-        proof: CellRef<Proof>;
-    }, extraOptions?: ExtraSendOptions): Promise<void>;
-    sendInternalRegister(provider: ContractProvider, via: Sender, msgValue: coins, body: {
-        queryId: uint64;
-        publicViewKey: Point;
-    }, extraOptions?: ExtraSendOptions): Promise<void>;
-    sendInternalFlipAccountStatus(provider: ContractProvider, via: Sender, msgValue: coins, body: {
-        queryId: uint64;
-        excess: c.Address;
-    }, extraOptions?: ExtraSendOptions): Promise<void>;
-    getAccountData(provider: ContractProvider): Promise<AccountRuntimeStorage>;
-}
-export {};

package/dist/wrappers/Account.gen.js

@@ -1,677 +0,0 @@
-"use strict";
-// AUTO-GENERATED, do not edit
-// It's a TypeScript wrapper for a Account 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.Account = exports.TransferSuccessfulLog = exports.InternalWithdraw = exports.ExcessMessage = exports.Proof = exports.Point = exports.InternalFlipAccountStatus = exports.InternalRegister = exports.InitWithdraw = exports.InternalDeposit = exports.TransferCallback = exports.InternalTransfer = exports.InternalTransferAdditionalData = exports.InitTransfer = exports.TransferAdditionalData = exports.AccountStorage = exports.AccountRuntimeStorage = 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.AccountRuntimeStorage = {
-    create(args) {
-        return {
-            $: 'AccountRuntimeStorage',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        return {
-            $: 'AccountRuntimeStorage',
-            locked: s.loadBoolean(),
-            minter: s.loadAddress(),
-            owner: s.loadAddress(),
-            seqNo: s.loadUintBig(32),
-            publicViewKey: exports.Point.fromSlice(s),
-            commitment: exports.Point.fromSlice(s),
-        };
-    },
-    store(self, b) {
-        b.storeBit(self.locked);
-        b.storeAddress(self.minter);
-        b.storeAddress(self.owner);
-        b.storeUint(self.seqNo, 32);
-        exports.Point.store(self.publicViewKey, b);
-        exports.Point.store(self.commitment, b);
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.AccountRuntimeStorage.store);
-    }
-};
-exports.AccountStorage = {
-    create(args) {
-        return {
-            $: 'AccountStorage',
-            locked: false,
-            seqNo: 0n,
-            ...args
-        };
-    },
-    fromSlice(s) {
-        return {
-            $: 'AccountStorage',
-            locked: s.loadBoolean(),
-            minter: s.loadAddress(),
-            owner: s.loadAddress(),
-            seqNo: s.loadUintBig(32),
-            publicViewKey: loadCellRef(s, exports.Point.fromSlice),
-            commitment: loadCellRef(s, exports.Point.fromSlice),
-        };
-    },
-    store(self, b) {
-        b.storeBit(self.locked);
-        b.storeAddress(self.minter);
-        b.storeAddress(self.owner);
-        b.storeUint(self.seqNo, 32);
-        storeCellRef(self.publicViewKey, b, exports.Point.store);
-        storeCellRef(self.commitment, b, exports.Point.store);
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.AccountStorage.store);
-    }
-};
-exports.TransferAdditionalData = {
-    create(args) {
-        return {
-            $: 'TransferAdditionalData',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        return {
-            $: 'TransferAdditionalData',
-            ephemeral: exports.Point.fromSlice(s),
-            encAmount: s.loadUintBig(256),
-            encBlind: loadCellRef(s, (s) => s.loadUintBig(256)),
-        };
-    },
-    store(self, b) {
-        exports.Point.store(self.ephemeral, b);
-        b.storeUint(self.encAmount, 256);
-        storeCellRef(self.encBlind, b, (v, b) => b.storeUint(v, 256));
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.TransferAdditionalData.store);
-    }
-};
-exports.InitTransfer = {
-    PREFIX: 0x886055ac,
-    create(args) {
-        return {
-            $: 'InitTransfer',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        loadAndCheckPrefix32(s, 0x886055ac, 'InitTransfer');
-        return {
-            $: 'InitTransfer',
-            queryId: s.loadUintBig(64),
-            to: s.loadAddress(),
-            receiverViewKey: exports.Point.fromSlice(s),
-            newCommitment: loadCellRef(s, exports.Point.fromSlice),
-            amountCommit: loadCellRef(s, exports.Point.fromSlice),
-            proof: loadCellRef(s, exports.Proof.fromSlice),
-            ad: loadCellRef(s, exports.TransferAdditionalData.fromSlice),
-        };
-    },
-    store(self, b) {
-        b.storeUint(0x886055ac, 32);
-        b.storeUint(self.queryId, 64);
-        b.storeAddress(self.to);
-        exports.Point.store(self.receiverViewKey, b);
-        storeCellRef(self.newCommitment, b, exports.Point.store);
-        storeCellRef(self.amountCommit, b, exports.Point.store);
-        storeCellRef(self.proof, b, exports.Proof.store);
-        storeCellRef(self.ad, b, exports.TransferAdditionalData.store);
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.InitTransfer.store);
-    }
-};
-exports.InternalTransferAdditionalData = {
-    create(args) {
-        return {
-            $: 'InternalTransferAdditionalData',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        return {
-            $: 'InternalTransferAdditionalData',
-            ephemeral: exports.Point.fromSlice(s),
-            encBlind: s.loadUintBig(256),
-        };
-    },
-    store(self, b) {
-        exports.Point.store(self.ephemeral, b);
-        b.storeUint(self.encBlind, 256);
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.InternalTransferAdditionalData.store);
-    }
-};
-exports.InternalTransfer = {
-    PREFIX: 0xc22d1aa0,
-    create(args) {
-        return {
-            $: 'InternalTransfer',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        loadAndCheckPrefix32(s, 0xc22d1aa0, 'InternalTransfer');
-        return {
-            $: 'InternalTransfer',
-            queryId: s.loadUintBig(64),
-            from: s.loadAddress(),
-            receiverViewKey: exports.Point.fromSlice(s),
-            encAmount: loadCellRef(s, (s) => s.loadUintBig(256)),
-            amountCommit: loadCellRef(s, exports.Point.fromSlice),
-            oldStorageCommitment: loadCellRef(s, exports.Point.fromSlice),
-            ad: loadCellRef(s, exports.InternalTransferAdditionalData.fromSlice),
-        };
-    },
-    store(self, b) {
-        b.storeUint(0xc22d1aa0, 32);
-        b.storeUint(self.queryId, 64);
-        b.storeAddress(self.from);
-        exports.Point.store(self.receiverViewKey, b);
-        storeCellRef(self.encAmount, b, (v, b) => b.storeUint(v, 256));
-        storeCellRef(self.amountCommit, b, exports.Point.store);
-        storeCellRef(self.oldStorageCommitment, b, exports.Point.store);
-        storeCellRef(self.ad, b, exports.InternalTransferAdditionalData.store);
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.InternalTransfer.store);
-    }
-};
-exports.TransferCallback = {
-    PREFIX: 0x5c4dfe3b,
-    create(args) {
-        return {
-            $: 'TransferCallback',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        loadAndCheckPrefix32(s, 0x5c4dfe3b, 'TransferCallback');
-        return {
-            $: 'TransferCallback',
-            queryId: s.loadUintBig(64),
-            from: s.loadAddress(),
-        };
-    },
-    store(self, b) {
-        b.storeUint(0x5c4dfe3b, 32);
-        b.storeUint(self.queryId, 64);
-        b.storeAddress(self.from);
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.TransferCallback.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.InitWithdraw = {
-    PREFIX: 0xa71f12ae,
-    create(args) {
-        return {
-            $: 'InitWithdraw',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        loadAndCheckPrefix32(s, 0xa71f12ae, 'InitWithdraw');
-        return {
-            $: 'InitWithdraw',
-            queryId: s.loadUintBig(64),
-            amount: s.loadCoins(),
-            newCommitment: loadCellRef(s, exports.Point.fromSlice),
-            proof: loadCellRef(s, exports.Proof.fromSlice),
-        };
-    },
-    store(self, b) {
-        b.storeUint(0xa71f12ae, 32);
-        b.storeUint(self.queryId, 64);
-        b.storeCoins(self.amount);
-        storeCellRef(self.newCommitment, b, exports.Point.store);
-        storeCellRef(self.proof, b, exports.Proof.store);
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.InitWithdraw.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.InternalFlipAccountStatus = {
-    PREFIX: 0x158bd66b,
-    create(args) {
-        return {
-            $: 'InternalFlipAccountStatus',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        loadAndCheckPrefix32(s, 0x158bd66b, 'InternalFlipAccountStatus');
-        return {
-            $: 'InternalFlipAccountStatus',
-            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.InternalFlipAccountStatus.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);
-    }
-};
-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.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.TransferSuccessfulLog = {
-    PREFIX: 0x4882c87b,
-    create(args) {
-        return {
-            $: 'TransferSuccessfulLog',
-            ...args
-        };
-    },
-    fromSlice(s) {
-        loadAndCheckPrefix32(s, 0x4882c87b, 'TransferSuccessfulLog');
-        return {
-            $: 'TransferSuccessfulLog',
-            queryId: s.loadUintBig(64),
-            from: s.loadAddress(),
-            data: s.loadRef(),
-        };
-    },
-    store(self, b) {
-        b.storeUint(0x4882c87b, 32);
-        b.storeUint(self.queryId, 64);
-        b.storeAddress(self.from);
-        b.storeRef(self.data);
-    },
-    toCell(self) {
-        return makeCellFrom(self, exports.TransferSuccessfulLog.store);
-    }
-};
-class Account {
-    constructor(address, init) {
-        this.address = address;
-        this.init = init;
-    }
-    static fromAddress(address) {
-        return new Account(address);
-    }
-    static createCellOfInternalDeposit(body) {
-        return exports.InternalDeposit.toCell(exports.InternalDeposit.create(body));
-    }
-    static createCellOfInitTransfer(body) {
-        return exports.InitTransfer.toCell(exports.InitTransfer.create(body));
-    }
-    static createCellOfInternalTransfer(body) {
-        return exports.InternalTransfer.toCell(exports.InternalTransfer.create(body));
-    }
-    static createCellOfTransferCallback(body) {
-        return exports.TransferCallback.toCell(exports.TransferCallback.create(body));
-    }
-    static createCellOfInitWithdraw(body) {
-        return exports.InitWithdraw.toCell(exports.InitWithdraw.create(body));
-    }
-    static createCellOfInternalRegister(body) {
-        return exports.InternalRegister.toCell(exports.InternalRegister.create(body));
-    }
-    static createCellOfInternalFlipAccountStatus(body) {
-        return exports.InternalFlipAccountStatus.toCell(exports.InternalFlipAccountStatus.create(body));
-    }
-    async sendDeploy(provider, via, msgValue, extraOptions) {
-        return provider.internal(via, {
-            value: msgValue,
-            body: c.Cell.EMPTY,
-            ...extraOptions
-        });
-    }
-    async sendInternalDeposit(provider, via, msgValue, body, extraOptions) {
-        return provider.internal(via, {
-            value: msgValue,
-            body: exports.InternalDeposit.toCell(exports.InternalDeposit.create(body)),
-            ...extraOptions
-        });
-    }
-    async sendInitTransfer(provider, via, msgValue, body, extraOptions) {
-        return provider.internal(via, {
-            value: msgValue,
-            body: exports.InitTransfer.toCell(exports.InitTransfer.create(body)),
-            ...extraOptions
-        });
-    }
-    async sendInternalTransfer(provider, via, msgValue, body, extraOptions) {
-        return provider.internal(via, {
-            value: msgValue,
-            body: exports.InternalTransfer.toCell(exports.InternalTransfer.create(body)),
-            ...extraOptions
-        });
-    }
-    async sendTransferCallback(provider, via, msgValue, body, extraOptions) {
-        return provider.internal(via, {
-            value: msgValue,
-            body: exports.TransferCallback.toCell(exports.TransferCallback.create(body)),
-            ...extraOptions
-        });
-    }
-    async sendInitWithdraw(provider, via, msgValue, body, extraOptions) {
-        return provider.internal(via, {
-            value: msgValue,
-            body: exports.InitWithdraw.toCell(exports.InitWithdraw.create(body)),
-            ...extraOptions
-        });
-    }
-    async sendInternalRegister(provider, via, msgValue, body, extraOptions) {
-        return provider.internal(via, {
-            value: msgValue,
-            body: exports.InternalRegister.toCell(exports.InternalRegister.create(body)),
-            ...extraOptions
-        });
-    }
-    async sendInternalFlipAccountStatus(provider, via, msgValue, body, extraOptions) {
-        return provider.internal(via, {
-            value: msgValue,
-            body: exports.InternalFlipAccountStatus.toCell(exports.InternalFlipAccountStatus.create(body)),
-            ...extraOptions
-        });
-    }
-    async getAccountData(provider) {
-        const r = StackReader.fromGetMethod(8, await provider.get('getAccountData', []));
-        return ({
-            $: 'AccountRuntimeStorage',
-            locked: r.readBoolean(),
-            minter: r.readSlice().loadAddress(),
-            owner: r.readSlice().loadAddress(),
-            seqNo: r.readBigInt(),
-            publicViewKey: ({
-                $: 'Point',
-                x: r.readBigInt(),
-                y: r.readBigInt(),
-            }),
-            commitment: ({
-                $: 'Point',
-                x: r.readBigInt(),
-                y: r.readBigInt(),
-            }),
-        });
-    }
-}
-exports.Account = Account;
-Account.Errors = {
-    'DepositErrors.InvalidInputs': 258,
-    'TransferErrors.InvalidInputs': 258,
-    'WithdrawErrors.InvalidInputs': 258,
-    'TransferErrors.IndexOutOfRange': 259,
-    'Errors.InvalidProof': 519,
-    'Errors.InvalidAmount': 3775,
-    'Errors.AlreadyInitialized': 16689,
-    'Errors.NotAlreadyInitialized': 22161,
-    'Errors.NotEnoughGas': 29432,
-    'Errors.InvalidPoint': 37828,
-    'Errors.InvalidWorkchain': 38296,
-    'Errors.WrongSender': 45881,
-    'Errors.PositionLocked': 48515,
-    'Errors.WrongOP': 65535,
-};