@dynamic-labs/ethereum-gasless-core 5.3.1 → 5.4.0

package/CHANGELOG.md

@@ -1,4 +1,43 @@
 
+## [5.4.0](https://github.com/dynamic-labs/dynamic-auth/compare/v5.3.2...v5.4.0) (2026-08-25)
+
+
+### Features
+
+* **aleo:** wire up signMessage on the WaaS Aleo connector ([#12235](https://github.com/dynamic-labs/dynamic-auth/issues/12235)) ([e56cbf5](https://github.com/dynamic-labs/dynamic-auth/commit/e56cbf5546bdcc21ce916dece43ae36dcea9b808))
+* **waas:** thread isRawScalarImport through importPrivateKey for ed25519 chains ([#12220](https://github.com/dynamic-labs/dynamic-auth/issues/12220)) ([ced9efa](https://github.com/dynamic-labs/dynamic-auth/commit/ced9efac5fa5a4a1280383419f56fe22733722cd))
+* **webview:** add policies message contract and controller ([#12248](https://github.com/dynamic-labs/dynamic-auth/issues/12248)) ([8557c1e](https://github.com/dynamic-labs/dynamic-auth/commit/8557c1ed3861e12f1f06b2bb610184813b577daa))
+
+
+### Bug Fixes
+
+* **bitcoin:** pass the wallet's address type when signing ([#12265](https://github.com/dynamic-labs/dynamic-auth/issues/12265)) ([b8a8eab](https://github.com/dynamic-labs/dynamic-auth/commit/b8a8eab7e4cc294cc307fb10ea6814e76111a274))
+* remediate high-severity tar vulnerability and prune a dead override ([#12268](https://github.com/dynamic-labs/dynamic-auth/issues/12268)) ([6b1b343](https://github.com/dynamic-labs/dynamic-auth/commit/6b1b343e7947e8da30012446677e342ae9bfe14a))
+* **waas-svm:** fix retry-classification and environmentId gaps in [#12240](https://github.com/dynamic-labs/dynamic-auth/issues/12240) ([#12247](https://github.com/dynamic-labs/dynamic-auth/issues/12247)) ([e79cecc](https://github.com/dynamic-labs/dynamic-auth/commit/e79ceccd424c48c3a7f45fdd6ea288c269ac0171))
+* **wallet-connect:** reopen WalletConnect IndexedDB when the browser closes the connection ([#12262](https://github.com/dynamic-labs/dynamic-auth/issues/12262)) ([1a20dde](https://github.com/dynamic-labs/dynamic-auth/commit/1a20ddeaeec590ae3390c9e47ef3c14738379b83))
+
+
+### Performance Improvements
+
+* **ethereum-gasless-core:** parallel 7702 auth signing and long-poll sponsored-tx status ([#12225](https://github.com/dynamic-labs/dynamic-auth/issues/12225)) ([53ca916](https://github.com/dynamic-labs/dynamic-auth/commit/53ca91668f8dd839c52d55a0e5d7bb5257f7f415))
+
+### [5.3.2](https://github.com/dynamic-labs/dynamic-auth/compare/v5.3.1...v5.3.2) (2026-08-19)
+
+
+### Features
+
+* **bitcoin:** add allowedSighash to embedded wallet signPsbt ([#12233](https://github.com/dynamic-labs/dynamic-auth/issues/12233)) ([d0ff829](https://github.com/dynamic-labs/dynamic-auth/commit/d0ff8291a3d1771d5ca356172acc10af94349b15))
+* **bitcoin:** forward signingIndexes to embedded PSBT signing ([#12211](https://github.com/dynamic-labs/dynamic-auth/issues/12211)) ([733da3d](https://github.com/dynamic-labs/dynamic-auth/commit/733da3d32f39a9ae6d813df84fcff6350ba12eb5))
+* expose createOfflineRecoveryShares SDK function in webview and legacy client ([#12239](https://github.com/dynamic-labs/dynamic-auth/issues/12239)) ([c8056e8](https://github.com/dynamic-labs/dynamic-auth/commit/c8056e8d5a1c66ac0146b046bc7cc198de118f0b))
+
+
+### Bug Fixes
+
+* **bitcoin:** parse PSBTs with the active network's address encoding ([#12219](https://github.com/dynamic-labs/dynamic-auth/issues/12219)) ([8b151e2](https://github.com/dynamic-labs/dynamic-auth/commit/8b151e23440094cfa0d48728e1d0f19de567ca05))
+* **bitcoin:** stop ensureActiveAccount from resetting a switched network ([#12215](https://github.com/dynamic-labs/dynamic-auth/issues/12215)) ([86668b7](https://github.com/dynamic-labs/dynamic-auth/commit/86668b79d23cd89b7e96518551cdaecab7dd5ce3))
+* remediate high-severity dependency vulnerabilities ([#12238](https://github.com/dynamic-labs/dynamic-auth/issues/12238)) ([a4fc78c](https://github.com/dynamic-labs/dynamic-auth/commit/a4fc78ca27ee44ce6a1038c4e0d07f55528b4994))
+* **waas-svm:** retry SVM gas sponsorship before falling back, then throw ([#12240](https://github.com/dynamic-labs/dynamic-auth/issues/12240)) ([f599a7a](https://github.com/dynamic-labs/dynamic-auth/commit/f599a7af55727e06373772acf574ee7c43e56bbb))
+
 ### [5.3.1](https://github.com/dynamic-labs/dynamic-auth/compare/v5.3.0...v5.3.1) (2026-08-14)
 
 ## [5.3.0](https://github.com/dynamic-labs/dynamic-auth/compare/v5.2.0...v5.3.0) (2026-08-12)

package/package.cjs

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

package/package.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/ethereum-gasless-core",
-  "version": "5.3.1",
+  "version": "5.4.0",
   "main": "./src/index.cjs",
   "module": "./src/index.js",
   "types": "./src/index.d.ts",
@@ -14,8 +14,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@dynamic-labs/sdk-api-core": "0.0.1118",
-    "@dynamic-labs/assert-package-version": "5.3.1"
+    "@dynamic-labs/sdk-api-core": "0.12.0",
+    "@dynamic-labs/assert-package-version": "5.4.0"
   },
   "peerDependencies": {
     "viem": "^2.45.3"

package/src/lib/getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.cjs

@@ -13,12 +13,13 @@ var SponsorTransactionError = require('../errors/SponsorTransactionError/Sponsor
  * as the building block for custom polling flows; for the common "wait until
  * done" case prefer `waitForSponsoredTransaction`.
  */
-const getEVMSponsoredTransactionStatus = async ({ requestId }, { sdkApi, environmentId }) => {
+const getEVMSponsoredTransactionStatus = async ({ requestId, waitSeconds }, { sdkApi, environmentId }) => {
     let data;
     try {
         data = await sdkApi.getEVMSponsoredTransactionStatus({
             environmentId,
             requestId,
+            ...(waitSeconds ? { wait: waitSeconds } : {}),
         });
     }
     catch (error) {

package/src/lib/getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.d.ts

@@ -2,6 +2,12 @@ import type { EvmGaslessApiDeps, SponsoredTransactionStatusResult } from '../typ
 type GetEVMSponsoredTransactionStatusParams = {
     /** The request ID returned by `relaySponsoredTransaction` / `sendSponsoredTransaction`. */
     requestId: string;
+    /**
+     * Seconds to let the API hold the response open while the transaction is
+     * still unresolved, so the hash comes back as soon as it exists instead of on
+     * a later call. Omitted or `0` responds immediately.
+     */
+    waitSeconds?: number;
 };
 /**
  * Fetches the current relay state for a sponsored EVM transaction.
@@ -11,5 +17,5 @@ type GetEVMSponsoredTransactionStatusParams = {
  * as the building block for custom polling flows; for the common "wait until
  * done" case prefer `waitForSponsoredTransaction`.
  */
-export declare const getEVMSponsoredTransactionStatus: ({ requestId }: GetEVMSponsoredTransactionStatusParams, { sdkApi, environmentId }: EvmGaslessApiDeps) => Promise<SponsoredTransactionStatusResult>;
+export declare const getEVMSponsoredTransactionStatus: ({ requestId, waitSeconds }: GetEVMSponsoredTransactionStatusParams, { sdkApi, environmentId }: EvmGaslessApiDeps) => Promise<SponsoredTransactionStatusResult>;
 export {};

package/src/lib/getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.js

@@ -9,12 +9,13 @@ import { SponsorTransactionError } from '../errors/SponsorTransactionError/Spons
  * as the building block for custom polling flows; for the common "wait until
  * done" case prefer `waitForSponsoredTransaction`.
  */
-const getEVMSponsoredTransactionStatus = async ({ requestId }, { sdkApi, environmentId }) => {
+const getEVMSponsoredTransactionStatus = async ({ requestId, waitSeconds }, { sdkApi, environmentId }) => {
     let data;
     try {
         data = await sdkApi.getEVMSponsoredTransactionStatus({
             environmentId,
             requestId,
+            ...(waitSeconds ? { wait: waitSeconds } : {}),
         });
     }
     catch (error) {

package/src/lib/signSponsoredTransaction/signSponsoredTransaction.cjs

@@ -20,30 +20,36 @@ var toSerializedAuthorization = require('../toSerializedAuthorization/toSerializ
 const signSponsoredTransaction = async ({ authorization, autoDelegate = true, calls, nonce: providedNonce, validForSeconds = constants.DEFAULT_VALID_FOR_SECONDS, }, deps) => {
     const { chainId, walletClient } = deps;
     const walletAddress = walletClient.account.address;
-    const resolvedAuthorization = await resolveAuthorization.resolveAuthorization({ authorization, autoDelegate, walletAddress }, deps);
-    const nonce = providedNonce ?? (await generateIntentNonce.generateIntentNonce({ walletAddress }, deps));
-    const deadline = BigInt(Math.floor(Date.now() / 1000) + validForSeconds);
-    const { relayerAddress } = await getAvailableEvmGaslessRelayer.getAvailableEvmGaslessRelayer({ chainId }, deps);
-    const signature = await walletClient.signTypedData({
-        account: walletClient.account,
-        domain: {
-            chainId,
-            verifyingContract: constants.DELEGATION_CONTRACT_ADDRESS,
-        },
-        message: {
-            calls: calls.map((c) => ({
-                data: c.data,
-                target: c.target,
-                value: c.value,
-            })),
-            deadline,
-            mode: constants.BATCH_CALL_OPDATA_AUTH_MODE,
-            nonce,
-            relayer: relayerAddress,
-        },
-        primaryType: 'AuthorizedExecutions',
-        types: constants.AUTHORIZED_EXECUTIONS_TYPES,
-    });
+    const authPromise = resolveAuthorization.resolveAuthorization({ authorization, autoDelegate, walletAddress }, deps);
+    const signPromise = (async () => {
+        const [nonce, { relayerAddress }] = await Promise.all([
+            providedNonce ?? generateIntentNonce.generateIntentNonce({ walletAddress }, deps),
+            getAvailableEvmGaslessRelayer.getAvailableEvmGaslessRelayer({ chainId }, deps),
+        ]);
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + validForSeconds);
+        const signature = await walletClient.signTypedData({
+            account: walletClient.account,
+            domain: {
+                chainId,
+                verifyingContract: constants.DELEGATION_CONTRACT_ADDRESS,
+            },
+            message: {
+                calls: calls.map((c) => ({
+                    data: c.data,
+                    target: c.target,
+                    value: c.value,
+                })),
+                deadline,
+                mode: constants.BATCH_CALL_OPDATA_AUTH_MODE,
+                nonce,
+                relayer: relayerAddress,
+            },
+            primaryType: 'AuthorizedExecutions',
+            types: constants.AUTHORIZED_EXECUTIONS_TYPES,
+        });
+        return { deadline, nonce, relayerAddress, signature };
+    })();
+    const [resolvedAuthorization, { deadline, nonce, relayerAddress, signature },] = await Promise.all([authPromise, signPromise]);
     return {
         authorization: resolvedAuthorization
             ? toSerializedAuthorization.toSerializedAuthorization(resolvedAuthorization)

package/src/lib/signSponsoredTransaction/signSponsoredTransaction.js

@@ -16,30 +16,36 @@ import { toSerializedAuthorization } from '../toSerializedAuthorization/toSerial
 const signSponsoredTransaction = async ({ authorization, autoDelegate = true, calls, nonce: providedNonce, validForSeconds = DEFAULT_VALID_FOR_SECONDS, }, deps) => {
     const { chainId, walletClient } = deps;
     const walletAddress = walletClient.account.address;
-    const resolvedAuthorization = await resolveAuthorization({ authorization, autoDelegate, walletAddress }, deps);
-    const nonce = providedNonce ?? (await generateIntentNonce({ walletAddress }, deps));
-    const deadline = BigInt(Math.floor(Date.now() / 1000) + validForSeconds);
-    const { relayerAddress } = await getAvailableEvmGaslessRelayer({ chainId }, deps);
-    const signature = await walletClient.signTypedData({
-        account: walletClient.account,
-        domain: {
-            chainId,
-            verifyingContract: DELEGATION_CONTRACT_ADDRESS,
-        },
-        message: {
-            calls: calls.map((c) => ({
-                data: c.data,
-                target: c.target,
-                value: c.value,
-            })),
-            deadline,
-            mode: BATCH_CALL_OPDATA_AUTH_MODE,
-            nonce,
-            relayer: relayerAddress,
-        },
-        primaryType: 'AuthorizedExecutions',
-        types: AUTHORIZED_EXECUTIONS_TYPES,
-    });
+    const authPromise = resolveAuthorization({ authorization, autoDelegate, walletAddress }, deps);
+    const signPromise = (async () => {
+        const [nonce, { relayerAddress }] = await Promise.all([
+            providedNonce ?? generateIntentNonce({ walletAddress }, deps),
+            getAvailableEvmGaslessRelayer({ chainId }, deps),
+        ]);
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + validForSeconds);
+        const signature = await walletClient.signTypedData({
+            account: walletClient.account,
+            domain: {
+                chainId,
+                verifyingContract: DELEGATION_CONTRACT_ADDRESS,
+            },
+            message: {
+                calls: calls.map((c) => ({
+                    data: c.data,
+                    target: c.target,
+                    value: c.value,
+                })),
+                deadline,
+                mode: BATCH_CALL_OPDATA_AUTH_MODE,
+                nonce,
+                relayer: relayerAddress,
+            },
+            primaryType: 'AuthorizedExecutions',
+            types: AUTHORIZED_EXECUTIONS_TYPES,
+        });
+        return { deadline, nonce, relayerAddress, signature };
+    })();
+    const [resolvedAuthorization, { deadline, nonce, relayerAddress, signature },] = await Promise.all([authPromise, signPromise]);
     return {
         authorization: resolvedAuthorization
             ? toSerializedAuthorization(resolvedAuthorization)

package/src/lib/waitForSponsoredTransaction/waitForSponsoredTransaction.cjs

@@ -6,30 +6,42 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var SponsorTransactionError = require('../errors/SponsorTransactionError/SponsorTransactionError.cjs');
 var getEVMSponsoredTransactionStatus = require('../getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.cjs');
 
-const POLL_INTERVAL_MS = 2000;
 const TIMEOUT_MS = 60000;
-const MAX_POLLING_ATTEMPTS = TIMEOUT_MS / POLL_INTERVAL_MS;
+const MAX_WAIT_SECONDS = 10;
+// Floor between requests. The API answers immediately instead of holding when
+// a transaction already has too many waiters, and the loop would spin against
+// that without this.
+const MIN_REQUEST_INTERVAL_MS = 1000;
 const TERMINAL_FAILURE_STATUSES = new Set([
     'failure',
 ]);
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
- * Polls `getEVMSponsoredTransactionStatus` until the relay reports the
- * transaction has been included on-chain, then returns the transaction hash.
+ * Waits until the relay reports the transaction has been included on-chain,
+ * then returns the transaction hash.
  *
- * Throws if the relay returns a terminal failure or if polling times out.
+ * Each request asks the API to hold the response open until the transaction
+ * resolves, so the hash comes back as soon as it exists.
  */
 const waitForSponsoredTransaction = async ({ requestId }, deps) => {
-    for (let attempt = 0; attempt < MAX_POLLING_ATTEMPTS; attempt++) {
-        const result = await getEVMSponsoredTransactionStatus.getEVMSponsoredTransactionStatus({ requestId }, deps);
+    const deadline = Date.now() + TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const startedAt = Date.now();
+        // Never ask for a hold that would outlive the deadline; under a second
+        // left means asking for none at all. The clamp matters because the
+        // deadline can pass between the loop check and here.
+        const waitSeconds = Math.max(0, Math.min(MAX_WAIT_SECONDS, Math.floor((deadline - startedAt) / 1000)));
+        const result = await getEVMSponsoredTransactionStatus.getEVMSponsoredTransactionStatus({ requestId, waitSeconds }, deps);
         if (TERMINAL_FAILURE_STATUSES.has(result.status)) {
             throw new SponsorTransactionError.SponsorTransactionError(null, result.errorMessage);
         }
         if (result.transactionHash) {
             return { transactionHash: result.transactionHash };
         }
-        if (attempt < MAX_POLLING_ATTEMPTS - 1) {
-            await sleep(POLL_INTERVAL_MS);
+        const elapsed = Date.now() - startedAt;
+        const remaining = deadline - Date.now();
+        if (remaining > 0 && elapsed < MIN_REQUEST_INTERVAL_MS) {
+            await sleep(Math.min(MIN_REQUEST_INTERVAL_MS - elapsed, remaining));
         }
     }
     throw new SponsorTransactionError.SponsorTransactionError(null, `Timed out waiting for sponsored transaction ${requestId}`);

package/src/lib/waitForSponsoredTransaction/waitForSponsoredTransaction.d.ts

@@ -5,10 +5,11 @@ type WaitForSponsoredTransactionParams = {
     requestId: string;
 };
 /**
- * Polls `getEVMSponsoredTransactionStatus` until the relay reports the
- * transaction has been included on-chain, then returns the transaction hash.
+ * Waits until the relay reports the transaction has been included on-chain,
+ * then returns the transaction hash.
  *
- * Throws if the relay returns a terminal failure or if polling times out.
+ * Each request asks the API to hold the response open until the transaction
+ * resolves, so the hash comes back as soon as it exists.
  */
 export declare const waitForSponsoredTransaction: ({ requestId }: WaitForSponsoredTransactionParams, deps: EvmGaslessApiDeps) => Promise<{
     transactionHash: Hex;

package/src/lib/waitForSponsoredTransaction/waitForSponsoredTransaction.js

@@ -2,30 +2,42 @@
 import { SponsorTransactionError } from '../errors/SponsorTransactionError/SponsorTransactionError.js';
 import { getEVMSponsoredTransactionStatus } from '../getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.js';
 
-const POLL_INTERVAL_MS = 2000;
 const TIMEOUT_MS = 60000;
-const MAX_POLLING_ATTEMPTS = TIMEOUT_MS / POLL_INTERVAL_MS;
+const MAX_WAIT_SECONDS = 10;
+// Floor between requests. The API answers immediately instead of holding when
+// a transaction already has too many waiters, and the loop would spin against
+// that without this.
+const MIN_REQUEST_INTERVAL_MS = 1000;
 const TERMINAL_FAILURE_STATUSES = new Set([
     'failure',
 ]);
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
- * Polls `getEVMSponsoredTransactionStatus` until the relay reports the
- * transaction has been included on-chain, then returns the transaction hash.
+ * Waits until the relay reports the transaction has been included on-chain,
+ * then returns the transaction hash.
  *
- * Throws if the relay returns a terminal failure or if polling times out.
+ * Each request asks the API to hold the response open until the transaction
+ * resolves, so the hash comes back as soon as it exists.
  */
 const waitForSponsoredTransaction = async ({ requestId }, deps) => {
-    for (let attempt = 0; attempt < MAX_POLLING_ATTEMPTS; attempt++) {
-        const result = await getEVMSponsoredTransactionStatus({ requestId }, deps);
+    const deadline = Date.now() + TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const startedAt = Date.now();
+        // Never ask for a hold that would outlive the deadline; under a second
+        // left means asking for none at all. The clamp matters because the
+        // deadline can pass between the loop check and here.
+        const waitSeconds = Math.max(0, Math.min(MAX_WAIT_SECONDS, Math.floor((deadline - startedAt) / 1000)));
+        const result = await getEVMSponsoredTransactionStatus({ requestId, waitSeconds }, deps);
         if (TERMINAL_FAILURE_STATUSES.has(result.status)) {
             throw new SponsorTransactionError(null, result.errorMessage);
         }
         if (result.transactionHash) {
             return { transactionHash: result.transactionHash };
         }
-        if (attempt < MAX_POLLING_ATTEMPTS - 1) {
-            await sleep(POLL_INTERVAL_MS);
+        const elapsed = Date.now() - startedAt;
+        const remaining = deadline - Date.now();
+        if (remaining > 0 && elapsed < MIN_REQUEST_INTERVAL_MS) {
+            await sleep(Math.min(MIN_REQUEST_INTERVAL_MS - elapsed, remaining));
         }
     }
     throw new SponsorTransactionError(null, `Timed out waiting for sponsored transaction ${requestId}`);