@dynamic-labs/waas-svm 4.83.0 → 4.83.2-alpha.0

package/package.cjs

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

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.83.0";
+var version = "4.83.2-alpha.0";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/waas-svm",
-  "version": "4.83.0",
+  "version": "4.83.2-alpha.0",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,19 +18,19 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs/sdk-api-core": "0.0.964",
-    "@dynamic-labs/embedded-wallet-solana": "4.83.0",
+    "@dynamic-labs/sdk-api-core": "0.0.985",
+    "@dynamic-labs/embedded-wallet-solana": "4.83.2-alpha.0",
     "@solana/web3.js": "1.98.1",
     "eventemitter3": "5.0.1",
     "bs58": "5.0.0",
-    "@dynamic-labs/assert-package-version": "4.83.0",
-    "@dynamic-labs/logger": "4.83.0",
-    "@dynamic-labs/rpc-providers": "4.83.0",
-    "@dynamic-labs/solana-core": "4.83.0",
-    "@dynamic-labs/types": "4.83.0",
-    "@dynamic-labs/utils": "4.83.0",
-    "@dynamic-labs/waas": "4.83.0",
-    "@dynamic-labs/wallet-connector-core": "4.83.0"
+    "@dynamic-labs/assert-package-version": "4.83.2-alpha.0",
+    "@dynamic-labs/logger": "4.83.2-alpha.0",
+    "@dynamic-labs/rpc-providers": "4.83.2-alpha.0",
+    "@dynamic-labs/solana-core": "4.83.2-alpha.0",
+    "@dynamic-labs/types": "4.83.2-alpha.0",
+    "@dynamic-labs/utils": "4.83.2-alpha.0",
+    "@dynamic-labs/waas": "4.83.2-alpha.0",
+    "@dynamic-labs/wallet-connector-core": "4.83.2-alpha.0"
   },
   "peerDependencies": {}
 }

package/src/connector/DynamicWaasSVMConnector.cjs

@@ -191,12 +191,21 @@ class DynamicWaasSVMConnector extends waas.withDynamicWaas(solanaCore.SolanaWall
         });
     }
     internalSignTransaction(transaction_1) {
-        return _tslib.__awaiter(this, arguments, void 0, function* (transaction, { parentTraceId, startTime, } = {}) {
+        return _tslib.__awaiter(this, arguments, void 0, function* (transaction, { parentTraceId, startTime, overrideBlockhash, } = {}) {
             var _a, _b, _c;
             const traceId = parentTraceId || this.generateTraceId();
             const effectiveStartTime = startTime || Date.now();
             // Attempt to sponsor the transaction before signing
             const txToSign = yield this.maybeSponsorTransaction(transaction);
+            if (overrideBlockhash) {
+                if (solanaCore.isVersionedTransaction(txToSign)) {
+                    txToSign.message.recentBlockhash = overrideBlockhash.blockhash;
+                }
+                else {
+                    txToSign.recentBlockhash = overrideBlockhash.blockhash;
+                    txToSign.lastValidBlockHeight = overrideBlockhash.lastValidBlockHeight;
+                }
+            }
             const walletClient = yield this.instrumentAsync({
                 context: { chainName: 'SVM', startTime: effectiveStartTime, traceId },
                 fn: () => _tslib.__awaiter(this, void 0, void 0, function* () { return this.getWaasWalletClient(); }),
@@ -343,16 +352,25 @@ class DynamicWaasSVMConnector extends waas.withDynamicWaas(solanaCore.SolanaWall
     }
     internalSignAndSendTransaction(transaction_1, options_1) {
         return _tslib.__awaiter(this, arguments, void 0, function* (transaction, options, { parentTraceId, startTime, } = {}) {
+            var _a;
             const traceId = parentTraceId || this.generateTraceId();
             const effectiveStartTime = startTime || Date.now();
             if (!this.activeAccountAddress) {
                 throw new Error('Active account address is required');
             }
             const connection = this.getWalletClient();
+            // Refresh the blockhash right before signing so the tx is submitted with
+            // a fresh validity window AND so confirmTransaction's expiration check
+            // operates on the same blockhash that's embedded in the tx.
+            // Use 'finalized' so the blockhash is recognized by every RPC node
+            // (a 'confirmed' blockhash may not yet have propagated to the simulating
+            // node, which surfaces as "Blockhash not found" at sendRawTransaction).
+            const { blockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash('finalized');
             const signedTransaction = yield this.instrumentAsync({
                 context: { chainName: 'SVM', startTime: effectiveStartTime, traceId },
                 fn: () => _tslib.__awaiter(this, void 0, void 0, function* () {
                     return this.internalSignTransaction(transaction, {
+                        overrideBlockhash: { blockhash, lastValidBlockHeight },
                         parentTraceId: traceId,
                         startTime: effectiveStartTime,
                     });
@@ -380,49 +398,53 @@ class DynamicWaasSVMConnector extends waas.withDynamicWaas(solanaCore.SolanaWall
                 operation: 'internalSignAndSendTransaction',
                 resource: 'sendRawTransaction',
             });
-            // Listen for transaction confirmation with timeout
             const confirmationStartTime = Date.now();
-            return new Promise((resolve, reject) => {
-                var _a;
-                const timeout = setTimeout(() => {
-                    const timeoutTotalElapsed = Date.now() - confirmationStartTime;
-                    this.instrument(`[internalSignAndSendTransaction] Transaction timed out - total: ${timeoutTotalElapsed}ms`, {
-                        key: 'internalSignAndSendTransaction-transactionTimedOut',
+            try {
+                const confirmationResult = yield connection.confirmTransaction({
+                    blockhash,
+                    lastValidBlockHeight,
+                    signature,
+                }, (_a = options === null || options === void 0 ? void 0 : options.preflightCommitment) !== null && _a !== void 0 ? _a : 'confirmed');
+                const confirmationEndTime = Date.now();
+                const confirmationStepElapsed = confirmationEndTime - confirmationStartTime;
+                const confirmationTotalElapsed = confirmationEndTime - effectiveStartTime;
+                if (confirmationResult.value.err) {
+                    logger.logger.error(`[internalSignAndSendTransaction] Transaction failed - total: ${confirmationTotalElapsed}ms, step: ${confirmationStepElapsed}ms`, {
+                        accountAddress: this.activeAccountAddress,
+                        error: confirmationResult.value.err,
+                        key: 'internalSignAndSendTransaction-transactionFailed',
                         rpcUrl: connection.rpcEndpoint,
-                        time: timeoutTotalElapsed,
+                        stepTime: confirmationStepElapsed,
+                        time: confirmationTotalElapsed,
                         traceId,
                     });
-                    reject(new Error('Transaction timed out'));
-                }, 60000);
-                connection.onSignature(signature, (result) => {
-                    clearTimeout(timeout);
-                    const confirmationEndTime = Date.now();
-                    const confirmationStepElapsed = confirmationEndTime - confirmationStartTime;
-                    const confirmationTotalElapsed = confirmationEndTime - effectiveStartTime;
-                    if (result.err) {
-                        logger.logger.error(`[internalSignAndSendTransaction] Transaction failed - total: ${confirmationTotalElapsed}ms, step: ${confirmationStepElapsed}ms`, {
-                            accountAddress: this.activeAccountAddress,
-                            error: result.err,
-                            key: 'internalSignAndSendTransaction-transactionFailed',
-                            rpcUrl: connection.rpcEndpoint,
-                            stepTime: confirmationStepElapsed,
-                            time: confirmationTotalElapsed,
-                            traceId,
-                        });
-                        reject(new Error(`Transaction failed: ${result.err}`));
-                    }
-                    else {
-                        this.instrument(`[internalSignAndSendTransaction] Transaction confirmed - total: ${confirmationTotalElapsed}ms, step: ${confirmationStepElapsed}ms`, {
-                            key: 'internalSignAndSendTransaction-transactionSuccess',
-                            rpcUrl: connection.rpcEndpoint,
-                            stepTime: confirmationStepElapsed,
-                            time: confirmationTotalElapsed,
-                            traceId,
-                        });
-                        resolve(signature);
-                    }
-                }, (_a = options === null || options === void 0 ? void 0 : options.preflightCommitment) !== null && _a !== void 0 ? _a : 'confirmed');
-            });
+                    throw new utils.TransactionFailedError(confirmationResult.value.err);
+                }
+                this.instrument(`[internalSignAndSendTransaction] Transaction confirmed - total: ${confirmationTotalElapsed}ms, step: ${confirmationStepElapsed}ms`, {
+                    key: 'internalSignAndSendTransaction-transactionSuccess',
+                    rpcUrl: connection.rpcEndpoint,
+                    stepTime: confirmationStepElapsed,
+                    time: confirmationTotalElapsed,
+                    traceId,
+                });
+            }
+            catch (error) {
+                if (error instanceof utils.TransactionFailedError) {
+                    throw error;
+                }
+                const timeoutTotalElapsed = Date.now() - confirmationStartTime;
+                logger.logger.error(`[internalSignAndSendTransaction] Confirmation timed out - total: ${timeoutTotalElapsed}ms`, {
+                    accountAddress: this.activeAccountAddress,
+                    error,
+                    key: 'internalSignAndSendTransaction-confirmationTimedOut',
+                    rpcUrl: connection.rpcEndpoint,
+                    signature,
+                    time: timeoutTotalElapsed,
+                    traceId,
+                });
+                throw new utils.TransactionConfirmationTimeoutError(signature);
+            }
+            return signature;
         });
     }
     signAndSendTransaction(transaction, options) {

package/src/connector/DynamicWaasSVMConnector.d.ts

@@ -186,9 +186,13 @@ export declare class DynamicWaasSVMConnector extends DynamicWaasSVMConnector_bas
         startTime?: number;
     }): Promise<string>;
     signMessage(message: string): Promise<string>;
-    internalSignTransaction<T extends Transaction | VersionedTransaction>(transaction: T, { parentTraceId, startTime, }?: {
+    internalSignTransaction<T extends Transaction | VersionedTransaction>(transaction: T, { parentTraceId, startTime, overrideBlockhash, }?: {
         parentTraceId?: string;
         startTime?: number;
+        overrideBlockhash?: {
+            blockhash: string;
+            lastValidBlockHeight: number;
+        };
     }): Promise<Transaction | VersionedTransaction>;
     signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<Transaction | VersionedTransaction>;
     internalSignAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<(Transaction | VersionedTransaction)[]>;

package/src/connector/DynamicWaasSVMConnector.js

@@ -4,7 +4,7 @@ import { PublicKey } from '@solana/web3.js';
 import { sponsorSolanaTransaction } from '@dynamic-labs/embedded-wallet-solana';
 import { MFAAction, TokenScope } from '@dynamic-labs/sdk-api-core';
 import { SolanaWalletConnector, isVersionedTransaction, SolanaUiTransaction } from '@dynamic-labs/solana-core';
-import { DynamicError } from '@dynamic-labs/utils';
+import { DynamicError, TransactionFailedError, TransactionConfirmationTimeoutError } from '@dynamic-labs/utils';
 import { withDynamicWaas } from '@dynamic-labs/waas';
 import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
 import { logger } from '../../utils/logger.js';
@@ -187,12 +187,21 @@ class DynamicWaasSVMConnector extends withDynamicWaas(SolanaWalletConnector) {
         });
     }
     internalSignTransaction(transaction_1) {
-        return __awaiter(this, arguments, void 0, function* (transaction, { parentTraceId, startTime, } = {}) {
+        return __awaiter(this, arguments, void 0, function* (transaction, { parentTraceId, startTime, overrideBlockhash, } = {}) {
             var _a, _b, _c;
             const traceId = parentTraceId || this.generateTraceId();
             const effectiveStartTime = startTime || Date.now();
             // Attempt to sponsor the transaction before signing
             const txToSign = yield this.maybeSponsorTransaction(transaction);
+            if (overrideBlockhash) {
+                if (isVersionedTransaction(txToSign)) {
+                    txToSign.message.recentBlockhash = overrideBlockhash.blockhash;
+                }
+                else {
+                    txToSign.recentBlockhash = overrideBlockhash.blockhash;
+                    txToSign.lastValidBlockHeight = overrideBlockhash.lastValidBlockHeight;
+                }
+            }
             const walletClient = yield this.instrumentAsync({
                 context: { chainName: 'SVM', startTime: effectiveStartTime, traceId },
                 fn: () => __awaiter(this, void 0, void 0, function* () { return this.getWaasWalletClient(); }),
@@ -339,16 +348,25 @@ class DynamicWaasSVMConnector extends withDynamicWaas(SolanaWalletConnector) {
     }
     internalSignAndSendTransaction(transaction_1, options_1) {
         return __awaiter(this, arguments, void 0, function* (transaction, options, { parentTraceId, startTime, } = {}) {
+            var _a;
             const traceId = parentTraceId || this.generateTraceId();
             const effectiveStartTime = startTime || Date.now();
             if (!this.activeAccountAddress) {
                 throw new Error('Active account address is required');
             }
             const connection = this.getWalletClient();
+            // Refresh the blockhash right before signing so the tx is submitted with
+            // a fresh validity window AND so confirmTransaction's expiration check
+            // operates on the same blockhash that's embedded in the tx.
+            // Use 'finalized' so the blockhash is recognized by every RPC node
+            // (a 'confirmed' blockhash may not yet have propagated to the simulating
+            // node, which surfaces as "Blockhash not found" at sendRawTransaction).
+            const { blockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash('finalized');
             const signedTransaction = yield this.instrumentAsync({
                 context: { chainName: 'SVM', startTime: effectiveStartTime, traceId },
                 fn: () => __awaiter(this, void 0, void 0, function* () {
                     return this.internalSignTransaction(transaction, {
+                        overrideBlockhash: { blockhash, lastValidBlockHeight },
                         parentTraceId: traceId,
                         startTime: effectiveStartTime,
                     });
@@ -376,49 +394,53 @@ class DynamicWaasSVMConnector extends withDynamicWaas(SolanaWalletConnector) {
                 operation: 'internalSignAndSendTransaction',
                 resource: 'sendRawTransaction',
             });
-            // Listen for transaction confirmation with timeout
             const confirmationStartTime = Date.now();
-            return new Promise((resolve, reject) => {
-                var _a;
-                const timeout = setTimeout(() => {
-                    const timeoutTotalElapsed = Date.now() - confirmationStartTime;
-                    this.instrument(`[internalSignAndSendTransaction] Transaction timed out - total: ${timeoutTotalElapsed}ms`, {
-                        key: 'internalSignAndSendTransaction-transactionTimedOut',
+            try {
+                const confirmationResult = yield connection.confirmTransaction({
+                    blockhash,
+                    lastValidBlockHeight,
+                    signature,
+                }, (_a = options === null || options === void 0 ? void 0 : options.preflightCommitment) !== null && _a !== void 0 ? _a : 'confirmed');
+                const confirmationEndTime = Date.now();
+                const confirmationStepElapsed = confirmationEndTime - confirmationStartTime;
+                const confirmationTotalElapsed = confirmationEndTime - effectiveStartTime;
+                if (confirmationResult.value.err) {
+                    logger.error(`[internalSignAndSendTransaction] Transaction failed - total: ${confirmationTotalElapsed}ms, step: ${confirmationStepElapsed}ms`, {
+                        accountAddress: this.activeAccountAddress,
+                        error: confirmationResult.value.err,
+                        key: 'internalSignAndSendTransaction-transactionFailed',
                         rpcUrl: connection.rpcEndpoint,
-                        time: timeoutTotalElapsed,
+                        stepTime: confirmationStepElapsed,
+                        time: confirmationTotalElapsed,
                         traceId,
                     });
-                    reject(new Error('Transaction timed out'));
-                }, 60000);
-                connection.onSignature(signature, (result) => {
-                    clearTimeout(timeout);
-                    const confirmationEndTime = Date.now();
-                    const confirmationStepElapsed = confirmationEndTime - confirmationStartTime;
-                    const confirmationTotalElapsed = confirmationEndTime - effectiveStartTime;
-                    if (result.err) {
-                        logger.error(`[internalSignAndSendTransaction] Transaction failed - total: ${confirmationTotalElapsed}ms, step: ${confirmationStepElapsed}ms`, {
-                            accountAddress: this.activeAccountAddress,
-                            error: result.err,
-                            key: 'internalSignAndSendTransaction-transactionFailed',
-                            rpcUrl: connection.rpcEndpoint,
-                            stepTime: confirmationStepElapsed,
-                            time: confirmationTotalElapsed,
-                            traceId,
-                        });
-                        reject(new Error(`Transaction failed: ${result.err}`));
-                    }
-                    else {
-                        this.instrument(`[internalSignAndSendTransaction] Transaction confirmed - total: ${confirmationTotalElapsed}ms, step: ${confirmationStepElapsed}ms`, {
-                            key: 'internalSignAndSendTransaction-transactionSuccess',
-                            rpcUrl: connection.rpcEndpoint,
-                            stepTime: confirmationStepElapsed,
-                            time: confirmationTotalElapsed,
-                            traceId,
-                        });
-                        resolve(signature);
-                    }
-                }, (_a = options === null || options === void 0 ? void 0 : options.preflightCommitment) !== null && _a !== void 0 ? _a : 'confirmed');
-            });
+                    throw new TransactionFailedError(confirmationResult.value.err);
+                }
+                this.instrument(`[internalSignAndSendTransaction] Transaction confirmed - total: ${confirmationTotalElapsed}ms, step: ${confirmationStepElapsed}ms`, {
+                    key: 'internalSignAndSendTransaction-transactionSuccess',
+                    rpcUrl: connection.rpcEndpoint,
+                    stepTime: confirmationStepElapsed,
+                    time: confirmationTotalElapsed,
+                    traceId,
+                });
+            }
+            catch (error) {
+                if (error instanceof TransactionFailedError) {
+                    throw error;
+                }
+                const timeoutTotalElapsed = Date.now() - confirmationStartTime;
+                logger.error(`[internalSignAndSendTransaction] Confirmation timed out - total: ${timeoutTotalElapsed}ms`, {
+                    accountAddress: this.activeAccountAddress,
+                    error,
+                    key: 'internalSignAndSendTransaction-confirmationTimedOut',
+                    rpcUrl: connection.rpcEndpoint,
+                    signature,
+                    time: timeoutTotalElapsed,
+                    traceId,
+                });
+                throw new TransactionConfirmationTimeoutError(signature);
+            }
+            return signature;
         });
     }
     signAndSendTransaction(transaction, options) {