@ton/blueprint 0.10.0

package/dist/compile/OverwritableVirtualFileSystem.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { VirtualFileSystem } from '@tact-lang/compiler';
+export declare class OverwritableVirtualFileSystem implements VirtualFileSystem {
+    root: string;
+    overwrites: Map<string, Buffer>;
+    resolve(...path: string[]): string;
+    exists(path: string): boolean;
+    readFile(path: string): Buffer;
+    writeFile(path: string, content: string | Buffer): void;
+}

package/dist/compile/OverwritableVirtualFileSystem.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverwritableVirtualFileSystem = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+class OverwritableVirtualFileSystem {
+    constructor() {
+        this.root = '/';
+        this.overwrites = new Map();
+    }
+    resolve(...path) {
+        return (0, path_1.resolve)(...path);
+    }
+    exists(path) {
+        return (0, fs_1.existsSync)(path);
+    }
+    readFile(path) {
+        return this.overwrites.get(path) ?? (0, fs_1.readFileSync)(path);
+    }
+    writeFile(path, content) {
+        this.overwrites.set(path, typeof content === 'string' ? Buffer.from(content, 'utf-8') : content);
+    }
+}
+exports.OverwritableVirtualFileSystem = OverwritableVirtualFileSystem;

package/dist/compile/compile.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { Cell } from 'ton-core';
+export type FuncCompileResult = {
+    lang: 'func';
+    code: Cell;
+};
+export type TactCompileResult = {
+    lang: 'tact';
+    fs: Map<string, Buffer>;
+    code: Cell;
+};
+export type CompileResult = TactCompileResult | FuncCompileResult;
+export declare function doCompile(name: string): Promise<CompileResult>;
+export declare function compile(name: string): Promise<Cell>;

package/dist/compile/compile.js

@@ -0,0 +1,115 @@
+"use strict";
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = exports.doCompile = void 0;
+const func_js_1 = require("@ton-community/func-js");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const ton_core_1 = require("ton-core");
+const paths_1 = require("../paths");
+const compiler_1 = require("@tact-lang/compiler");
+const OverwritableVirtualFileSystem_1 = require("./OverwritableVirtualFileSystem");
+async function getCompilerConfigForContract(name) {
+    var _a;
+    require('ts-node/register');
+    const mod = await (_a = path_1.default.join(paths_1.WRAPPERS_DIR, name + '.compile.ts'), Promise.resolve().then(() => __importStar(require(_a))));
+    if (typeof mod.compile !== 'object') {
+        throw new Error(`Object 'compile' is missing`);
+    }
+    return mod.compile;
+}
+async function doCompileFunc(config) {
+    const cr = await (0, func_js_1.compileFunc)(config);
+    if (cr.status === 'error')
+        throw new Error(cr.message);
+    return {
+        lang: 'func',
+        code: ton_core_1.Cell.fromBase64(cr.codeBoc),
+    };
+}
+function findTactBoc(fs) {
+    let buf = undefined;
+    for (const [k, v] of fs) {
+        if (k.endsWith('.code.boc')) {
+            buf = v;
+            break;
+        }
+    }
+    if (buf === undefined) {
+        throw new Error('Could not find boc in tact compilation result');
+    }
+    return ton_core_1.Cell.fromBoc(buf)[0];
+}
+async function doCompileTact(config, name) {
+    const fs = new OverwritableVirtualFileSystem_1.OverwritableVirtualFileSystem();
+    const res = await (0, compiler_1.build)({
+        config: {
+            name: 'tact',
+            path: path_1.default.join(process.cwd(), config.target),
+            output: path_1.default.join(paths_1.BUILD_DIR, name),
+        },
+        stdlib: '/stdlib',
+        project: fs,
+    });
+    if (!res) {
+        throw new Error('Could not compile tact');
+    }
+    const code = findTactBoc(fs.overwrites);
+    return {
+        lang: 'tact',
+        fs: fs.overwrites,
+        code,
+    };
+}
+async function doCompileInner(name, config) {
+    if (config.lang === 'tact') {
+        return await doCompileTact(config, name);
+    }
+    return await doCompileFunc({
+        targets: config.targets,
+        sources: config.sources ?? ((path) => (0, fs_1.readFileSync)(path).toString()),
+        optLevel: config.optLevel,
+    });
+}
+async function doCompile(name) {
+    const config = await getCompilerConfigForContract(name);
+    if (config.preCompileHook !== undefined) {
+        await config.preCompileHook();
+    }
+    const res = await doCompileInner(name, config);
+    if (config.postCompileHook !== undefined) {
+        await config.postCompileHook(res.code);
+    }
+    return res;
+}
+exports.doCompile = doCompile;
+async function compile(name) {
+    const result = await doCompile(name);
+    return result.code;
+}
+exports.compile = compile;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { tonDeepLink, sleep } from './utils';
+export { NetworkProvider } from './network/NetworkProvider';
+export { createNetworkProvider } from './network/createNetworkProvider';
+export { compile } from './compile/compile';
+export { CompilerConfig } from './compile/CompilerConfig';
+export { UIProvider } from './ui/UIProvider';

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = exports.createNetworkProvider = exports.sleep = exports.tonDeepLink = void 0;
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "tonDeepLink", { enumerable: true, get: function () { return utils_1.tonDeepLink; } });
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return utils_1.sleep; } });
+var createNetworkProvider_1 = require("./network/createNetworkProvider");
+Object.defineProperty(exports, "createNetworkProvider", { enumerable: true, get: function () { return createNetworkProvider_1.createNetworkProvider; } });
+var compile_1 = require("./compile/compile");
+Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compile_1.compile; } });

package/dist/network/NetworkProvider.d.ts

@@ -0,0 +1,22 @@
+import { TonClient4 } from 'ton';
+import { Address, Cell, Contract, ContractProvider, OpenedContract, Sender } from 'ton-core';
+import { UIProvider } from '../ui/UIProvider';
+export interface NetworkProvider {
+    network(): 'mainnet' | 'testnet';
+    sender(): Sender;
+    api(): TonClient4;
+    provider(address: Address, init?: {
+        code?: Cell;
+        data?: Cell;
+    }): ContractProvider;
+    isContractDeployed(address: Address): Promise<boolean>;
+    waitForDeploy(address: Address, attempts?: number, sleepDuration?: number): Promise<void>;
+    /**
+     * @deprecated
+     *
+     * Use your Contract's `sendDeploy` method (or similar) together with `waitForDeploy` instead.
+     */
+    deploy(contract: Contract, value: bigint, body?: Cell, waitAttempts?: number): Promise<void>;
+    open<T extends Contract>(contract: T): OpenedContract<T>;
+    ui(): UIProvider;
+}

package/dist/network/NetworkProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/network/createNetworkProvider.d.ts

@@ -0,0 +1,3 @@
+import { UIProvider } from '../ui/UIProvider';
+import { NetworkProvider } from './NetworkProvider';
+export declare function createNetworkProvider(ui: UIProvider): Promise<NetworkProvider>;

package/dist/network/createNetworkProvider.js

@@ -0,0 +1,282 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _SendProviderSender_provider, _WrappedContractProvider_address, _WrappedContractProvider_provider, _WrappedContractProvider_init, _NetworkProviderImpl_tc, _NetworkProviderImpl_sender, _NetworkProviderImpl_network, _NetworkProviderImpl_explorer, _NetworkProviderImpl_ui;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNetworkProvider = void 0;
+const utils_1 = require("../utils");
+const arg_1 = __importDefault(require("arg"));
+const DeeplinkProvider_1 = require("./send/DeeplinkProvider");
+const TonConnectProvider_1 = require("./send/TonConnectProvider");
+const TonHubProvider_1 = require("./send/TonHubProvider");
+const ton_core_1 = require("ton-core");
+const ton_1 = require("ton");
+const ton_access_1 = require("@orbs-network/ton-access");
+const FSStorage_1 = require("./storage/FSStorage");
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+const ton_crypto_1 = require("ton-crypto");
+const MnemonicProvider_1 = require("./send/MnemonicProvider");
+const argSpec = {
+    '--mainnet': Boolean,
+    '--testnet': Boolean,
+    '--tonconnect': Boolean,
+    '--deeplink': Boolean,
+    '--tonhub': Boolean,
+    '--mnemonic': Boolean,
+    '--tonscan': Boolean,
+    '--tonapi': Boolean,
+    '--toncx': Boolean,
+    '--dton': Boolean,
+};
+class SendProviderSender {
+    constructor(provider) {
+        _SendProviderSender_provider.set(this, void 0);
+        __classPrivateFieldSet(this, _SendProviderSender_provider, provider, "f");
+        this.address = provider.address();
+    }
+    async send(args) {
+        if (args.bounce !== undefined) {
+            console.warn("Warning: blueprint's Sender does not support `bounce` flag, because it is ignored by all used Sender APIs");
+            console.warn('To silence this warning, change your `bounce` flags passed to Senders to unset or undefined');
+        }
+        if (!(args.sendMode === undefined || args.sendMode == ton_core_1.SendMode.PAY_GAS_SEPARATELY)) {
+            throw new Error('Deployer sender does not support `sendMode` other than `PAY_GAS_SEPARATELY`');
+        }
+        await __classPrivateFieldGet(this, _SendProviderSender_provider, "f").sendTransaction(args.to, args.value, args.body ?? undefined, args.init ?? undefined);
+    }
+}
+_SendProviderSender_provider = new WeakMap();
+class WrappedContractProvider {
+    constructor(address, provider, init) {
+        _WrappedContractProvider_address.set(this, void 0);
+        _WrappedContractProvider_provider.set(this, void 0);
+        _WrappedContractProvider_init.set(this, void 0);
+        __classPrivateFieldSet(this, _WrappedContractProvider_address, address, "f");
+        __classPrivateFieldSet(this, _WrappedContractProvider_provider, provider, "f");
+        __classPrivateFieldSet(this, _WrappedContractProvider_init, init, "f");
+    }
+    async getState() {
+        return await __classPrivateFieldGet(this, _WrappedContractProvider_provider, "f").getState();
+    }
+    async get(name, args) {
+        return await __classPrivateFieldGet(this, _WrappedContractProvider_provider, "f").get(name, args);
+    }
+    async external(message) {
+        return await __classPrivateFieldGet(this, _WrappedContractProvider_provider, "f").external(message);
+    }
+    async internal(via, args) {
+        const init = __classPrivateFieldGet(this, _WrappedContractProvider_init, "f") && (await this.getState()).state.type !== 'active' ? __classPrivateFieldGet(this, _WrappedContractProvider_init, "f") : undefined;
+        return await via.send({
+            to: __classPrivateFieldGet(this, _WrappedContractProvider_address, "f"),
+            value: typeof args.value === 'string' ? (0, ton_core_1.toNano)(args.value) : args.value,
+            sendMode: args.sendMode,
+            bounce: args.bounce,
+            init,
+            body: typeof args.body === 'string' ? (0, ton_core_1.comment)(args.body) : args.body,
+        });
+    }
+}
+_WrappedContractProvider_address = new WeakMap(), _WrappedContractProvider_provider = new WeakMap(), _WrappedContractProvider_init = new WeakMap();
+class NetworkProviderImpl {
+    constructor(tc, sender, network, explorer, ui) {
+        _NetworkProviderImpl_tc.set(this, void 0);
+        _NetworkProviderImpl_sender.set(this, void 0);
+        _NetworkProviderImpl_network.set(this, void 0);
+        _NetworkProviderImpl_explorer.set(this, void 0);
+        _NetworkProviderImpl_ui.set(this, void 0);
+        __classPrivateFieldSet(this, _NetworkProviderImpl_tc, tc, "f");
+        __classPrivateFieldSet(this, _NetworkProviderImpl_sender, sender, "f");
+        __classPrivateFieldSet(this, _NetworkProviderImpl_network, network, "f");
+        __classPrivateFieldSet(this, _NetworkProviderImpl_explorer, explorer, "f");
+        __classPrivateFieldSet(this, _NetworkProviderImpl_ui, ui, "f");
+    }
+    network() {
+        return __classPrivateFieldGet(this, _NetworkProviderImpl_network, "f");
+    }
+    explorer() {
+        return __classPrivateFieldGet(this, _NetworkProviderImpl_explorer, "f");
+    }
+    sender() {
+        return __classPrivateFieldGet(this, _NetworkProviderImpl_sender, "f");
+    }
+    api() {
+        return __classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f");
+    }
+    provider(address, init) {
+        return new WrappedContractProvider(address, __classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f").provider(address, init ? { code: init.code ?? new ton_core_1.Cell(), data: init.data ?? new ton_core_1.Cell() } : undefined), init);
+    }
+    async isContractDeployed(address) {
+        return __classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f").isContractDeployed((await __classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f").getLastBlock()).last.seqno, address);
+    }
+    async waitForDeploy(address, attempts = 10, sleepDuration = 2000) {
+        if (attempts <= 0) {
+            throw new Error('Attempt number must be positive');
+        }
+        for (let i = 1; i <= attempts; i++) {
+            __classPrivateFieldGet(this, _NetworkProviderImpl_ui, "f").setActionPrompt(`Awaiting contract deployment... [Attempt ${i}/${attempts}]`);
+            const isDeployed = await this.isContractDeployed(address);
+            if (isDeployed) {
+                __classPrivateFieldGet(this, _NetworkProviderImpl_ui, "f").clearActionPrompt();
+                __classPrivateFieldGet(this, _NetworkProviderImpl_ui, "f").write(`Contract deployed at address ${address.toString()}`);
+                __classPrivateFieldGet(this, _NetworkProviderImpl_ui, "f").write(`You can view it at ${(0, utils_1.getExplorerLink)(address.toString(), __classPrivateFieldGet(this, _NetworkProviderImpl_network, "f"), __classPrivateFieldGet(this, _NetworkProviderImpl_explorer, "f"))}`);
+                return;
+            }
+            await (0, utils_1.sleep)(sleepDuration);
+        }
+        __classPrivateFieldGet(this, _NetworkProviderImpl_ui, "f").clearActionPrompt();
+        throw new Error("Contract was not deployed. Check your wallet's transactions");
+    }
+    /**
+     * @deprecated
+     *
+     * Use your Contract's `sendDeploy` method (or similar) together with `waitForDeploy` instead.
+     */
+    async deploy(contract, value, body, waitAttempts = 10) {
+        const isDeployed = await this.isContractDeployed(contract.address);
+        if (isDeployed) {
+            throw new Error('Contract is already deployed!');
+        }
+        if (!contract.init) {
+            throw new Error('Contract has no init!');
+        }
+        await __classPrivateFieldGet(this, _NetworkProviderImpl_sender, "f").send({
+            to: contract.address,
+            value,
+            body,
+            init: contract.init,
+        });
+        if (waitAttempts <= 0)
+            return;
+        await this.waitForDeploy(contract.address, waitAttempts);
+    }
+    open(contract) {
+        return (0, ton_core_1.openContract)(contract, (params) => this.provider(params.address, params.init ?? undefined));
+    }
+    ui() {
+        return __classPrivateFieldGet(this, _NetworkProviderImpl_ui, "f");
+    }
+}
+_NetworkProviderImpl_tc = new WeakMap(), _NetworkProviderImpl_sender = new WeakMap(), _NetworkProviderImpl_network = new WeakMap(), _NetworkProviderImpl_explorer = new WeakMap(), _NetworkProviderImpl_ui = new WeakMap();
+async function createMnemonicProvider(client, ui) {
+    const mnemonic = process.env.WALLET_MNEMONIC ?? '';
+    const walletVersion = process.env.WALLET_VERSION ?? '';
+    if (mnemonic.length === 0 || walletVersion.length === 0) {
+        throw new Error('Mnemonic deployer was chosen, but env variables WALLET_MNEMONIC and WALLET_VERSION are not set');
+    }
+    const keyPair = await (0, ton_crypto_1.mnemonicToPrivateKey)(mnemonic.split(' '));
+    return new MnemonicProvider_1.MnemonicProvider({
+        version: walletVersion.toLowerCase(),
+        client,
+        secretKey: keyPair.secretKey,
+        ui,
+    });
+}
+class NetworkProviderBuilder {
+    constructor(args, ui) {
+        this.args = args;
+        this.ui = ui;
+    }
+    async chooseNetwork() {
+        let network = (0, utils_1.oneOrZeroOf)({
+            mainnet: this.args['--mainnet'],
+            testnet: this.args['--testnet'],
+        });
+        if (!network) {
+            network = await this.ui.choose('Which network do you want to use?', ['mainnet', 'testnet'], (c) => c);
+        }
+        return network;
+    }
+    chooseExplorer() {
+        return ((0, utils_1.oneOrZeroOf)({
+            tonscan: this.args['--tonscan'],
+            tonapi: this.args['--tonapi'],
+            toncx: this.args['--toncx'],
+            dton: this.args['--dton'],
+        }) ?? 'tonscan');
+    }
+    async chooseSendProvider(network, client) {
+        let deployUsing = (0, utils_1.oneOrZeroOf)({
+            tonconnect: this.args['--tonconnect'],
+            deeplink: this.args['--deeplink'],
+            tonhub: this.args['--tonhub'],
+            mnemonic: this.args['--mnemonic'],
+        });
+        if (!deployUsing) {
+            deployUsing = (await this.ui.choose('Which wallet are you using?', [
+                {
+                    name: 'TON Connect compatible mobile wallet (example: Tonkeeper)',
+                    value: 'tonconnect',
+                },
+                {
+                    name: 'Create a ton:// deep link',
+                    value: 'deeplink',
+                },
+                {
+                    name: 'Tonhub wallet',
+                    value: 'tonhub',
+                },
+                {
+                    name: 'Mnemonic',
+                    value: 'mnemonic',
+                },
+            ], (c) => c.name)).value;
+        }
+        const storagePath = path_1.default.join(paths_1.TEMP_DIR, network, deployUsing + '.json');
+        let provider;
+        switch (deployUsing) {
+            case 'deeplink':
+                provider = new DeeplinkProvider_1.DeeplinkProvider(this.ui);
+                break;
+            case 'tonconnect':
+                provider = new TonConnectProvider_1.TonConnectProvider(new FSStorage_1.FSStorage(storagePath), this.ui);
+                break;
+            case 'tonhub':
+                provider = new TonHubProvider_1.TonHubProvider(network, new FSStorage_1.FSStorage(storagePath), this.ui);
+                break;
+            case 'mnemonic':
+                provider = await createMnemonicProvider(client, this.ui);
+                break;
+            default:
+                throw new Error('Unknown deploy option');
+        }
+        return provider;
+    }
+    async build() {
+        const network = await this.chooseNetwork();
+        const explorer = this.chooseExplorer();
+        const tc = new ton_1.TonClient4({
+            endpoint: await (0, ton_access_1.getHttpV4Endpoint)({ network }),
+        });
+        const sendProvider = await this.chooseSendProvider(network, tc);
+        try {
+            await sendProvider.connect();
+        }
+        catch (e) {
+            console.error('Unable to connect to wallet.');
+            process.exit(1);
+        }
+        finally {
+            this.ui.setActionPrompt('');
+        }
+        const sender = new SendProviderSender(sendProvider);
+        return new NetworkProviderImpl(tc, sender, network, explorer, this.ui);
+    }
+}
+async function createNetworkProvider(ui) {
+    const args = (0, arg_1.default)(argSpec);
+    return await new NetworkProviderBuilder(args, ui).build();
+}
+exports.createNetworkProvider = createNetworkProvider;

package/dist/network/send/DeeplinkProvider.d.ts

@@ -0,0 +1,10 @@
+import { Address, Cell, StateInit } from 'ton-core';
+import { SendProvider } from './SendProvider';
+import { UIProvider } from '../../ui/UIProvider';
+export declare class DeeplinkProvider implements SendProvider {
+    #private;
+    constructor(ui: UIProvider);
+    connect(): Promise<void>;
+    sendTransaction(address: Address, amount: bigint, payload?: Cell, stateInit?: StateInit): Promise<void>;
+    address(): Address | undefined;
+}

package/dist/network/send/DeeplinkProvider.js

@@ -0,0 +1,44 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _DeeplinkProvider_ui;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeeplinkProvider = void 0;
+const ton_core_1 = require("ton-core");
+const utils_1 = require("../../utils");
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+class DeeplinkProvider {
+    constructor(ui) {
+        _DeeplinkProvider_ui.set(this, void 0);
+        __classPrivateFieldSet(this, _DeeplinkProvider_ui, ui, "f");
+    }
+    async connect() {
+        return;
+    }
+    async sendTransaction(address, amount, payload, stateInit) {
+        const deepLink = (0, utils_1.tonDeepLink)(address, amount, payload, stateInit ? (0, ton_core_1.beginCell)().storeWritable((0, ton_core_1.storeStateInit)(stateInit)).endCell() : undefined);
+        __classPrivateFieldGet(this, _DeeplinkProvider_ui, "f").write('\n');
+        qrcode_terminal_1.default.generate(deepLink, { small: true }, (qr) => __classPrivateFieldGet(this, _DeeplinkProvider_ui, "f").write(qr));
+        __classPrivateFieldGet(this, _DeeplinkProvider_ui, "f").write('\n');
+        __classPrivateFieldGet(this, _DeeplinkProvider_ui, "f").write(deepLink);
+        __classPrivateFieldGet(this, _DeeplinkProvider_ui, "f").write('\nScan the QR code above, or open the ton:// link to send this transaction');
+        await __classPrivateFieldGet(this, _DeeplinkProvider_ui, "f").prompt('Press enter when transaction was issued');
+    }
+    address() {
+        return undefined;
+    }
+}
+exports.DeeplinkProvider = DeeplinkProvider;
+_DeeplinkProvider_ui = new WeakMap();

package/dist/network/send/MnemonicProvider.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { TonClient4 } from 'ton';
+import { Address, Cell, StateInit } from 'ton-core';
+import { SendProvider } from './SendProvider';
+import { UIProvider } from '../../ui/UIProvider';
+export type WalletVersion = 'v1r1' | 'v1r2' | 'v1r3' | 'v2r1' | 'v2r2' | 'v3r1' | 'v3r2' | 'v4';
+export declare class MnemonicProvider implements SendProvider {
+    #private;
+    constructor(params: {
+        version: WalletVersion;
+        workchain?: number;
+        secretKey: Buffer;
+        client: TonClient4;
+        ui: UIProvider;
+    });
+    connect(): Promise<void>;
+    sendTransaction(address: Address, amount: bigint, payload?: Cell | undefined, stateInit?: StateInit | undefined): Promise<void>;
+    address(): Address;
+}

package/dist/network/send/MnemonicProvider.js

@@ -0,0 +1,80 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MnemonicProvider_wallet, _MnemonicProvider_secretKey, _MnemonicProvider_client, _MnemonicProvider_ui;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MnemonicProvider = void 0;
+const ton_1 = require("ton");
+const ton_core_1 = require("ton-core");
+const ton_crypto_1 = require("ton-crypto");
+const wallets = {
+    v1r1: ton_1.WalletContractV1R1,
+    v1r2: ton_1.WalletContractV1R2,
+    v1r3: ton_1.WalletContractV1R3,
+    v2r1: ton_1.WalletContractV2R1,
+    v2r2: ton_1.WalletContractV2R2,
+    v3r1: ton_1.WalletContractV3R1,
+    v3r2: ton_1.WalletContractV3R2,
+    v4: ton_1.WalletContractV4,
+};
+class MnemonicProvider {
+    constructor(params) {
+        _MnemonicProvider_wallet.set(this, void 0);
+        _MnemonicProvider_secretKey.set(this, void 0);
+        _MnemonicProvider_client.set(this, void 0);
+        _MnemonicProvider_ui.set(this, void 0);
+        if (!(params.version in wallets)) {
+            throw new Error(`Unknown wallet version ${params.version}`);
+        }
+        const kp = (0, ton_crypto_1.keyPairFromSecretKey)(params.secretKey);
+        __classPrivateFieldSet(this, _MnemonicProvider_client, params.client, "f");
+        __classPrivateFieldSet(this, _MnemonicProvider_wallet, (0, ton_core_1.openContract)(wallets[params.version].create({
+            workchain: params.workchain ?? 0,
+            publicKey: kp.publicKey,
+        }), (params) => __classPrivateFieldGet(this, _MnemonicProvider_client, "f").provider(params.address, params.init)), "f");
+        __classPrivateFieldSet(this, _MnemonicProvider_secretKey, kp.secretKey, "f");
+        __classPrivateFieldSet(this, _MnemonicProvider_ui, params.ui, "f");
+    }
+    async connect() {
+        __classPrivateFieldGet(this, _MnemonicProvider_ui, "f").write(`Connected to wallet at address: ${this.address()}\n`);
+    }
+    async sendTransaction(address, amount, payload, stateInit) {
+        await __classPrivateFieldGet(this, _MnemonicProvider_wallet, "f").sendTransfer({
+            seqno: await __classPrivateFieldGet(this, _MnemonicProvider_wallet, "f").getSeqno(),
+            secretKey: __classPrivateFieldGet(this, _MnemonicProvider_secretKey, "f"),
+            messages: [
+                {
+                    init: stateInit,
+                    body: payload ?? new ton_core_1.Cell(),
+                    info: {
+                        type: 'internal',
+                        ihrDisabled: true,
+                        ihrFee: 0n,
+                        bounce: true,
+                        bounced: false,
+                        dest: address,
+                        value: { coins: amount },
+                        forwardFee: 0n,
+                        createdAt: 0,
+                        createdLt: 0n,
+                    },
+                },
+            ],
+        });
+        __classPrivateFieldGet(this, _MnemonicProvider_ui, "f").write('Sent transaction');
+    }
+    address() {
+        return __classPrivateFieldGet(this, _MnemonicProvider_wallet, "f").address;
+    }
+}
+exports.MnemonicProvider = MnemonicProvider;
+_MnemonicProvider_wallet = new WeakMap(), _MnemonicProvider_secretKey = new WeakMap(), _MnemonicProvider_client = new WeakMap(), _MnemonicProvider_ui = new WeakMap();

package/dist/network/send/SendProvider.d.ts

@@ -0,0 +1,6 @@
+import { Address, Cell, StateInit } from 'ton-core';
+export interface SendProvider {
+    connect(): Promise<void>;
+    sendTransaction(address: Address, amount: bigint, payload?: Cell, stateInit?: StateInit): Promise<any>;
+    address(): Address | undefined;
+}