@pizzaton/ton 0.0.0-stage → 0.1.1

package/dist/simulation/index.mjs

@@ -0,0 +1,310 @@
+import { invariant } from "../core/errors.mjs";
+import { createTimedFetch, normalizeHttpsBaseUrl, validateRequestTimeout } from "../core/http.mjs";
+import { Cell, beginCell, storeMessage } from "@ton/core";
+import { TonClient4 } from "@ton/ton";
+import { TonApiClient } from "@ton-api/client";
+import { Blockchain, RemoteBlockchainStorage, wrapTonClient4ForRemote } from "@ton/sandbox";
+//#region src/simulation/index.ts
+function createTonSimulationWithFallback(primary, fallback) {
+	return {
+		source: primary.source,
+		async simulate(input) {
+			try {
+				const result = await primary.simulate(input);
+				if (!result.error) return result;
+			} catch {}
+			return fallback.simulate(input);
+		}
+	};
+}
+function messageToCell(message) {
+	return beginCell().store(storeMessage(message)).endCell();
+}
+function createTonSandboxSimulation(blockchain, options = {}) {
+	blockchain.recordStorage = options.recordStorage ?? true;
+	return {
+		source: "sandbox",
+		blockchain,
+		async simulate(input) {
+			return withBlockchainLock(blockchain, async () => {
+				const snapshot = blockchain.snapshot();
+				try {
+					const result = await blockchain.sendMessage(input.message, { ignoreChksig: input.ignoreSignatureCheck ?? false });
+					return buildSandboxResult(result.transactions, result.events);
+				} catch (cause) {
+					return buildFailureResult("sandbox", cause, false);
+				} finally {
+					if (!input.persist) await blockchain.loadFrom(snapshot);
+				}
+			});
+		}
+	};
+}
+/**
+* Creates a native sandbox backed by a read-only snapshot of the live chain.
+* Contract code and account state are fetched lazily from TonClient4.
+*/
+async function createTonClient4SandboxSimulation(options) {
+	const endpoint = normalizeHttpsBaseUrl(options.endpoint, "TON Client4 endpoint");
+	const timeoutMs = validateRequestTimeout(options.timeoutMs, "TON Client4");
+	if (options.blockSeqno !== void 0) invariant(Number.isSafeInteger(options.blockSeqno) && options.blockSeqno >= 0, "INVALID_NETWORK", "TON Client4 block sequence number must be a non-negative safe integer");
+	if (options.now !== void 0) invariant(Number.isSafeInteger(options.now) && options.now >= 0, "INVALID_NETWORK", "TON simulation time must be a non-negative safe integer");
+	const client = new TonClient4({
+		endpoint,
+		timeout: timeoutMs
+	});
+	const latest = await client.getLastBlock();
+	const blockSeqno = options.blockSeqno ?? latest.last.seqno;
+	const config = options.config ?? Cell.fromBase64((await client.getConfig(blockSeqno)).config.cell);
+	const blockchain = await Blockchain.create({
+		config,
+		storage: new RemoteBlockchainStorage(wrapTonClient4ForRemote(client), blockSeqno),
+		autoDeployLibs: true
+	});
+	blockchain.now = options.now ?? latest.now;
+	return createTonSandboxSimulation(blockchain, options);
+}
+/** Optional fallback for clients that cannot hydrate a native sandbox snapshot. */
+function createTonApiSimulationFallback(options = {}) {
+	const baseUrl = options.baseUrl ?? "https://tonapi.io";
+	const normalizedBaseUrl = normalizeHttpsBaseUrl(baseUrl, "TonAPI");
+	const timeoutMs = validateRequestTimeout(options.timeoutMs, "TonAPI");
+	const client = new TonApiClient({
+		baseUrl: normalizedBaseUrl,
+		fetch: createTimedFetch(options.fetch ?? globalThis.fetch, timeoutMs, "TonAPI"),
+		...options.apiKey === void 0 ? {} : { apiKey: options.apiKey }
+	});
+	return {
+		source: "tonapi",
+		async simulate(input) {
+			const boc = input.message instanceof Cell ? input.message : messageToCell(input.message);
+			try {
+				return buildTonApiResult(await client.emulation.emulateMessageToTrace({ boc }, { ignore_signature_check: input.ignoreSignatureCheck ?? false }));
+			} catch (cause) {
+				return buildFailureResult("tonapi", cause, true);
+			}
+		}
+	};
+}
+function buildSandboxResult(transactions, events) {
+	const normalized = transactions.map(normalizeSandboxTransaction);
+	const rootTransaction = normalized.find((transaction) => !transaction.parentHash);
+	const cost = normalized.reduce((total, transaction) => ({
+		totalFees: total.totalFees + transaction.totalFees,
+		storageFees: total.storageFees + transaction.storageFees,
+		gasFees: total.gasFees + transaction.gasFees,
+		forwardFees: total.forwardFees + transaction.forwardFees,
+		actionFees: total.actionFees + transaction.actionFees,
+		gasUsed: total.gasUsed + transaction.gasUsed,
+		vmSteps: total.vmSteps + transaction.vmSteps
+	}), zeroCost());
+	return {
+		source: "sandbox",
+		success: normalized.length > 0 && normalized.every((transaction) => transaction.success),
+		transactions: normalized,
+		cost,
+		events,
+		...rootTransaction ? { rootTransactionHash: rootTransaction.hash } : {},
+		...normalized.length === 0 ? { error: { message: "Sandbox produced no transactions" } } : {},
+		speculative: false
+	};
+}
+function normalizeSandboxTransaction(transaction) {
+	const description = transaction.description;
+	const compute = "computePhase" in description ? description.computePhase : void 0;
+	const storage = "storagePhase" in description ? description.storagePhase : void 0;
+	const action = "actionPhase" in description ? description.actionPhase : void 0;
+	const computePhase = compute ?? void 0;
+	const actionPhase = action ?? void 0;
+	const gasUsed = computePhase?.type === "vm" ? computePhase.gasUsed : 0n;
+	const gasFees = computePhase?.type === "vm" ? computePhase.gasFees : 0n;
+	const vmSteps = computePhase?.type === "vm" ? computePhase.vmSteps : 0;
+	const actionFees = actionPhase?.totalActionFees ?? 0n;
+	const forwardFees = actionPhase?.totalFwdFees ?? 0n;
+	const aborted = "aborted" in description ? description.aborted : false;
+	const computeSuccess = computePhase?.type === "vm" ? computePhase.success : true;
+	const actionSuccess = actionPhase?.success;
+	return {
+		hash: transaction.hash().toString("hex"),
+		logicalTime: transaction.lt,
+		accountId: transaction.address.toString(16).padStart(64, "0"),
+		timestamp: transaction.now,
+		success: !aborted && computeSuccess && actionSuccess !== false,
+		oldStatus: transaction.oldStatus,
+		endStatus: transaction.endStatus,
+		totalFees: transaction.totalFees.coins,
+		storageFees: storage?.storageFeesCollected ?? 0n,
+		gasFees,
+		forwardFees,
+		actionFees,
+		gasUsed,
+		vmSteps,
+		...computePhase?.type === "vm" ? { exitCode: computePhase.exitCode } : {},
+		...actionSuccess !== void 0 ? { actionSuccess } : {},
+		...transaction.inMessage ? { input: summarizeMessage(transaction.inMessage) } : {},
+		outputs: transaction.outMessages.values().map(summarizeMessage),
+		...transaction.parent ? { parentHash: transaction.parent.hash().toString("hex") } : {},
+		childHashes: transaction.children.map((child) => child.hash().toString("hex")),
+		blockchainLogs: transaction.blockchainLogs,
+		vmLogs: transaction.vmLogs,
+		debugLogs: transaction.debugLogs,
+		...transaction.oldStorage ? { oldStorage: transaction.oldStorage } : {},
+		...transaction.newStorage ? { newStorage: transaction.newStorage } : {}
+	};
+}
+function summarizeMessage(message) {
+	const info = message.info;
+	if (info.type === "internal") return {
+		type: "internal",
+		source: info.src,
+		destination: info.dest,
+		value: info.value.coins,
+		body: message.body,
+		...message.init ? { init: message.init } : {},
+		createdAt: info.createdAt,
+		createdLt: info.createdLt
+	};
+	if (info.type === "external-in") return {
+		type: "external-in",
+		destination: info.dest,
+		body: message.body,
+		...message.init ? { init: message.init } : {}
+	};
+	return {
+		type: "external-out",
+		source: info.src,
+		body: message.body,
+		createdAt: info.createdAt,
+		createdLt: info.createdLt
+	};
+}
+function buildTonApiResult(trace) {
+	const transactions = flattenTonApiTrace(trace).map(normalizeTonApiTransaction);
+	const cost = transactions.reduce((total, transaction) => ({
+		totalFees: total.totalFees + transaction.totalFees,
+		storageFees: total.storageFees + transaction.storageFees,
+		gasFees: total.gasFees + transaction.gasFees,
+		forwardFees: total.forwardFees + transaction.forwardFees,
+		actionFees: total.actionFees + transaction.actionFees,
+		gasUsed: total.gasUsed + transaction.gasUsed,
+		vmSteps: total.vmSteps + transaction.vmSteps
+	}), zeroCost());
+	return {
+		source: "tonapi",
+		success: transactions.length > 0 && transactions.every((transaction) => transaction.success),
+		transactions,
+		cost,
+		...transactions.length === 0 ? { error: { message: "TonAPI returned no transactions" } } : {},
+		...transactions[0] ? { rootTransactionHash: transactions[0].hash } : {},
+		speculative: true
+	};
+}
+function flattenTonApiTrace(root) {
+	const flattened = [];
+	const pending = [{ trace: root }];
+	const seen = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const item = pending.pop();
+		if (!item) continue;
+		invariant(!seen.has(item.trace), "PROVIDER_ERROR", "TonAPI returned a recursive trace");
+		seen.add(item.trace);
+		invariant(seen.size <= 1e5, "PROVIDER_ERROR", "TonAPI trace exceeds the transaction limit");
+		flattened.push(item);
+		const children = item.trace.children ?? [];
+		for (let index = children.length - 1; index >= 0; index -= 1) {
+			const child = children[index];
+			if (child) pending.push({
+				trace: child,
+				parentHash: item.trace.transaction.hash
+			});
+		}
+	}
+	return flattened;
+}
+function normalizeTonApiTransaction(item) {
+	const transaction = item.trace.transaction;
+	const compute = transaction.computePhase;
+	const action = transaction.actionPhase;
+	const storage = transaction.storagePhase;
+	return {
+		hash: transaction.hash,
+		logicalTime: transaction.lt,
+		accountId: transaction.account.address.hash.toString("hex").padStart(64, "0"),
+		timestamp: transaction.utime,
+		success: transaction.success,
+		oldStatus: transaction.origStatus,
+		endStatus: transaction.endStatus,
+		totalFees: transaction.totalFees,
+		storageFees: storage?.feesCollected ?? 0n,
+		gasFees: compute?.gasFees ?? 0n,
+		forwardFees: action?.fwdFees ?? 0n,
+		actionFees: action ? action.totalFees - action.fwdFees : 0n,
+		gasUsed: compute?.gasUsed ?? 0n,
+		vmSteps: compute?.vmSteps ?? 0,
+		...compute?.exitCode !== void 0 ? { exitCode: compute.exitCode } : {},
+		...action ? { actionSuccess: action.success } : {},
+		...transaction.inMsg ? { input: summarizeTonApiMessage(transaction.inMsg) } : {},
+		outputs: transaction.outMsgs.map(summarizeTonApiMessage),
+		...item.parentHash ? { parentHash: item.parentHash } : {},
+		childHashes: (item.trace.children ?? []).map((child) => child.transaction.hash),
+		blockchainLogs: "",
+		vmLogs: "",
+		debugLogs: ""
+	};
+}
+function summarizeTonApiMessage(message) {
+	if (!message) return { type: "external-in" };
+	return {
+		type: message.msgType === "int_msg" ? "internal" : message.msgType === "ext_out_msg" ? "external-out" : "external-in",
+		...message.source ? { source: message.source.address } : {},
+		...message.destination ? { destination: message.destination.address } : {},
+		...message.value === void 0 ? {} : { value: message.value },
+		...message.rawBody ? { body: message.rawBody } : {},
+		...message.createdAt === void 0 ? {} : { createdAt: message.createdAt },
+		...message.createdLt === void 0 ? {} : { createdLt: message.createdLt }
+	};
+}
+function zeroCost() {
+	return {
+		totalFees: 0n,
+		storageFees: 0n,
+		gasFees: 0n,
+		forwardFees: 0n,
+		actionFees: 0n,
+		gasUsed: 0n,
+		vmSteps: 0
+	};
+}
+function buildFailureResult(source, cause, speculative) {
+	const error = cause instanceof Error ? cause : new Error(String(cause));
+	const exitCode = typeof cause === "object" && cause !== null && "exitCode" in cause && typeof cause.exitCode === "number" ? cause.exitCode : void 0;
+	return {
+		source,
+		success: false,
+		transactions: [],
+		cost: zeroCost(),
+		error: {
+			message: error.message,
+			...exitCode !== void 0 ? { exitCode } : {}
+		},
+		speculative
+	};
+}
+const blockchainLocks = /* @__PURE__ */ new WeakMap();
+async function withBlockchainLock(blockchain, operation) {
+	const previous = blockchainLocks.get(blockchain) ?? Promise.resolve();
+	let release = () => {};
+	const turn = new Promise((resolve) => {
+		release = resolve;
+	});
+	blockchainLocks.set(blockchain, turn);
+	await previous;
+	try {
+		return await operation();
+	} finally {
+		release();
+		if (blockchainLocks.get(blockchain) === turn) blockchainLocks.delete(blockchain);
+	}
+}
+//#endregion
+export { createTonApiSimulationFallback, createTonClient4SandboxSimulation, createTonSandboxSimulation, createTonSimulationWithFallback, messageToCell };

package/dist/transactions/index.d.mts

@@ -0,0 +1,33 @@
+import { TonNetwork } from "../core/network.mjs";
+import { TonAddress } from "../core/address.mjs";
+import { Address, Cell } from "@ton/core";
+import { SendTransactionRequestWithMessages } from "@tonconnect/sdk";
+//#region src/transactions/index.d.ts
+export interface TonTransactionMessage {
+  readonly to: string | Address | TonAddress;
+  readonly value: bigint;
+  readonly body?: Cell;
+  readonly stateInit?: Cell;
+  readonly bounce?: boolean;
+}
+export interface TransactionIntent {
+  readonly kind: "ton-transaction";
+  readonly id: string;
+  readonly validUntil: number;
+  readonly messages: readonly TonTransactionMessage[];
+  readonly metadata?: Readonly<Record<string, string>>;
+}
+export type TonConnectMessage = SendTransactionRequestWithMessages["messages"][number];
+export type TonConnectTransaction = Pick<SendTransactionRequestWithMessages, "validUntil" | "messages">;
+export declare function createTransactionIntent(input: {
+  id: string;
+  validUntil: number;
+  messages: readonly TonTransactionMessage[];
+  metadata?: Readonly<Record<string, string>>;
+}): TransactionIntent;
+export declare function validateTransactionIntent(input: Pick<TransactionIntent, "id" | "validUntil" | "messages">, now?: number): void;
+export declare function toTonConnectTransaction(intent: TransactionIntent, options: {
+  network: TonNetwork;
+  now?: number;
+}): TonConnectTransaction;
+//#endregion

package/dist/transactions/index.mjs

@@ -0,0 +1,51 @@
+import { invariant } from "../core/errors.mjs";
+import { parseTonAddress, toFriendlyAddress } from "../core/address.mjs";
+import { MAX_TON_COINS } from "../core/amount.mjs";
+import { bytesToBase64 } from "../core/bytes.mjs";
+import { Cell } from "@ton/core";
+//#region src/transactions/index.ts
+function createTransactionIntent(input) {
+	validateTransactionIntent(input);
+	return Object.freeze({
+		kind: "ton-transaction",
+		id: input.id,
+		validUntil: input.validUntil,
+		messages: Object.freeze(input.messages.map((message) => Object.freeze({ ...message }))),
+		...input.metadata ? { metadata: Object.freeze({ ...input.metadata }) } : {}
+	});
+}
+function validateTransactionIntent(input, now = Math.floor(Date.now() / 1e3)) {
+	invariant(typeof input.id === "string" && input.id.trim().length > 0, "INVALID_TRANSACTION", "Transaction intent id is required");
+	invariant(Number.isSafeInteger(now), "INVALID_TRANSACTION", "Current time must be a safe integer");
+	invariant(Number.isSafeInteger(input.validUntil), "INVALID_TRANSACTION", "validUntil must be a safe integer");
+	invariant(input.validUntil > now, "INVALID_TRANSACTION", "Transaction intent has expired");
+	invariant(input.validUntil <= now + 3600, "INVALID_TRANSACTION", "Transaction intent expires too far in the future");
+	invariant(Array.isArray(input.messages) && input.messages.length > 0 && input.messages.length <= 4, "INVALID_TRANSACTION", "A transaction must contain between one and four messages");
+	for (const message of input.messages) {
+		invariant(typeof message === "object" && message !== null, "INVALID_TRANSACTION", "Transaction message must be an object");
+		invariant(typeof message.value === "bigint" && message.value >= 0n, "INVALID_TRANSACTION", "Message value must be a non-negative bigint");
+		invariant(message.value <= MAX_TON_COINS, "INVALID_TRANSACTION", "Message value is out of range");
+		parseTonAddress(message.to);
+		invariant(message.body === void 0 || message.body instanceof Cell, "INVALID_TRANSACTION", "Message body must be a TON Cell");
+		invariant(message.stateInit === void 0 || message.stateInit instanceof Cell, "INVALID_TRANSACTION", "Message state init must be a TON Cell");
+		invariant(message.bounce === void 0 || typeof message.bounce === "boolean", "INVALID_TRANSACTION", "Message bounce flag must be a boolean");
+	}
+}
+function toTonConnectTransaction(intent, options) {
+	invariant(options.network === "mainnet" || options.network === "testnet", "INVALID_NETWORK", "Unsupported TON network");
+	validateTransactionIntent(intent, options.now);
+	return {
+		validUntil: intent.validUntil,
+		messages: intent.messages.map((message) => ({
+			address: toFriendlyAddress(message.to, {
+				network: options.network,
+				bounceable: message.bounce ?? true
+			}),
+			amount: message.value.toString(),
+			...message.body ? { payload: bytesToBase64(message.body.toBoc()) } : {},
+			...message.stateInit ? { stateInit: bytesToBase64(message.stateInit.toBoc()) } : {}
+		}))
+	};
+}
+//#endregion
+export { createTransactionIntent, toTonConnectTransaction, validateTransactionIntent };

package/dist/vesting/index.d.mts

@@ -0,0 +1,12 @@
+//#region src/vesting/index.d.ts
+export interface VestingSchedule {
+  readonly totalAmount: bigint;
+  readonly startTime: number;
+  readonly cliffDuration: number;
+  readonly duration: number;
+  readonly now?: number;
+}
+export declare function validateVestingSchedule(schedule: VestingSchedule): void;
+export declare function unlockedAmount(schedule: VestingSchedule, at?: number): bigint;
+export declare function claimableAmount(schedule: VestingSchedule, releasedAmount: bigint, at?: number): bigint;
+//#endregion

package/dist/vesting/index.mjs

@@ -0,0 +1,25 @@
+import { invariant } from "../core/errors.mjs";
+//#region src/vesting/index.ts
+function validateVestingSchedule(schedule) {
+	invariant(schedule.totalAmount >= 0n, "INVALID_SCHEDULE", "Total vesting amount cannot be negative");
+	invariant(Number.isSafeInteger(schedule.startTime), "INVALID_SCHEDULE", "Start time must be a safe integer");
+	if (schedule.now !== void 0) invariant(Number.isSafeInteger(schedule.now), "INVALID_SCHEDULE", "Current time must be a safe integer");
+	invariant(Number.isSafeInteger(schedule.cliffDuration) && schedule.cliffDuration >= 0, "INVALID_SCHEDULE", "Cliff duration is invalid");
+	invariant(Number.isSafeInteger(schedule.duration) && schedule.duration > 0, "INVALID_SCHEDULE", "Vesting duration must be positive");
+	invariant(schedule.cliffDuration <= schedule.duration, "INVALID_SCHEDULE", "Cliff cannot exceed vesting duration");
+	invariant(Number.isSafeInteger(schedule.startTime + schedule.duration), "INVALID_SCHEDULE", "Vesting schedule end time is out of range");
+}
+function unlockedAmount(schedule, at = schedule.now ?? Math.floor(Date.now() / 1e3)) {
+	validateVestingSchedule(schedule);
+	invariant(Number.isSafeInteger(at), "INVALID_SCHEDULE", "Calculation time must be a safe integer");
+	if (at < schedule.startTime + schedule.cliffDuration) return 0n;
+	const elapsed = Math.min(at - schedule.startTime, schedule.duration);
+	return schedule.totalAmount * BigInt(elapsed) / BigInt(schedule.duration);
+}
+function claimableAmount(schedule, releasedAmount, at) {
+	invariant(releasedAmount >= 0n && releasedAmount <= schedule.totalAmount, "INVALID_SCHEDULE", "Released amount is out of range");
+	const claimable = unlockedAmount(schedule, at) - releasedAmount;
+	return claimable > 0n ? claimable : 0n;
+}
+//#endregion
+export { claimableAmount, unlockedAmount, validateVestingSchedule };

package/dist/wallet/index.d.mts

@@ -0,0 +1,23 @@
+import { Address, Contract, ContractProvider, StateInit } from "@ton/core";
+import { WalletContractV1R1, WalletContractV1R2, WalletContractV1R3, WalletContractV2R1, WalletContractV2R2, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5Beta, WalletContractV5R1 } from "@ton/ton";
+//#region src/wallet/index.d.ts
+export declare const TON_WALLET_VERSIONS: readonly ["v1r1", "v1r2", "v1r3", "v2r1", "v2r2", "v3r1", "v3r2", "v4", "v5beta", "v5r1"];
+export type TonWalletVersion = (typeof TON_WALLET_VERSIONS)[number];
+export declare const DEFAULT_TON_WALLET_VERSION: TonWalletVersion;
+export interface TonWalletContract extends Contract {
+  readonly address: Address;
+  readonly init: StateInit;
+  readonly publicKey: Buffer;
+  getBalance(provider: ContractProvider): Promise<bigint>;
+  getSeqno(provider: ContractProvider): Promise<number>;
+}
+export interface TonWalletFactoryOptions {
+  readonly version?: TonWalletVersion;
+  readonly workchain?: number;
+  readonly publicKey: Buffer;
+  readonly walletId?: number;
+  readonly networkGlobalId?: -239 | -3;
+}
+export declare function createTonWalletContract(options: TonWalletFactoryOptions): TonWalletContract;
+//#endregion
+export { WalletContractV1R1, WalletContractV1R2, WalletContractV1R3, WalletContractV2R1, WalletContractV2R2, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5Beta, WalletContractV5R1 };

package/dist/wallet/index.mjs

@@ -0,0 +1,71 @@
+import { WalletContractV1R1, WalletContractV1R1 as WalletContractV1R1$1, WalletContractV1R2, WalletContractV1R2 as WalletContractV1R2$1, WalletContractV1R3, WalletContractV1R3 as WalletContractV1R3$1, WalletContractV2R1, WalletContractV2R1 as WalletContractV2R1$1, WalletContractV2R2, WalletContractV2R2 as WalletContractV2R2$1, WalletContractV3R1, WalletContractV3R1 as WalletContractV3R1$1, WalletContractV3R2, WalletContractV3R2 as WalletContractV3R2$1, WalletContractV4, WalletContractV4 as WalletContractV4$1, WalletContractV5Beta, WalletContractV5Beta as WalletContractV5Beta$1, WalletContractV5R1, WalletContractV5R1 as WalletContractV5R1$1 } from "@ton/ton";
+//#region src/wallet/index.ts
+const TON_WALLET_VERSIONS = [
+	"v1r1",
+	"v1r2",
+	"v1r3",
+	"v2r1",
+	"v2r2",
+	"v3r1",
+	"v3r2",
+	"v4",
+	"v5beta",
+	"v5r1"
+];
+const DEFAULT_TON_WALLET_VERSION = "v5r1";
+function createTonWalletContract(options) {
+	const workchain = options.workchain ?? 0;
+	const publicKey = Buffer.from(options.publicKey);
+	if (publicKey.length !== 32) throw new Error("TON wallet public keys must be exactly 32 bytes");
+	switch (options.version ?? "v5r1") {
+		case "v1r1": return WalletContractV1R1$1.create({
+			workchain,
+			publicKey
+		});
+		case "v1r2": return WalletContractV1R2$1.create({
+			workchain,
+			publicKey
+		});
+		case "v1r3": return WalletContractV1R3$1.create({
+			workchain,
+			publicKey
+		});
+		case "v2r1": return WalletContractV2R1$1.create({
+			workchain,
+			publicKey
+		});
+		case "v2r2": return WalletContractV2R2$1.create({
+			workchain,
+			publicKey
+		});
+		case "v3r1": return WalletContractV3R1$1.create({
+			workchain,
+			publicKey,
+			walletId: options.walletId
+		});
+		case "v3r2": return WalletContractV3R2$1.create({
+			workchain,
+			publicKey,
+			walletId: options.walletId
+		});
+		case "v4": return WalletContractV4$1.create({
+			workchain,
+			publicKey,
+			walletId: options.walletId
+		});
+		case "v5beta": return WalletContractV5Beta$1.create({ publicKey });
+		case "v5r1": return WalletContractV5R1$1.create({
+			publicKey,
+			walletId: {
+				networkGlobalId: options.networkGlobalId ?? -239,
+				context: {
+					walletVersion: "v5r1",
+					workchain,
+					subwalletNumber: options.walletId ?? 0
+				}
+			}
+		});
+	}
+}
+//#endregion
+export { DEFAULT_TON_WALLET_VERSION, TON_WALLET_VERSIONS, WalletContractV1R1, WalletContractV1R2, WalletContractV1R3, WalletContractV2R1, WalletContractV2R2, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5Beta, WalletContractV5R1, createTonWalletContract };