@dynamic-labs/waas-ton 4.51.0 → 4.52.0

package/src/connector/DynamicWaasTonConnector.js

@@ -0,0 +1,278 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { TonClient } from '@ton/ton';
+import { MFAAction } from '@dynamic-labs/sdk-api-core';
+import { TonUiTransaction, NANOTON_PER_TON } from '@dynamic-labs/ton';
+import { DynamicError } from '@dynamic-labs/utils';
+import { withDynamicWaas } from '@dynamic-labs/waas';
+import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
+import { DynamicWaasTonSigner } from '../signer/DynamicWaasTonSigner.js';
+import { CHAIN } from '../types/index.js';
+import { prepareTransaction } from '../utils/prepareTransaction/prepareTransaction.js';
+import '@ton/crypto';
+import { prepareTonTransfer } from '../utils/prepareTonTransfer/prepareTonTransfer.js';
+import { prepareJettonTransfer } from '../utils/prepareJettonTransfer/prepareJettonTransfer.js';
+import { getWalletSeqno } from '../utils/getWalletSeqno/getWalletSeqno.js';
+import { executeTransaction } from '../utils/executeTransaction/executeTransaction.js';
+import { extractDisplayInfoFromRequest } from '../utils/extractDisplayInfoFromRequest/extractDisplayInfoFromRequest.js';
+import { convertSendTransactionRequest } from '../utils/convertSendTransactionRequest/convertSendTransactionRequest.js';
+import { logger } from '../utils/logger/logger.js';
+import { TonWalletConnector } from './TonWalletConnector.js';
+import { Logger } from '@dynamic-labs/logger';
+
+class DynamicWaasTonConnector extends withDynamicWaas(TonWalletConnector) {
+    constructor(props) {
+        super(props);
+        this.name = 'Dynamic Waas';
+        this.overrideKey = 'dynamicwaas';
+        this.isEmbeddedWallet = true;
+        this.logger = logger;
+        this.walletUiUtils = props.walletUiUtils;
+    }
+    /**
+     * Override setEnvironmentId to ensure it's set on the global logger
+     */
+    setEnvironmentId(environmentId) {
+        super.setEnvironmentId(environmentId);
+        Logger.setEnvironmentId(environmentId);
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new DynamicWaasTonSigner({
+                walletConnector: this,
+            });
+        });
+    }
+    getWalletClientByAddress(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ accountAddress, }) {
+            this.setActiveAccountAddress(accountAddress);
+            return this.getWaasWalletClient();
+        });
+    }
+    getTonClient(chainId) {
+        var _a, _b, _c;
+        const targetChainId = chainId || CHAIN.MAINNET;
+        const network = (_a = this.tonNetworks) === null || _a === void 0 ? void 0 : _a.find((net) => net.chainId === targetChainId);
+        if (!network) {
+            throw new DynamicError(`Network configuration not found for chainId: ${targetChainId}`);
+        }
+        const endpoint = ((_b = network.privateCustomerRpcUrls) === null || _b === void 0 ? void 0 : _b[0]) || ((_c = network.rpcUrls) === null || _c === void 0 ? void 0 : _c[0]);
+        if (!endpoint) {
+            throw new DynamicError(`No RPC endpoint found for chainId: ${targetChainId}`);
+        }
+        return new TonClient({
+            endpoint,
+        });
+    }
+    getActiveAccountAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.activeAccountAddress;
+        });
+    }
+    setActiveAccountAddress(accountAddress) {
+        this.activeAccountAddress = accountAddress;
+    }
+    requireSignedSessionId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const signedSessionId = yield ((_a = this.getSignedSessionId) === null || _a === void 0 ? void 0 : _a.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError('Signed session ID is required');
+            }
+            return signedSessionId;
+        });
+    }
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const targetWallet = yield walletClient.getWallet({
+                accountAddress: expectedAddress,
+                authToken: (_a = this.getAuthToken) === null || _a === void 0 ? void 0 : _a.call(this),
+                signedSessionId,
+            });
+            if (!targetWallet) {
+                throw new DynamicError('Account not found');
+            }
+            const isWalletActive = isSameAddress(targetWallet.accountAddress, this.activeAccountAddress || '', this.connectedChain);
+            if (!isWalletActive) {
+                this.activeAccountAddress = targetWallet.accountAddress;
+            }
+        });
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.activeAccountAddress;
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getWaasWalletClient();
+        });
+    }
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.walletUiUtils.signMessage({
+                handler: () => __awaiter(this, void 0, void 0, function* () { return this.internalSignMessage(message); }),
+                message,
+                walletConnector: this,
+            });
+        });
+    }
+    internalSignMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new Error('Active account address is required');
+            }
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const signedMessage = yield walletClient.signMessage({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_b = this.getAuthToken) === null || _b === void 0 ? void 0 : _b.call(this),
+                message,
+                mfaToken,
+                signedSessionId,
+            });
+            return signedMessage;
+        });
+    }
+    endSession() {
+        const _super = Object.create(null, {
+            endSession: { get: () => super.endSession }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.endSession.call(this);
+            this.activeAccountAddress = undefined;
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    signMessageWithContext(_params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
+    }
+    sendTransaction(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            // TON Connect spec allows 1-4 messages per transaction
+            if (request.messages.length < 1 || request.messages.length > 4) {
+                throw new DynamicError(`Invalid message count: ${request.messages.length}. Must be between 1 and 4.`);
+            }
+            const displayInfo = extractDisplayInfoFromRequest(request);
+            const uiTransaction = new TonUiTransaction({
+                client: this.getTonClient(),
+                from: this.activeAccountAddress,
+                onSubmit: () => __awaiter(this, void 0, void 0, function* () { return this.internalSendTransaction(request); }),
+            });
+            uiTransaction.to = displayInfo.recipient;
+            uiTransaction.value = displayInfo.value
+                ? BigInt(displayInfo.value)
+                : undefined;
+            // Handle jetton transfers
+            if (displayInfo.jettonAddress && displayInfo.jettonAmount) {
+                uiTransaction.nonNativeAddress = displayInfo.jettonAddress;
+                uiTransaction.nonNativeValue = BigInt(displayInfo.jettonAmount);
+            }
+            return this.walletUiUtils.sendTransaction(this, uiTransaction);
+        });
+    }
+    internalSendTransaction(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const client = this.getTonClient();
+            const walletAddress = request.from || this.activeAccountAddress;
+            const network = request.network || CHAIN.MAINNET;
+            const seqno = yield getWalletSeqno(walletAddress, client);
+            const actionsArray = convertSendTransactionRequest(request);
+            const { hashToSignHex, transactionData } = prepareTransaction({
+                actionsArray,
+                networkGlobalId: network,
+                seqno,
+                timeout: request.validUntil - Math.floor(Date.now() / 1000),
+                validUntil: request.validUntil,
+                walletAddress,
+            });
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const signature = yield walletClient.signTransaction({
+                authToken: (_b = this.getAuthToken) === null || _b === void 0 ? void 0 : _b.call(this),
+                mfaToken,
+                senderAddress: this.activeAccountAddress,
+                signedSessionId,
+                transaction: hashToSignHex,
+            });
+            const result = yield executeTransaction({
+                client,
+                signature,
+                transactionData,
+            });
+            if (!result.success) {
+                throw new DynamicError(`Failed to execute transaction: ${result.error || 'Unknown error'}`);
+            }
+            return result.transactionHash || '';
+        });
+    }
+    internalSendUiTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!transaction.to) {
+                throw new DynamicError('Destination address is required');
+            }
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const client = this.getTonClient();
+            // Handle Jetton (non-native token) transfers
+            if (transaction.nonNativeAddress && transaction.nonNativeValue) {
+                const request = yield prepareJettonTransfer({
+                    client,
+                    forwardTonAmount: BigInt(0),
+                    jettonAmount: transaction.nonNativeValue,
+                    jettonMasterAddress: transaction.nonNativeAddress,
+                    recipientAddress: transaction.to,
+                    timeout: 60,
+                    walletAddress: this.activeAccountAddress,
+                });
+                return this.internalSendTransaction(request);
+            }
+            // Handle native TON transfers
+            if (transaction.value) {
+                const tonAmount = Number(transaction.value) / NANOTON_PER_TON;
+                const request = yield prepareTonTransfer({
+                    amount: tonAmount,
+                    client,
+                    recipient: transaction.to,
+                    timeout: 60,
+                    walletAddress: this.activeAccountAddress,
+                });
+                return this.internalSendTransaction(request);
+            }
+            throw new DynamicError('Invalid transaction parameters');
+        });
+    }
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const client = this.getTonClient();
+            return new TonUiTransaction({
+                client,
+                from,
+                onSubmit: (transaction) => __awaiter(this, void 0, void 0, function* () { return this.internalSendUiTransaction(transaction); }),
+            });
+        });
+    }
+}
+
+export { DynamicWaasTonConnector };

package/src/connector/TonWalletConnector.cjs

@@ -0,0 +1,41 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var WaasTonWallet = require('../wallet/WaasTonWallet.cjs');
+var index = require('../types/index.cjs');
+
+/**
+ * Temp file until we have the ton-core package ready.
+ */
+class TonWalletConnector extends walletConnectorCore.WalletConnectorBase {
+    constructor(opts) {
+        super(opts);
+        this.ChainWallet = WaasTonWallet.WaasTonWallet;
+        this.connectedChain = 'TON';
+        this.supportedChains = ['TON'];
+        this.tonNetworks = opts.tonNetworks;
+    }
+    /**
+     * Get the enabled networks for the wallet.
+     * Networks are configured via project settings.
+     */
+    getEnabledNetworks() {
+        return this.tonNetworks;
+    }
+    /**
+     * Get the current network ID.
+     * Returns the first network's networkId as default.
+     */
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            return ((_c = (_b = (_a = this.tonNetworks) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.networkId) === null || _c === void 0 ? void 0 : _c.toString()) || index.CHAIN.MAINNET;
+        });
+    }
+}
+
+exports.TonWalletConnector = TonWalletConnector;

package/src/connector/TonWalletConnector.d.ts

@@ -0,0 +1,29 @@
+import { Chain, WalletConnectorBase, WalletMetadata } from '@dynamic-labs/wallet-connector-core';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { GenericNetwork } from '@dynamic-labs/types';
+import { WaasTonWallet } from '../wallet/WaasTonWallet';
+export type TonWalletConnectorOpts = {
+    walletBook: WalletBookSchema;
+    tonNetworks: GenericNetwork[];
+    metadata?: WalletMetadata;
+};
+/**
+ * Temp file until we have the ton-core package ready.
+ */
+export declare abstract class TonWalletConnector extends WalletConnectorBase<typeof WaasTonWallet> {
+    ChainWallet: typeof WaasTonWallet;
+    connectedChain: Chain;
+    supportedChains: Chain[];
+    tonNetworks: GenericNetwork[];
+    constructor(opts: TonWalletConnectorOpts);
+    /**
+     * Get the enabled networks for the wallet.
+     * Networks are configured via project settings.
+     */
+    getEnabledNetworks(): GenericNetwork[];
+    /**
+     * Get the current network ID.
+     * Returns the first network's networkId as default.
+     */
+    getNetwork(): Promise<string | undefined>;
+}

package/src/connector/TonWalletConnector.js

@@ -0,0 +1,37 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { WaasTonWallet } from '../wallet/WaasTonWallet.js';
+import { CHAIN } from '../types/index.js';
+
+/**
+ * Temp file until we have the ton-core package ready.
+ */
+class TonWalletConnector extends WalletConnectorBase {
+    constructor(opts) {
+        super(opts);
+        this.ChainWallet = WaasTonWallet;
+        this.connectedChain = 'TON';
+        this.supportedChains = ['TON'];
+        this.tonNetworks = opts.tonNetworks;
+    }
+    /**
+     * Get the enabled networks for the wallet.
+     * Networks are configured via project settings.
+     */
+    getEnabledNetworks() {
+        return this.tonNetworks;
+    }
+    /**
+     * Get the current network ID.
+     * Returns the first network's networkId as default.
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            return ((_c = (_b = (_a = this.tonNetworks) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.networkId) === null || _c === void 0 ? void 0 : _c.toString()) || CHAIN.MAINNET;
+        });
+    }
+}
+
+export { TonWalletConnector };

package/src/index.cjs

@@ -0,0 +1,34 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assertPackageVersion = require('@dynamic-labs/assert-package-version');
+var _package = require('../package.cjs');
+var DynamicWaasTonConnector = require('./connector/DynamicWaasTonConnector.cjs');
+var DynamicWaasTonConnectors = require('./DynamicWaasTonConnectors.cjs');
+var DynamicWaasTonSigner = require('./signer/DynamicWaasTonSigner.cjs');
+var WaasTonWallet = require('./wallet/WaasTonWallet.cjs');
+require('@ton/ton');
+require('@ton/core');
+require('./types/index.cjs');
+var generateTonConnectProofHash = require('./utils/generateTonConnectProofHash/generateTonConnectProofHash.cjs');
+var prepareTonTransfer = require('./utils/prepareTonTransfer/prepareTonTransfer.cjs');
+var prepareJettonTransfer = require('./utils/prepareJettonTransfer/prepareJettonTransfer.cjs');
+var getJettonWalletAddress = require('./utils/getJettonWalletAddress/getJettonWalletAddress.cjs');
+var getWalletSeqno = require('./utils/getWalletSeqno/getWalletSeqno.cjs');
+var executeTransaction = require('./utils/executeTransaction/executeTransaction.cjs');
+require('./utils/logger/logger.cjs');
+
+assertPackageVersion.assertPackageVersion('@dynamic-labs/waas-ton', _package.version);
+
+exports.DynamicWaasTonConnector = DynamicWaasTonConnector.DynamicWaasTonConnector;
+exports.DynamicWaasTonConnectors = DynamicWaasTonConnectors.DynamicWaasTonConnectors;
+exports.DynamicWaasTonSigner = DynamicWaasTonSigner.DynamicWaasTonSigner;
+exports.WaasTonWallet = WaasTonWallet.WaasTonWallet;
+exports.generateTonConnectProofHash = generateTonConnectProofHash.generateTonConnectProofHash;
+exports.prepareTonTransfer = prepareTonTransfer.prepareTonTransfer;
+exports.prepareJettonTransfer = prepareJettonTransfer.prepareJettonTransfer;
+exports.getJettonWalletAddress = getJettonWalletAddress.getJettonWalletAddress;
+exports.getWalletSeqno = getWalletSeqno.getWalletSeqno;
+exports.executeTransaction = executeTransaction.executeTransaction;

package/src/index.d.ts

@@ -0,0 +1,7 @@
+export { DynamicWaasTonConnector } from './connector/DynamicWaasTonConnector';
+export { DynamicWaasTonConnectors } from './DynamicWaasTonConnectors';
+export { DynamicWaasTonSigner } from './signer/DynamicWaasTonSigner';
+export { WaasTonWallet } from './wallet/WaasTonWallet';
+export type { TonConnectDomain, TonConnectProof, TonTransactionData, } from './types';
+export { prepareTonTransfer, getWalletSeqno, executeTransaction, generateTonConnectProofHash, getJettonWalletAddress, prepareJettonTransfer, } from './utils';
+export type { PrepareTonTransferParams, ExecuteTransactionParams, ExecuteTransactionResult, GenerateTonConnectProofHashParams, GetJettonWalletAddressParams, PrepareJettonTransferParams, } from './utils';

package/src/index.js

@@ -0,0 +1,19 @@
+'use client'
+import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
+import { version } from '../package.js';
+export { DynamicWaasTonConnector } from './connector/DynamicWaasTonConnector.js';
+export { DynamicWaasTonConnectors } from './DynamicWaasTonConnectors.js';
+export { DynamicWaasTonSigner } from './signer/DynamicWaasTonSigner.js';
+export { WaasTonWallet } from './wallet/WaasTonWallet.js';
+import '@ton/ton';
+import '@ton/core';
+import './types/index.js';
+export { generateTonConnectProofHash } from './utils/generateTonConnectProofHash/generateTonConnectProofHash.js';
+export { prepareTonTransfer } from './utils/prepareTonTransfer/prepareTonTransfer.js';
+export { prepareJettonTransfer } from './utils/prepareJettonTransfer/prepareJettonTransfer.js';
+export { getJettonWalletAddress } from './utils/getJettonWalletAddress/getJettonWalletAddress.js';
+export { getWalletSeqno } from './utils/getWalletSeqno/getWalletSeqno.js';
+export { executeTransaction } from './utils/executeTransaction/executeTransaction.js';
+import './utils/logger/logger.js';
+
+assertPackageVersion('@dynamic-labs/waas-ton', version);

package/src/signer/DynamicWaasTonSigner.cjs

@@ -0,0 +1,61 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+require('@ton/ton');
+require('@ton/core');
+require('../types/index.cjs');
+var generateTonConnectProofHash = require('../utils/generateTonConnectProofHash/generateTonConnectProofHash.cjs');
+require('../utils/prepareJettonTransfer/prepareJettonTransfer.cjs');
+require('../utils/logger/logger.cjs');
+
+/**
+ * Signer implementation for DynamicWaasTonConnector
+ */
+class DynamicWaasTonSigner {
+    constructor({ walletConnector, }) {
+        this.walletConnector = walletConnector;
+        this.accountAddress = this.walletConnector.activeAccountAddress;
+    }
+    /**
+     * Generates a TON Connect proof by constructing the proof message,
+     * hashing it according to TON Connect spec, and signing it.
+     *
+     * @param payload - The payload string to include in the proof
+     * @returns Complete TON Connect proof object
+     */
+    generateTonConnectProof(payload) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.accountAddress) {
+                throw new Error('Active account address is required');
+            }
+            yield this.walletConnector.getWaasWalletClient();
+            const host = utils.PlatformService.getHost();
+            const timestamp = Math.floor(Date.now() / 1000);
+            const domainLengthBytes = new TextEncoder().encode(host).length;
+            const domain = {
+                lengthBytes: domainLengthBytes,
+                value: host,
+            };
+            const hashHex = yield generateTonConnectProofHash.generateTonConnectProofHash({
+                address: this.accountAddress,
+                domain,
+                payload,
+                timestamp,
+            });
+            const signature = yield this.walletConnector.signMessage(hashHex);
+            return {
+                address: this.accountAddress,
+                domain,
+                payload,
+                signature,
+                timestamp,
+            };
+        });
+    }
+}
+
+exports.DynamicWaasTonSigner = DynamicWaasTonSigner;

package/src/signer/DynamicWaasTonSigner.d.ts

@@ -0,0 +1,20 @@
+import { DynamicWaasTonConnector } from '../connector/DynamicWaasTonConnector';
+import type { TonConnectProof } from '../types';
+/**
+ * Signer implementation for DynamicWaasTonConnector
+ */
+export declare class DynamicWaasTonSigner {
+    private readonly accountAddress;
+    private walletConnector;
+    constructor({ walletConnector, }: {
+        walletConnector: DynamicWaasTonConnector;
+    });
+    /**
+     * Generates a TON Connect proof by constructing the proof message,
+     * hashing it according to TON Connect spec, and signing it.
+     *
+     * @param payload - The payload string to include in the proof
+     * @returns Complete TON Connect proof object
+     */
+    generateTonConnectProof(payload: string): Promise<TonConnectProof>;
+}

package/src/signer/DynamicWaasTonSigner.js

@@ -0,0 +1,57 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { PlatformService } from '@dynamic-labs/utils';
+import '@ton/ton';
+import '@ton/core';
+import '../types/index.js';
+import { generateTonConnectProofHash } from '../utils/generateTonConnectProofHash/generateTonConnectProofHash.js';
+import '../utils/prepareJettonTransfer/prepareJettonTransfer.js';
+import '../utils/logger/logger.js';
+
+/**
+ * Signer implementation for DynamicWaasTonConnector
+ */
+class DynamicWaasTonSigner {
+    constructor({ walletConnector, }) {
+        this.walletConnector = walletConnector;
+        this.accountAddress = this.walletConnector.activeAccountAddress;
+    }
+    /**
+     * Generates a TON Connect proof by constructing the proof message,
+     * hashing it according to TON Connect spec, and signing it.
+     *
+     * @param payload - The payload string to include in the proof
+     * @returns Complete TON Connect proof object
+     */
+    generateTonConnectProof(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accountAddress) {
+                throw new Error('Active account address is required');
+            }
+            yield this.walletConnector.getWaasWalletClient();
+            const host = PlatformService.getHost();
+            const timestamp = Math.floor(Date.now() / 1000);
+            const domainLengthBytes = new TextEncoder().encode(host).length;
+            const domain = {
+                lengthBytes: domainLengthBytes,
+                value: host,
+            };
+            const hashHex = yield generateTonConnectProofHash({
+                address: this.accountAddress,
+                domain,
+                payload,
+                timestamp,
+            });
+            const signature = yield this.walletConnector.signMessage(hashHex);
+            return {
+                address: this.accountAddress,
+                domain,
+                payload,
+                signature,
+                timestamp,
+            };
+        });
+    }
+}
+
+export { DynamicWaasTonSigner };

package/src/types/index.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Network chain identifier for TON
+ */
+exports.CHAIN = void 0;
+(function (CHAIN) {
+    CHAIN["MAINNET"] = "-239";
+    CHAIN["TESTNET"] = "-3";
+})(exports.CHAIN || (exports.CHAIN = {}));

package/src/types/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Domain information for TON Connect protocol
+ */
+export interface TonConnectDomain {
+    /** Length of domain value in bytes */
+    lengthBytes: number;
+    /** Domain value (e.g., example.com) */
+    value: string;
+}
+/**
+ * Complete TON Connect proof object
+ */
+export interface TonConnectProof {
+    /** Wallet address string */
+    address: string;
+    /** Domain information */
+    domain: TonConnectDomain;
+    /** Unix timestamp in seconds */
+    timestamp: number;
+    /** Payload string */
+    payload: string;
+    /** Signature as base64 string */
+    signature: string;
+}
+/**
+ * Network chain identifier for TON
+ */
+export declare enum CHAIN {
+    MAINNET = "-239",
+    TESTNET = "-3"
+}
+/**
+ * TON Connect compatible transaction request
+ * @see https://ton-connect.github.io/sdk/interfaces/_tonconnect_ui.SendTransactionRequest.html
+ */
+export interface SendTransactionRequest {
+    /** The sender address from which DApp intends to send the transaction */
+    from?: string;
+    /** Messages to send */
+    messages: {
+        /** Receiver's address */
+        address: string;
+        /** Amount to send in nanoTon */
+        amount: string;
+        /** Extra currencies to send */
+        extraCurrency?: {
+            [k: number]: string;
+        };
+        /** Contract specific data to add to the transaction (base64 encoded BOC) */
+        payload?: string;
+        /** Contract specific data to add to the transaction (base64 encoded BOC) */
+        stateInit?: string;
+    }[];
+    /** The network where DApp intends to send the transaction */
+    network?: CHAIN;
+    /** Sending transaction deadline in unix epoch seconds */
+    validUntil: number;
+}
+/**
+ * Generic transaction data used internally for signing and execution
+ */
+export interface TonTransactionData {
+    /** Sender wallet address */
+    address: string;
+    /** Current wallet seqno */
+    seqno: number;
+    /** Base64-encoded message body (the transaction to be signed) */
+    messageBody: string;
+    /** Transaction timeout in seconds */
+    timeout: number;
+}