@pizzaton/ton 0.1.0 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # @pizzaton/ton
 
-Typed TON protocol infrastructure for PizzaTon applications. The package provides reusable primitives for TON addresses, amounts, messages, providers, standard Jetton and NFT contracts, wallet versions, TON Connect, emulation, simulation, Merkle airdrops, and vesting calculations.
+Typed TON protocol infrastructure for PizzaTon applications. The package provides reusable primitives for TON addresses, amounts, messages, providers, standard Jetton and NFT contracts, wallet versions, TON Connect proof verification, emulation, simulation, Merkle airdrops, and vesting calculations.
 
 It is intentionally protocol-focused. Application workflows, database persistence, authentication, launchpad rules, product-specific contracts, and UI components belong in the application or domain packages that consume this package.
 
@@ -33,8 +33,8 @@ npm install @ton/sandbox @ton-api/client react @types/react
 ```
 
 Install `@ton/sandbox` for `/emulator` and `/simulation`, `@ton-api/client` for
-`/indexer`, `/jetton/details`, and TonAPI simulation fallback, and `react` plus
-`@types/react` for `/react`.
+`/indexer`, `/jetton/details`, and TonAPI simulation fallback, `@tonconnect/sdk`
+for `/connect`, and `react` plus `@types/react` for `/react`.
 
 Use the narrowest subpath that contains the feature you need. This keeps browser bundles free of server-only and emulator dependencies.
 
@@ -45,6 +45,7 @@ Use the narrowest subpath that contains the feature you need. This keeps browser
 | `@pizzaton/ton/provider` | Provider interfaces for application-defined adapters |
 | `@pizzaton/ton/server` | Server-side `@ton/ton` HTTP provider |
 | `@pizzaton/ton/connect` | TON Connect adapter and network validation |
+| `@pizzaton/ton/proof` | Server-side TON Connect proof, sign-data, and wallet state-init verification |
 | `@pizzaton/ton/react` | React hooks over the adapter |
 | `@pizzaton/ton/jetton` | Jetton payloads, data readers, wallet resolution, and implementation profiles |
 | `@pizzaton/ton/jetton/details` | Server-side token detail lookup through TonAPI and TonCenter |
@@ -67,6 +68,8 @@ package; there is no separate contracts workspace package.
 
 `@pizzaton/ton/server`, `@pizzaton/ton/jetton/details`, `@pizzaton/ton/emulator`, `@pizzaton/ton/simulation`, `@pizzaton/ton/indexer`, and `@pizzaton/ton/wallet` are feature subpaths outside the root entry point. Do not import them from browser components unless the bundler is explicitly configured for those dependencies. React components should use `@pizzaton/ton/connect`, `@pizzaton/ton/transactions`, and `@pizzaton/ton/react`.
 
+`@pizzaton/ton/proof` is server-only. It verifies TON Connect proof and text sign-data signatures, timestamp and domain bindings, the wallet address derived from `state_init`, and public keys for standard WalletContract V1–V5R1 wallets. WalletTg uses an external public key, so pass `resolveDelegatedWalletPublicKey` to resolve that key through the application's trusted RPC adapter. Challenge storage, nonce consumption, session binding, and trusted-origin policy remain application responsibilities.
+
 ## Official TON SDK first
 
 The package uses the official TON libraries as its source of truth. `Address`, `Cell`, `Builder`, `ContractProvider`, `Sender`, `StateInit`, message codecs, dictionaries, and tuple types come from `@ton/core`. RPC clients, Jetton master/wallet readers, wallet-version contracts, and fee helpers come from `@ton/ton`. Cryptographic hashing comes from `@ton/crypto`; local execution comes from `@ton/sandbox`; wallet transport comes from `@tonconnect/sdk`.
@@ -294,6 +297,27 @@ const broadcastedBoc = await ton.sendTransaction(intent);
 
 The adapter checks that a wallet is connected and that its chain id matches the selected network. React applications can use `useTonWallet(adapter)` and `useTonTransaction(adapter)` from `@pizzaton/ton/react`; the transaction hook exposes `send`, `status`, `boc`, `error`, and `reset`.
 
+### TON Connect proof verification
+
+Run proof verification on the server after validating the challenge and its origin. The verifier checks the wallet `state_init` and signature; the application remains responsible for one-time challenge and session rules.
+
+```ts
+import { verifyTonConnectProof } from "@pizzaton/ton/proof";
+
+const verified = await verifyTonConnectProof(
+	{ address, proof, expectedDomain: "example.com", expectedPublicKey: publicKeyHex },
+	{
+		network: "mainnet",
+		resolveDelegatedWalletPublicKey: (walletAddress, network) =>
+			readWalletTgPublicKey(walletAddress, network),
+	},
+);
+```
+
+The delegated-wallet resolver is called only for the built-in WalletTg trampoline code hash or a code hash explicitly added by the application. Resolver errors propagate so applications can report RPC outages separately from invalid proofs.
+
+For text messages returned by TON Connect `signData`, use `verifyTonConnectSignData` from the same subpath. It verifies the canonical text digest and wallet signature; bind its `expectedDomain` and payload to an application-owned, single-use challenge before calling it.
+
 ## Native transaction simulation
 
 The preferred simulator is native `@ton/sandbox` execution. It can run against a local blockchain or a pinned live-state snapshot hydrated through `TonClient4`; it does not call TonAPI for the primary path.

package/dist/core/address.d.mts

@@ -4,7 +4,13 @@ import { Address } from "@ton/core";
 export type TonAddress = string & {
   readonly __brand: "TonAddress";
 };
+export interface ParsedFriendlyTonAddress {
+  readonly address: Address;
+  readonly isBounceable: boolean;
+  readonly isTestOnly: boolean;
+}
 export declare function parseTonAddress(value: string | Address): Address;
+export declare function parseFriendlyTonAddress(value: string): ParsedFriendlyTonAddress;
 export declare function toTonAddress(value: string | Address): TonAddress;
 export declare function addressesEqual(left: string | Address, right: string | Address): boolean;
 export declare function toFriendlyAddress(value: string | Address, options?: {

package/dist/core/address.mjs

@@ -10,6 +10,14 @@ function parseTonAddress(value) {
 		throw new TonPackageError("INVALID_ADDRESS", "Invalid TON address", { cause: String(error) });
 	}
 }
+function parseFriendlyTonAddress(value) {
+	if (typeof value !== "string") throw new TonPackageError("INVALID_ADDRESS", "Invalid friendly TON address");
+	try {
+		return Address.parseFriendly(value.trim());
+	} catch (error) {
+		throw new TonPackageError("INVALID_ADDRESS", "Invalid friendly TON address", { cause: String(error) });
+	}
+}
 function toTonAddress(value) {
 	return parseTonAddress(value).toRawString();
 }
@@ -42,4 +50,4 @@ function assertWorkchain(value, workchain) {
 	invariant(address.workChain === workchain, "INVALID_ADDRESS", `Expected workchain ${workchain}, received ${address.workChain}`);
 }
 //#endregion
-export { addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress };
+export { addressesEqual, assertWorkchain, parseFriendlyTonAddress, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress };

package/dist/core/index.d.mts

@@ -1,8 +1,8 @@
 import { TON_NETWORKS, TonNetwork, TonNetworkConfig, createNetworkConfig, explorerAddressUrl } from "./network.mjs";
-import { TonAddress, addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./address.mjs";
+import { ParsedFriendlyTonAddress, TonAddress, addressesEqual, assertWorkchain, parseFriendlyTonAddress, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./address.mjs";
 import { TokenMetadata, parseTokenMetadata, parseTokenMetadataJson } from "./metadata.mjs";
 import { MAX_TON_COINS, assertTonAmount, formatTon, formatUnits, parseTon, parseUnits } from "./amount.mjs";
 import { bytesToBase64, bytesToHex, hexToBytes } from "./bytes.mjs";
 import { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO } from "./constants.mjs";
 import { TonErrorCode, TonPackageError, invariant } from "./errors.mjs";
-export { MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_NETWORKS, TokenMetadata, TonAddress, TonErrorCode, TonNetwork, TonNetworkConfig, TonPackageError, addressesEqual, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, createNetworkConfig, explorerAddressUrl, formatTon, formatUnits, hexToBytes, invariant, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, shortenTonAddress, toFriendlyAddress, toTonAddress };
+export { MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, ParsedFriendlyTonAddress, TON_NETWORKS, TokenMetadata, TonAddress, TonErrorCode, TonNetwork, TonNetworkConfig, TonPackageError, addressesEqual, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, createNetworkConfig, explorerAddressUrl, formatTon, formatUnits, hexToBytes, invariant, parseFriendlyTonAddress, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, shortenTonAddress, toFriendlyAddress, toTonAddress };

package/dist/core/index.mjs

@@ -1,8 +1,8 @@
 import { TonPackageError, invariant } from "./errors.mjs";
-import { addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./address.mjs";
+import { addressesEqual, assertWorkchain, parseFriendlyTonAddress, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./address.mjs";
 import { MAX_TON_COINS, assertTonAmount, formatTon, formatUnits, parseTon, parseUnits } from "./amount.mjs";
 import { bytesToBase64, bytesToHex, hexToBytes } from "./bytes.mjs";
 import { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO } from "./constants.mjs";
 import { parseTokenMetadata, parseTokenMetadataJson } from "./metadata.mjs";
 import { TON_NETWORKS, createNetworkConfig, explorerAddressUrl } from "./network.mjs";
-export { MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_NETWORKS, TonPackageError, addressesEqual, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, createNetworkConfig, explorerAddressUrl, formatTon, formatUnits, hexToBytes, invariant, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, shortenTonAddress, toFriendlyAddress, toTonAddress };
+export { MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_NETWORKS, TonPackageError, addressesEqual, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, createNetworkConfig, explorerAddressUrl, formatTon, formatUnits, hexToBytes, invariant, parseFriendlyTonAddress, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, shortenTonAddress, toFriendlyAddress, toTonAddress };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { TON_NETWORKS, TonNetwork, TonNetworkConfig, createNetworkConfig, explorerAddressUrl } from "./core/network.mjs";
-import { TonAddress, addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./core/address.mjs";
+import { ParsedFriendlyTonAddress, TonAddress, addressesEqual, assertWorkchain, parseFriendlyTonAddress, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./core/address.mjs";
 import { TonConnectMessage, TonConnectTransaction, TonTransactionMessage, TransactionIntent, createTransactionIntent, toTonConnectTransaction, validateTransactionIntent } from "./transactions/index.mjs";
 import { readableTonConnectError } from "./connect/errors.mjs";
 import { TON_CONNECT_CHAIN_IDS, TonConnectAdapter, TonConnectClient, TonConnectWallet, createTonConnectAdapter, toWalletTransaction } from "./connect/index.mjs";
@@ -18,4 +18,4 @@ import { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO } from "./core/constants.mjs
 import { TonErrorCode, TonPackageError, invariant } from "./core/errors.mjs";
 import "./core/index.mjs";
 import { VestingSchedule, claimableAmount, unlockedAmount, validateVestingSchedule } from "./vesting/index.mjs";
-export { CONTRACT_CATALOG, ContractAuditReference, ContractCatalogId, ContractDescriptor, ContractFamily, ContractModule, ContractModuleClient, ContractModuleClientOptions, ContractModuleRegistry, ContractProductionApproval, ContractReadiness, ContractSendOptions, ContractSourceReference, MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_CONNECT_CHAIN_IDS, TON_NETWORKS, TokenMetadata, TonAccountState, TonAddress, TonConnectAdapter, TonConnectClient, TonConnectMessage, TonConnectTransaction, TonConnectWallet, TonContractClient, TonContractModule, TonErrorCode, TonGetMethodResult, TonNetwork, TonNetworkConfig, TonPackageError, TonProvider, TonTransactionMessage, TonTransactionSummary, TransactionIntent, UpgradePolicy, VestingSchedule, addressFlagDictionary, addressesEqual, assertProductionApproved, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, claimableAmount, crc32, createContractDescriptor, createContractModule, createContractModuleRegistry, createNetworkConfig, createTonConnectAdapter, createTransactionIntent, explorerAddressUrl, formatTon, formatUnits, getContractDescriptor, hexToBytes, invariant, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, readableTonConnectError, shortenTonAddress, toFriendlyAddress, toTonAddress, toTonConnectTransaction, toWalletTransaction, uint256CoinsDictionary, uint32FlagDictionary, unlockedAmount, validateTransactionIntent, validateVestingSchedule };
+export { CONTRACT_CATALOG, ContractAuditReference, ContractCatalogId, ContractDescriptor, ContractFamily, ContractModule, ContractModuleClient, ContractModuleClientOptions, ContractModuleRegistry, ContractProductionApproval, ContractReadiness, ContractSendOptions, ContractSourceReference, MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, ParsedFriendlyTonAddress, TON_CONNECT_CHAIN_IDS, TON_NETWORKS, TokenMetadata, TonAccountState, TonAddress, TonConnectAdapter, TonConnectClient, TonConnectMessage, TonConnectTransaction, TonConnectWallet, TonContractClient, TonContractModule, TonErrorCode, TonGetMethodResult, TonNetwork, TonNetworkConfig, TonPackageError, TonProvider, TonTransactionMessage, TonTransactionSummary, TransactionIntent, UpgradePolicy, VestingSchedule, addressFlagDictionary, addressesEqual, assertProductionApproved, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, claimableAmount, crc32, createContractDescriptor, createContractModule, createContractModuleRegistry, createNetworkConfig, createTonConnectAdapter, createTransactionIntent, explorerAddressUrl, formatTon, formatUnits, getContractDescriptor, hexToBytes, invariant, parseFriendlyTonAddress, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, readableTonConnectError, shortenTonAddress, toFriendlyAddress, toTonAddress, toTonConnectTransaction, toWalletTransaction, uint256CoinsDictionary, uint32FlagDictionary, unlockedAmount, validateTransactionIntent, validateVestingSchedule };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { TonPackageError, invariant } from "./core/errors.mjs";
-import { addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./core/address.mjs";
+import { addressesEqual, assertWorkchain, parseFriendlyTonAddress, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./core/address.mjs";
 import { MAX_TON_COINS, assertTonAmount, formatTon, formatUnits, parseTon, parseUnits } from "./core/amount.mjs";
 import { bytesToBase64, bytesToHex, hexToBytes } from "./core/bytes.mjs";
 import { createTransactionIntent, toTonConnectTransaction, validateTransactionIntent } from "./transactions/index.mjs";
@@ -16,4 +16,4 @@ import { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO } from "./core/constants.mjs
 import { parseTokenMetadata, parseTokenMetadataJson } from "./core/metadata.mjs";
 import { TON_NETWORKS, createNetworkConfig, explorerAddressUrl } from "./core/network.mjs";
 import { claimableAmount, unlockedAmount, validateVestingSchedule } from "./vesting/index.mjs";
-export { CONTRACT_CATALOG, ContractModuleClient, MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_CONNECT_CHAIN_IDS, TON_NETWORKS, TonContractClient, TonPackageError, addressFlagDictionary, addressesEqual, assertProductionApproved, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, claimableAmount, crc32, createContractDescriptor, createContractModule, createContractModuleRegistry, createNetworkConfig, createTonConnectAdapter, createTransactionIntent, explorerAddressUrl, formatTon, formatUnits, getContractDescriptor, hexToBytes, invariant, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, readableTonConnectError, shortenTonAddress, toFriendlyAddress, toTonAddress, toTonConnectTransaction, toWalletTransaction, uint256CoinsDictionary, uint32FlagDictionary, unlockedAmount, validateTransactionIntent, validateVestingSchedule };
+export { CONTRACT_CATALOG, ContractModuleClient, MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_CONNECT_CHAIN_IDS, TON_NETWORKS, TonContractClient, TonPackageError, addressFlagDictionary, addressesEqual, assertProductionApproved, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, claimableAmount, crc32, createContractDescriptor, createContractModule, createContractModuleRegistry, createNetworkConfig, createTonConnectAdapter, createTransactionIntent, explorerAddressUrl, formatTon, formatUnits, getContractDescriptor, hexToBytes, invariant, parseFriendlyTonAddress, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, readableTonConnectError, shortenTonAddress, toFriendlyAddress, toTonAddress, toTonConnectTransaction, toWalletTransaction, uint256CoinsDictionary, uint32FlagDictionary, unlockedAmount, validateTransactionIntent, validateVestingSchedule };

package/dist/proof/index.d.mts

@@ -0,0 +1,62 @@
+import { TonNetwork } from "../core/network.mjs";
+import { Address } from "@ton/core";
+//#region src/proof/index.d.ts
+/** The trampoline wallet code used by WalletTg. */
+export declare const TON_CONNECT_WALLET_TG_CODE_HASH = "9149ae51c1e4689710cebf7830297b16acfbadb363a920a537893e7ffeeca768";
+export interface TonConnectProof {
+  readonly timestamp: number;
+  readonly domain: {
+    readonly lengthBytes: number;
+    readonly value: string;
+  };
+  readonly payload: string;
+  readonly signature: string;
+  readonly state_init: string;
+}
+export interface VerifyTonConnectProofInput {
+  readonly address: string;
+  readonly proof: TonConnectProof;
+  readonly expectedDomain: string;
+  readonly expectedPublicKey?: string | Uint8Array;
+}
+export interface VerifyTonConnectProofOptions {
+  readonly network: TonNetwork;
+  readonly now?: number;
+  readonly maxAgeSeconds?: number;
+  readonly maxDomainBytes?: number;
+  readonly maxPayloadBytes?: number;
+  /** Additional wallet code hashes whose public key is resolved externally. */
+  readonly delegatedWalletCodeHashes?: readonly string[];
+  /** Resolve the signing key for wallets that keep it outside state_init. */
+  readonly resolveDelegatedWalletPublicKey?: (address: Address, network: TonNetwork) => Promise<Uint8Array | null>;
+}
+export interface VerifyTonConnectSignDataInput {
+  readonly address: string;
+  readonly stateInit: string;
+  readonly timestamp: number;
+  readonly domain: {
+    readonly lengthBytes: number;
+    readonly value: string;
+  };
+  readonly payload: {
+    readonly text: string;
+  };
+  readonly signature: string;
+  readonly expectedDomain: string;
+  readonly expectedPublicKey?: string | Uint8Array;
+}
+/**
+ * Verifies the TON Connect `ton_proof` signature and its state-init wallet.
+ * WalletTg and additional delegated wallets can resolve their public key with
+ * `resolveDelegatedWalletPublicKey`; resolver errors are allowed to propagate
+ * so callers can distinguish an RPC outage from an invalid proof.
+ */
+export declare function verifyTonConnectProof(input: VerifyTonConnectProofInput, options: VerifyTonConnectProofOptions): Promise<boolean>;
+/**
+ * Verifies a text payload returned by TON Connect `signData`. This validates
+ * the canonical TON Connect digest, the state-init/address binding, and the
+ * expected signing domain. It does not replace the application's challenge,
+ * message-hash, or single-use checks.
+ */
+export declare function verifyTonConnectSignData(input: VerifyTonConnectSignDataInput, options: VerifyTonConnectProofOptions): Promise<boolean>;
+//#endregion

package/dist/proof/index.mjs

@@ -0,0 +1,227 @@
+import { bytesToHex, hexToBytes } from "../core/bytes.mjs";
+import { Address, Cell } from "@ton/core";
+import { sha256, signVerify } from "@ton/crypto";
+import { WalletContractV1R1, WalletContractV1R2, WalletContractV1R3, WalletContractV2R1, WalletContractV2R2, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5R1, contractAddress as contractAddress$1, loadStateInit } from "@ton/ton";
+//#region src/proof/index.ts
+const MAX_STATE_INIT_BYTES = 12288;
+const DEFAULT_MAX_PROOF_AGE_SECONDS = 600;
+function isTonNetwork(value) {
+	return value === "mainnet" || value === "testnet";
+}
+/** The trampoline wallet code used by WalletTg. */
+const TON_CONNECT_WALLET_TG_CODE_HASH = "9149ae51c1e4689710cebf7830297b16acfbadb363a920a537893e7ffeeca768";
+const readV1V2 = (data) => {
+	const slice = data.beginParse();
+	slice.loadUint(32);
+	return slice.loadBuffer(32);
+};
+const readV3V4 = (data) => {
+	const slice = data.beginParse();
+	slice.loadUint(32);
+	slice.loadUint(32);
+	return slice.loadBuffer(32);
+};
+const readV5 = (data) => {
+	const slice = data.beginParse();
+	slice.loadBoolean();
+	slice.loadUint(32);
+	slice.loadUint(32);
+	return slice.loadBuffer(32);
+};
+const standardWallets = [
+	...[
+		WalletContractV1R1,
+		WalletContractV1R2,
+		WalletContractV1R3,
+		WalletContractV2R1,
+		WalletContractV2R2
+	].map((wallet) => ({
+		code: wallet.create({
+			workchain: 0,
+			publicKey: Buffer.alloc(32)
+		}).init.code,
+		readPublicKey: readV1V2
+	})),
+	...[
+		WalletContractV3R1,
+		WalletContractV3R2,
+		WalletContractV4
+	].map((wallet) => ({
+		code: wallet.create({
+			workchain: 0,
+			publicKey: Buffer.alloc(32)
+		}).init.code,
+		readPublicKey: readV3V4
+	})),
+	{
+		code: WalletContractV5R1.create({
+			workchain: 0,
+			publicKey: Buffer.alloc(32)
+		}).init.code,
+		readPublicKey: readV5
+	}
+];
+function parseStateInitWallet(addressValue, stateInitBase64) {
+	if (stateInitBase64.length === 0 || stateInitBase64.length > Math.ceil(MAX_STATE_INIT_BYTES * 4 / 3)) return null;
+	let address;
+	let stateInit;
+	try {
+		const bytes = Buffer.from(stateInitBase64, "base64");
+		if (bytes.length === 0 || bytes.length > MAX_STATE_INIT_BYTES || bytes.toString("base64") !== stateInitBase64) return null;
+		const cells = Cell.fromBoc(bytes);
+		if (cells.length !== 1) return null;
+		const cell = cells[0];
+		if (!cell) return null;
+		stateInit = loadStateInit(cell.beginParse());
+		address = Address.parse(addressValue);
+	} catch {
+		return null;
+	}
+	if (!stateInit.code || !stateInit.data) return null;
+	if (!contractAddress$1(address.workChain, stateInit).equals(address)) return null;
+	const codeHash = bytesToHex(stateInit.code.hash());
+	for (const wallet of standardWallets) {
+		if (!wallet.code.equals(stateInit.code)) continue;
+		try {
+			const publicKey = wallet.readPublicKey(stateInit.data);
+			return publicKey.length === 32 ? {
+				address,
+				codeHash,
+				publicKey,
+				delegated: false
+			} : null;
+		} catch {
+			return null;
+		}
+	}
+	return {
+		address,
+		codeHash,
+		publicKey: null,
+		delegated: true
+	};
+}
+function decodeExpectedPublicKey(value) {
+	if (value === void 0) return null;
+	if (typeof value !== "string") return value.length === 32 ? value : null;
+	try {
+		const bytes = hexToBytes(value);
+		return bytes.length === 32 ? bytes : null;
+	} catch {
+		return null;
+	}
+}
+function decodeSignature(value) {
+	try {
+		const signature = Buffer.from(value, "base64");
+		return signature.length === 64 && signature.toString("base64") === value ? signature : null;
+	} catch {
+		return null;
+	}
+}
+async function resolveSigningPublicKey(parsed, expectedPublicKey, options) {
+	let publicKey = parsed.publicKey;
+	if (!publicKey) {
+		if (!options.resolveDelegatedWalletPublicKey) return null;
+		publicKey = await options.resolveDelegatedWalletPublicKey(parsed.address, options.network);
+		if (publicKey?.length !== 32) return null;
+	}
+	const expected = decodeExpectedPublicKey(expectedPublicKey);
+	if (expectedPublicKey !== void 0 && !expected) return null;
+	if (expected && !Buffer.from(publicKey).equals(Buffer.from(expected))) return null;
+	return publicKey;
+}
+/**
+* Verifies the TON Connect `ton_proof` signature and its state-init wallet.
+* WalletTg and additional delegated wallets can resolve their public key with
+* `resolveDelegatedWalletPublicKey`; resolver errors are allowed to propagate
+* so callers can distinguish an RPC outage from an invalid proof.
+*/
+async function verifyTonConnectProof(input, options) {
+	if (!input || !options || !isTonNetwork(options.network) || typeof input.address !== "string" || typeof input.expectedDomain !== "string" || input.expectedDomain.length === 0 || !input.proof || typeof input.proof.state_init !== "string" || typeof input.proof.domain?.value !== "string" || !Number.isSafeInteger(input.proof.domain.lengthBytes) || !Number.isSafeInteger(input.proof.timestamp) || typeof input.proof.payload !== "string" || typeof input.proof.signature !== "string") return false;
+	const { proof } = input;
+	const domain = Buffer.from(proof.domain.value, "utf8");
+	const payload = Buffer.from(proof.payload, "utf8");
+	const maxDomainBytes = options.maxDomainBytes ?? 128;
+	const maxPayloadBytes = options.maxPayloadBytes ?? 128;
+	const now = options.now ?? Math.floor(Date.now() / 1e3);
+	const maxAgeSeconds = options.maxAgeSeconds ?? DEFAULT_MAX_PROOF_AGE_SECONDS;
+	if (proof.domain.value !== input.expectedDomain || proof.domain.lengthBytes !== domain.length || domain.length > maxDomainBytes || payload.length > maxPayloadBytes || proof.timestamp < 0 || !Number.isSafeInteger(now) || !Number.isSafeInteger(maxAgeSeconds) || maxAgeSeconds < 0 || Math.abs(now - proof.timestamp) > maxAgeSeconds) return false;
+	const signature = decodeSignature(proof.signature);
+	if (!signature) return false;
+	const parsed = parseStateInitWallet(input.address, input.proof.state_init);
+	if (!parsed) return false;
+	const delegatedHashes = /* @__PURE__ */ new Set([TON_CONNECT_WALLET_TG_CODE_HASH, ...(options.delegatedWalletCodeHashes ?? []).map((hash) => hash.toLowerCase())]);
+	if (parsed.delegated && !delegatedHashes.has(parsed.codeHash)) return false;
+	const publicKey = await resolveSigningPublicKey(parsed, input.expectedPublicKey, options);
+	if (!publicKey) return false;
+	const workchain = Buffer.alloc(4);
+	workchain.writeInt32BE(parsed.address.workChain, 0);
+	const domainLength = Buffer.alloc(4);
+	domainLength.writeUInt32LE(domain.length, 0);
+	const timestamp = Buffer.alloc(8);
+	timestamp.writeBigUInt64LE(BigInt(proof.timestamp), 0);
+	const message = Buffer.concat([
+		Buffer.from("ton-proof-item-v2/", "utf8"),
+		workchain,
+		parsed.address.hash,
+		domainLength,
+		domain,
+		timestamp,
+		payload
+	]);
+	const messageHash = await sha256(message);
+	const digest = await sha256(Buffer.concat([
+		Buffer.from([255, 255]),
+		Buffer.from("ton-connect", "utf8"),
+		messageHash
+	]));
+	return signVerify(digest, signature, Buffer.from(publicKey));
+}
+/**
+* Verifies a text payload returned by TON Connect `signData`. This validates
+* the canonical TON Connect digest, the state-init/address binding, and the
+* expected signing domain. It does not replace the application's challenge,
+* message-hash, or single-use checks.
+*/
+async function verifyTonConnectSignData(input, options) {
+	if (!input || !options || !isTonNetwork(options.network) || typeof input.address !== "string" || typeof input.stateInit !== "string" || typeof input.expectedDomain !== "string" || input.expectedDomain.length === 0 || typeof input.domain?.value !== "string" || !Number.isSafeInteger(input.domain.lengthBytes) || !Number.isSafeInteger(input.timestamp) || typeof input.payload?.text !== "string" || typeof input.signature !== "string") return false;
+	const domain = Buffer.from(input.domain.value, "utf8");
+	const payload = Buffer.from(input.payload.text, "utf8");
+	const now = options.now ?? Math.floor(Date.now() / 1e3);
+	const maxAgeSeconds = options.maxAgeSeconds ?? DEFAULT_MAX_PROOF_AGE_SECONDS;
+	const maxPayloadBytes = options.maxPayloadBytes ?? 2e3;
+	if (input.timestamp < 0 || !Number.isSafeInteger(now) || !Number.isSafeInteger(maxAgeSeconds) || maxAgeSeconds < 0 || input.domain.value !== input.expectedDomain || input.domain.lengthBytes !== domain.length || domain.length > (options.maxDomainBytes ?? 128) || payload.length === 0 || payload.length > maxPayloadBytes || input.timestamp > now + 60 || now - input.timestamp > maxAgeSeconds) return false;
+	const signature = decodeSignature(input.signature);
+	if (!signature) return false;
+	const parsed = parseStateInitWallet(input.address, input.stateInit);
+	if (!parsed) return false;
+	const delegatedHashes = /* @__PURE__ */ new Set([TON_CONNECT_WALLET_TG_CODE_HASH, ...(options.delegatedWalletCodeHashes ?? []).map((hash) => hash.toLowerCase())]);
+	if (parsed.delegated && !delegatedHashes.has(parsed.codeHash)) return false;
+	const publicKey = await resolveSigningPublicKey(parsed, input.expectedPublicKey, options);
+	if (!publicKey) return false;
+	const workchain = Buffer.alloc(4);
+	workchain.writeInt32BE(parsed.address.workChain, 0);
+	const domainLength = Buffer.alloc(4);
+	domainLength.writeUInt32BE(domain.length, 0);
+	const timestamp = Buffer.alloc(8);
+	timestamp.writeBigUInt64BE(BigInt(input.timestamp), 0);
+	const payloadLength = Buffer.alloc(4);
+	payloadLength.writeUInt32BE(payload.length, 0);
+	const message = Buffer.concat([
+		Buffer.from([255, 255]),
+		Buffer.from("ton-connect/sign-data/", "utf8"),
+		workchain,
+		parsed.address.hash,
+		domainLength,
+		domain,
+		timestamp,
+		Buffer.from("txt", "utf8"),
+		payloadLength,
+		payload
+	]);
+	const digest = await sha256(message);
+	return signVerify(digest, signature, Buffer.from(publicKey));
+}
+//#endregion
+export { TON_CONNECT_WALLET_TG_CODE_HASH, verifyTonConnectProof, verifyTonConnectSignData };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pizzaton/ton",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"description": "Typed TON blockchain primitives, contract wrappers, and protocol adapters",
 	"type": "module",
 	"main": "./dist/index.mjs",
@@ -43,6 +43,10 @@
 			"types": "./dist/provider/index.d.mts",
 			"import": "./dist/provider/index.mjs"
 		},
+		"./proof": {
+			"types": "./dist/proof/index.d.mts",
+			"import": "./dist/proof/index.mjs"
+		},
 		"./indexer": {
 			"types": "./dist/indexer/index.d.mts",
 			"import": "./dist/indexer/index.mjs"
@@ -130,10 +134,10 @@
 	"dependencies": {
 		"@ton/crypto": "^3.3.0",
 		"@ton/ton": "^16.3.0",
-		"@tonconnect/sdk": "^4.0.2",
 		"zod": "^4.5.4"
 	},
 	"peerDependencies": {
+		"@tonconnect/sdk": ">=4.0.2 <6.0.0",
 		"@ton/core": "^0.63.1",
 		"@types/node": ">=20",
 		"@ton/sandbox": "^0.44.0",
@@ -142,6 +146,9 @@
 		"@types/react": "^18.0.0 || ^19.0.0"
 	},
 	"peerDependenciesMeta": {
+		"@tonconnect/sdk": {
+			"optional": true
+		},
 		"@ton/sandbox": {
 			"optional": true
 		},