@dynamic-labs/waas-ton 4.51.2 → 4.52.0

package/CHANGELOG.md

@@ -1,4 +1,13 @@
 
+## [4.52.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.51.2...v4.52.0) (2025-12-22)
+
+
+### Features
+
+* add dynamic waas ton connector ([#9981](https://github.com/dynamic-labs/dynamic-auth/issues/9981)) ([95f2ecf](https://github.com/dynamic-labs/dynamic-auth/commit/95f2ecf253550ec8badad588a904599321a5846d))
+* add getTransactionHistory to react-native ([#10132](https://github.com/dynamic-labs/dynamic-auth/issues/10132)) ([bed6ce1](https://github.com/dynamic-labs/dynamic-auth/commit/bed6ce13b5e12f80121eebf6421355ae2b87968d))
+* add useGetTransactionHistory hook ([#10131](https://github.com/dynamic-labs/dynamic-auth/issues/10131)) ([431e7e1](https://github.com/dynamic-labs/dynamic-auth/commit/431e7e1a70cd0556c14f55c2827bb419f38a59c9))
+
 ### [4.51.2](https://github.com/dynamic-labs/dynamic-auth/compare/v4.51.1...v4.51.2) (2025-12-19)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.51.2";
+var version = "4.52.0";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.51.2";
+var version = "4.52.0";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/waas-ton",
-  "version": "4.51.2",
+  "version": "4.52.0",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,11 +18,18 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs/assert-package-version": "4.51.2",
-    "@dynamic-labs/logger": "4.51.2",
+    "@dynamic-labs/assert-package-version": "4.52.0",
+    "@dynamic-labs/logger": "4.52.0",
     "@dynamic-labs/sdk-api-core": "0.0.843",
+    "@dynamic-labs/ton": "4.52.0",
     "@ton/core": "0.62.0",
     "@ton/crypto": "3.3.0",
-    "@ton/ton": "16.0.0"
-  }
+    "@ton/ton": "16.0.0",
+    "@dynamic-labs/types": "4.52.0",
+    "@dynamic-labs/utils": "4.52.0",
+    "@dynamic-labs/waas": "4.52.0",
+    "@dynamic-labs/wallet-book": "4.52.0",
+    "@dynamic-labs/wallet-connector-core": "4.52.0"
+  },
+  "peerDependencies": {}
 }

package/src/DynamicWaasTonConnectors.cjs

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DynamicWaasTonConnector = require('./connector/DynamicWaasTonConnector.cjs');
+
+const DynamicWaasTonConnectors = () => [
+    DynamicWaasTonConnector.DynamicWaasTonConnector,
+];
+
+exports.DynamicWaasTonConnectors = DynamicWaasTonConnectors;

package/src/DynamicWaasTonConnectors.d.ts

@@ -0,0 +1,2 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+export declare const DynamicWaasTonConnectors: () => WalletConnectorConstructor[];

package/src/DynamicWaasTonConnectors.js

@@ -0,0 +1,8 @@
+'use client'
+import { DynamicWaasTonConnector } from './connector/DynamicWaasTonConnector.js';
+
+const DynamicWaasTonConnectors = () => [
+    DynamicWaasTonConnector,
+];
+
+export { DynamicWaasTonConnectors };

package/src/connector/DynamicWaasTonConnector.cjs

@@ -0,0 +1,282 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var ton = require('@ton/ton');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var ton$1 = require('@dynamic-labs/ton');
+var utils = require('@dynamic-labs/utils');
+var waas = require('@dynamic-labs/waas');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var DynamicWaasTonSigner = require('../signer/DynamicWaasTonSigner.cjs');
+var index = require('../types/index.cjs');
+var prepareTransaction = require('../utils/prepareTransaction/prepareTransaction.cjs');
+require('@ton/crypto');
+var prepareTonTransfer = require('../utils/prepareTonTransfer/prepareTonTransfer.cjs');
+var prepareJettonTransfer = require('../utils/prepareJettonTransfer/prepareJettonTransfer.cjs');
+var getWalletSeqno = require('../utils/getWalletSeqno/getWalletSeqno.cjs');
+var executeTransaction = require('../utils/executeTransaction/executeTransaction.cjs');
+var extractDisplayInfoFromRequest = require('../utils/extractDisplayInfoFromRequest/extractDisplayInfoFromRequest.cjs');
+var convertSendTransactionRequest = require('../utils/convertSendTransactionRequest/convertSendTransactionRequest.cjs');
+var logger = require('../utils/logger/logger.cjs');
+var TonWalletConnector = require('./TonWalletConnector.cjs');
+var logger$1 = require('@dynamic-labs/logger');
+
+class DynamicWaasTonConnector extends waas.withDynamicWaas(TonWalletConnector.TonWalletConnector) {
+    constructor(props) {
+        super(props);
+        this.name = 'Dynamic Waas';
+        this.overrideKey = 'dynamicwaas';
+        this.isEmbeddedWallet = true;
+        this.logger = logger.logger;
+        this.walletUiUtils = props.walletUiUtils;
+    }
+    /**
+     * Override setEnvironmentId to ensure it's set on the global logger
+     */
+    setEnvironmentId(environmentId) {
+        super.setEnvironmentId(environmentId);
+        logger$1.Logger.setEnvironmentId(environmentId);
+    }
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return new DynamicWaasTonSigner.DynamicWaasTonSigner({
+                walletConnector: this,
+            });
+        });
+    }
+    getWalletClientByAddress(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ accountAddress, }) {
+            this.setActiveAccountAddress(accountAddress);
+            return this.getWaasWalletClient();
+        });
+    }
+    getTonClient(chainId) {
+        var _a, _b, _c;
+        const targetChainId = chainId || index.CHAIN.MAINNET;
+        const network = (_a = this.tonNetworks) === null || _a === void 0 ? void 0 : _a.find((net) => net.chainId === targetChainId);
+        if (!network) {
+            throw new utils.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 utils.DynamicError(`No RPC endpoint found for chainId: ${targetChainId}`);
+        }
+        return new ton.TonClient({
+            endpoint,
+        });
+    }
+    getActiveAccountAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.activeAccountAddress;
+        });
+    }
+    setActiveAccountAddress(accountAddress) {
+        this.activeAccountAddress = accountAddress;
+    }
+    requireSignedSessionId() {
+        return _tslib.__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 utils.DynamicError('Signed session ID is required');
+            }
+            return signedSessionId;
+        });
+    }
+    validateActiveWallet(expectedAddress) {
+        return _tslib.__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 utils.DynamicError('Account not found');
+            }
+            const isWalletActive = walletConnectorCore.isSameAddress(targetWallet.accountAddress, this.activeAccountAddress || '', this.connectedChain);
+            if (!isWalletActive) {
+                this.activeAccountAddress = targetWallet.accountAddress;
+            }
+        });
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.activeAccountAddress;
+        });
+    }
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.getWaasWalletClient();
+        });
+    }
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.walletUiUtils.signMessage({
+                handler: () => _tslib.__awaiter(this, void 0, void 0, function* () { return this.internalSignMessage(message); }),
+                message,
+                walletConnector: this,
+            });
+        });
+    }
+    internalSignMessage(message) {
+        return _tslib.__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: sdkApiCore.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 _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
+    }
+    sendTransaction(request) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                throw new utils.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 utils.DynamicError(`Invalid message count: ${request.messages.length}. Must be between 1 and 4.`);
+            }
+            const displayInfo = extractDisplayInfoFromRequest.extractDisplayInfoFromRequest(request);
+            const uiTransaction = new ton$1.TonUiTransaction({
+                client: this.getTonClient(),
+                from: this.activeAccountAddress,
+                onSubmit: () => _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.activeAccountAddress) {
+                throw new utils.DynamicError('Active account address is required');
+            }
+            const client = this.getTonClient();
+            const walletAddress = request.from || this.activeAccountAddress;
+            const network = request.network || index.CHAIN.MAINNET;
+            const seqno = yield getWalletSeqno.getWalletSeqno(walletAddress, client);
+            const actionsArray = convertSendTransactionRequest.convertSendTransactionRequest(request);
+            const { hashToSignHex, transactionData } = prepareTransaction.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: sdkApiCore.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.executeTransaction({
+                client,
+                signature,
+                transactionData,
+            });
+            if (!result.success) {
+                throw new utils.DynamicError(`Failed to execute transaction: ${result.error || 'Unknown error'}`);
+            }
+            return result.transactionHash || '';
+        });
+    }
+    internalSendUiTransaction(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!transaction.to) {
+                throw new utils.DynamicError('Destination address is required');
+            }
+            if (!this.activeAccountAddress) {
+                throw new utils.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.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) / ton$1.NANOTON_PER_TON;
+                const request = yield prepareTonTransfer.prepareTonTransfer({
+                    amount: tonAmount,
+                    client,
+                    recipient: transaction.to,
+                    timeout: 60,
+                    walletAddress: this.activeAccountAddress,
+                });
+                return this.internalSendTransaction(request);
+            }
+            throw new utils.DynamicError('Invalid transaction parameters');
+        });
+    }
+    createUiTransaction(from) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const client = this.getTonClient();
+            return new ton$1.TonUiTransaction({
+                client,
+                from,
+                onSubmit: (transaction) => _tslib.__awaiter(this, void 0, void 0, function* () { return this.internalSendUiTransaction(transaction); }),
+            });
+        });
+    }
+}
+
+exports.DynamicWaasTonConnector = DynamicWaasTonConnector;

package/src/connector/DynamicWaasTonConnector.d.ts

@@ -0,0 +1,153 @@
+import { TonClient } from '@ton/ton';
+import { MFAAction, SignMessageContext } from '@dynamic-labs/sdk-api-core';
+import { IUITransaction, WalletUiUtils } from '@dynamic-labs/types';
+import { IDynamicWaasConnector, InternalWalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { DynamicWaasTonSigner } from '../signer/DynamicWaasTonSigner';
+import { SendTransactionRequest } from '../types';
+import { Logger } from '../utils';
+import { TonWalletConnector, TonWalletConnectorOpts } from './TonWalletConnector';
+export type DynamicWaasTonConnectorProps = TonWalletConnectorOpts & {
+    walletUiUtils: WalletUiUtils<InternalWalletConnector>;
+};
+declare const DynamicWaasTonConnector_base: (abstract new (...args: any[]) => {
+    [x: string]: any;
+    name: string;
+    overrideKey: string;
+    isEmbeddedWallet: boolean;
+    getSignedSessionId?: (() => Promise<string>) | undefined;
+    getMfaToken?: ((props?: {
+        mfaAction?: MFAAction | undefined;
+    } | undefined) => Promise<string | undefined>) | undefined;
+    getAuthToken?: (() => string) | undefined;
+    environmentId?: string | undefined;
+    baseApiUrl?: string | undefined;
+    relayUrl?: string | undefined;
+    baseClientKeysharesRelayApiUrl?: string | undefined;
+    dynamicWaasClient: import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient | undefined;
+    chainName: string;
+    authMode: "cookie" | "header";
+    logger: Logger;
+    __exportHandler: import("@dynamic-labs/waas").WaasExportHandler;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+    setGetAuthTokenFunction(getAuthToken: () => string): void;
+    setWaasAuthMode(authMode: "cookie" | "header"): void;
+    setGetMfaTokenFunction(getMfaToken: (props?: {
+        mfaAction?: MFAAction | undefined;
+    } | undefined) => Promise<string | undefined>): void;
+    setEnvironmentId(environmentId: string): void;
+    setBaseApiUrl(baseApiUrl: string): void;
+    setBaseClientKeysharesRelayApiUrl(baseClientKeysharesRelayApiUrl?: string | undefined): void;
+    setRelayUrl(relayUrl: string): void;
+    setGetSignedSessionIdFunction(getSignedSessionId: () => Promise<string>): void;
+    delegateKeyShares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    createDynamicWaasClient(traceContext?: import("dist/packages/waas/utils/instrumentation").TraceContext | undefined): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    getWaasWalletClient(traceContext?: import("dist/packages/waas/utils/instrumentation").TraceContext | undefined): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    createWalletAccount({ thresholdSignatureScheme, password, }?: {
+        thresholdSignatureScheme?: string | undefined;
+        password?: string | undefined;
+    } | undefined): Promise<{
+        chainName: string;
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: string | Uint8Array | undefined;
+    }>;
+    importPrivateKey({ privateKey, thresholdSignatureScheme, publicAddressCheck, }: {
+        privateKey: string;
+        thresholdSignatureScheme?: string | undefined;
+        publicAddressCheck?: string | undefined;
+    }): Promise<void>;
+    exportPrivateKey({ accountAddress, displayContainer, password, }?: {
+        accountAddress?: string | undefined;
+        displayContainer?: HTMLIFrameElement | undefined;
+        password?: string | undefined;
+    } | undefined): Promise<void>;
+    getExportHandler(): {
+        clear: () => void;
+    };
+    exportClientKeyshares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    backupKeySharesToGoogleDrive({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    exportClientKeysharesFromGoogleDrive({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    refreshWalletAccountShares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    reshareWalletAccountShares({ accountAddress, thresholdSignatureScheme, password, }: {
+        accountAddress: string;
+        thresholdSignatureScheme: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    revokeDelegation({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    updatePassword({ accountAddress, existingPassword, newPassword, }: {
+        accountAddress: string;
+        existingPassword: string;
+        newPassword: string;
+    }): Promise<void>;
+    signRawMessage({ accountAddress, message, password, }: {
+        accountAddress: string;
+        message: string;
+        password?: string | undefined;
+    }): Promise<string>;
+    endSession(): Promise<void>;
+    getActiveAccountAddress(): Promise<string | undefined>;
+    generateTraceId(): string;
+    instrument(message: string, context: import("dist/packages/logger/src").InstrumentOptions & import("dist/packages/waas/utils/instrumentation").InstrumentContext & Record<string, any>): void;
+    instrumentAsync<T_1>({ operation, resource, fn, context, }: {
+        operation: string;
+        resource: string;
+        fn: (timing: import("dist/packages/waas/utils/instrumentation").InstrumentationTimer) => Promise<T_1>;
+        context?: Record<string, any> | undefined;
+    }): Promise<T_1>;
+}) & typeof TonWalletConnector;
+export declare class DynamicWaasTonConnector extends DynamicWaasTonConnector_base implements IDynamicWaasConnector {
+    name: string;
+    overrideKey: string;
+    isEmbeddedWallet: boolean;
+    logger: Logger;
+    activeAccountAddress: string | undefined;
+    protected walletUiUtils: WalletUiUtils<InternalWalletConnector>;
+    constructor(props: DynamicWaasTonConnectorProps);
+    /**
+     * Override setEnvironmentId to ensure it's set on the global logger
+     */
+    setEnvironmentId(environmentId: string): void;
+    getSigner(): Promise<DynamicWaasTonSigner>;
+    getWalletClientByAddress({ accountAddress, }: {
+        accountAddress: string;
+    }): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    getTonClient(chainId?: string): TonClient;
+    getActiveAccountAddress(): Promise<string | undefined>;
+    private setActiveAccountAddress;
+    private requireSignedSessionId;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+    getAddress(): Promise<string | undefined>;
+    connect(): Promise<void>;
+    signMessage(message: string): Promise<string>;
+    internalSignMessage(message: string): Promise<string>;
+    endSession(): Promise<void>;
+    signMessageWithContext(_params: {
+        message: string | {
+            raw: string;
+        };
+        context: SignMessageContext;
+    }): Promise<string>;
+    sendTransaction(request: SendTransactionRequest): Promise<string>;
+    private internalSendTransaction;
+    private internalSendUiTransaction;
+    createUiTransaction(from: string): Promise<IUITransaction>;
+}
+export {};