@arkade-os/sdk 0.4.16 → 0.4.17

package/dist/cjs/contracts/contractManager.js

@@ -25,8 +25,6 @@ const DEFAULT_PAGE_SIZE = 500;
  * const manager = await ContractManager.create({
  *   indexerProvider: wallet.indexerProvider,
  *   contractRepository: wallet.contractRepository,
- *   walletRepository: wallet.walletRepository,
- *   getDefaultAddress: () => wallet.getAddress(),
  * });
  *
  * // Create a new VHTLC contract
@@ -90,7 +88,7 @@ class ContractManager {
         const contracts = await this.config.contractRepository.getContracts();
         // Delta-sync: fetch only virtual outputs that changed since the last cursor,
         // falling back to a full bootstrap for scripts seen for the first time.
-        await this.deltaSyncContracts(contracts);
+        await this.deltaSyncContracts(contracts, undefined, true);
         // Reconcile the pending frontier: fetch all not-yet-finalized virtual outputs
         // to catch any that the delta window may have missed.
         if (contracts.length > 0) {
@@ -423,21 +421,39 @@ class ContractManager {
         if (contracts.length === 0) {
             return new Map();
         }
-        return await this.fetchContractVxosFromIndexer(contracts, false, pageSize);
+        // Deduplicate concurrent callers against an in-flight fetch so we don't
+        // issue redundant round-trips. Once the fetch settles we clear the
+        // reference so the next call triggers a fresh fetch.
+        // TODO: can be removed once we fix the persistence layer (address vs scripts)
+        if (this.syncVtxosCallInflight) {
+            return this.syncVtxosCallInflight;
+        }
+        this.syncVtxosCallInflight = this.fetchContractVxosFromIndexer(contracts, true, pageSize).finally(() => {
+            this.syncVtxosCallInflight = undefined;
+        });
+        return this.syncVtxosCallInflight;
     }
     /**
      * Incrementally sync virtual outputs for the given contracts.
      * Uses per-script cursors to fetch only what changed since the last sync.
      * Scripts without a cursor are bootstrapped with a full fetch.
      */
-    async deltaSyncContracts(contracts, pageSize) {
+    async deltaSyncContracts(contracts, pageSize, force) {
         if (contracts.length === 0)
             return new Map();
+        // If forced, we are treating all contracts as boostrapped and we clean the VTXO list
+        if (force === true) {
+            await Promise.all(contracts.map((contract) => this.config.walletRepository.deleteVtxos(contract.address)));
+        }
         const cursors = await (0, syncCursors_1.getAllSyncCursors)(this.config.walletRepository);
         // Partition into bootstrap (no cursor) and delta (has cursor) groups.
         const bootstrap = [];
         const delta = [];
         for (const c of contracts) {
+            if (force) {
+                bootstrap.push(c);
+                continue;
+            }
             if (cursors[c.script] !== undefined) {
                 delta.push(c);
             }

package/dist/cjs/wallet/wallet.js

@@ -39,6 +39,10 @@ const contractManager_1 = require("../contracts/contractManager");
 const handlers_1 = require("../contracts/handlers");
 const helpers_1 = require("../contracts/handlers/helpers");
 const syncCursors_1 = require("../utils/syncCursors");
+// Hardcoded unilateral exit delay for mainnet (~7 days in seconds).
+// Pinned here so that address derivation stays stable for existing mainnet
+// wallets even after the server lowers the delay it advertises.
+const MAINNET_UNILATERAL_EXIT_DELAY = 605184n;
 /**
  * Type guard function to check if an identity has a toReadonly method.
  */
@@ -134,10 +138,16 @@ class ReadonlyWallet {
                 throw new Error("invalid exitTimelock");
             }
         }
+        // On mainnet, pin the unilateral exit delay to the historical value so
+        // that addresses derived by existing wallets remain stable even if the
+        // server starts advertising a shorter delay.
+        const unilateralExitDelay = info.network === "bitcoin"
+            ? MAINNET_UNILATERAL_EXIT_DELAY
+            : info.unilateralExitDelay;
         // create unilateral exit timelock
         const exitTimelock = config.exitTimelock ?? {
-            value: info.unilateralExitDelay,
-            type: info.unilateralExitDelay < 512n ? "blocks" : "seconds",
+            value: unilateralExitDelay,
+            type: unilateralExitDelay < 512n ? "blocks" : "seconds",
         };
         // validate boarding timelock passed in config if any
         if (config.boardingTimelock) {
@@ -292,14 +302,10 @@ class ReadonlyWallet {
      * @param filter - Optional flags controlling whether recoverable or unrolled VTXOs are included
      */
     async getVtxos(filter) {
-        const { isDelta, fetchedExtended, address } = await this.syncVtxos();
         const f = filter ?? { withRecoverable: true, withUnrolled: false };
-        // For delta syncs, read the full merged set from cache so old
-        // Virtual outputs that weren't in the delta are still returned.
-        const vtxos = isDelta
-            ? await this.walletRepository.getVtxos(address)
-            : fetchedExtended;
-        return vtxos.filter((vtxo) => {
+        const contractManager = await this.getContractManager();
+        const contractsWithVtxos = await contractManager.getContractsWithVtxos();
+        return contractsWithVtxos.flatMap(({ vtxos }) => vtxos.filter((vtxo) => {
             if ((0, _1.isSpendable)(vtxo)) {
                 if (!f.withRecoverable &&
                     ((0, _1.isRecoverable)(vtxo) || (0, _1.isExpired)(vtxo))) {
@@ -308,7 +314,7 @@ class ReadonlyWallet {
                 return true;
             }
             return !!(f.withUnrolled && vtxo.isUnrolled);
-        });
+        }));
     }
     /**
      * Return wallet transaction history derived from Arkade state and boarding transactions.
@@ -778,7 +784,6 @@ class ReadonlyWallet {
             indexerProvider: this.indexerProvider,
             contractRepository: this.contractRepository,
             walletRepository: this.walletRepository,
-            getDefaultAddress: () => this.getAddress(),
             watcherConfig: this.watcherConfig,
         });
         // Register the wallet's current address as a contract

package/dist/esm/contracts/contractManager.js

@@ -22,8 +22,6 @@ const DEFAULT_PAGE_SIZE = 500;
  * const manager = await ContractManager.create({
  *   indexerProvider: wallet.indexerProvider,
  *   contractRepository: wallet.contractRepository,
- *   walletRepository: wallet.walletRepository,
- *   getDefaultAddress: () => wallet.getAddress(),
  * });
  *
  * // Create a new VHTLC contract
@@ -87,7 +85,7 @@ export class ContractManager {
         const contracts = await this.config.contractRepository.getContracts();
         // Delta-sync: fetch only virtual outputs that changed since the last cursor,
         // falling back to a full bootstrap for scripts seen for the first time.
-        await this.deltaSyncContracts(contracts);
+        await this.deltaSyncContracts(contracts, undefined, true);
         // Reconcile the pending frontier: fetch all not-yet-finalized virtual outputs
         // to catch any that the delta window may have missed.
         if (contracts.length > 0) {
@@ -420,21 +418,39 @@ export class ContractManager {
         if (contracts.length === 0) {
             return new Map();
         }
-        return await this.fetchContractVxosFromIndexer(contracts, false, pageSize);
+        // Deduplicate concurrent callers against an in-flight fetch so we don't
+        // issue redundant round-trips. Once the fetch settles we clear the
+        // reference so the next call triggers a fresh fetch.
+        // TODO: can be removed once we fix the persistence layer (address vs scripts)
+        if (this.syncVtxosCallInflight) {
+            return this.syncVtxosCallInflight;
+        }
+        this.syncVtxosCallInflight = this.fetchContractVxosFromIndexer(contracts, true, pageSize).finally(() => {
+            this.syncVtxosCallInflight = undefined;
+        });
+        return this.syncVtxosCallInflight;
     }
     /**
      * Incrementally sync virtual outputs for the given contracts.
      * Uses per-script cursors to fetch only what changed since the last sync.
      * Scripts without a cursor are bootstrapped with a full fetch.
      */
-    async deltaSyncContracts(contracts, pageSize) {
+    async deltaSyncContracts(contracts, pageSize, force) {
         if (contracts.length === 0)
             return new Map();
+        // If forced, we are treating all contracts as boostrapped and we clean the VTXO list
+        if (force === true) {
+            await Promise.all(contracts.map((contract) => this.config.walletRepository.deleteVtxos(contract.address)));
+        }
         const cursors = await getAllSyncCursors(this.config.walletRepository);
         // Partition into bootstrap (no cursor) and delta (has cursor) groups.
         const bootstrap = [];
         const delta = [];
         for (const c of contracts) {
+            if (force) {
+                bootstrap.push(c);
+                continue;
+            }
             if (cursors[c.script] !== undefined) {
                 delta.push(c);
             }

package/dist/esm/wallet/wallet.js

@@ -34,6 +34,10 @@ import { ContractManager } from '../contracts/contractManager.js';
 import { contractHandlers } from '../contracts/handlers/index.js';
 import { timelockToSequence } from '../contracts/handlers/helpers.js';
 import { advanceSyncCursors, clearSyncCursors, computeSyncWindow, cursorCutoff, getAllSyncCursors, updateWalletState, } from '../utils/syncCursors.js';
+// Hardcoded unilateral exit delay for mainnet (~7 days in seconds).
+// Pinned here so that address derivation stays stable for existing mainnet
+// wallets even after the server lowers the delay it advertises.
+const MAINNET_UNILATERAL_EXIT_DELAY = 605184n;
 /**
  * Type guard function to check if an identity has a toReadonly method.
  */
@@ -129,10 +133,16 @@ export class ReadonlyWallet {
                 throw new Error("invalid exitTimelock");
             }
         }
+        // On mainnet, pin the unilateral exit delay to the historical value so
+        // that addresses derived by existing wallets remain stable even if the
+        // server starts advertising a shorter delay.
+        const unilateralExitDelay = info.network === "bitcoin"
+            ? MAINNET_UNILATERAL_EXIT_DELAY
+            : info.unilateralExitDelay;
         // create unilateral exit timelock
         const exitTimelock = config.exitTimelock ?? {
-            value: info.unilateralExitDelay,
-            type: info.unilateralExitDelay < 512n ? "blocks" : "seconds",
+            value: unilateralExitDelay,
+            type: unilateralExitDelay < 512n ? "blocks" : "seconds",
         };
         // validate boarding timelock passed in config if any
         if (config.boardingTimelock) {
@@ -287,14 +297,10 @@ export class ReadonlyWallet {
      * @param filter - Optional flags controlling whether recoverable or unrolled VTXOs are included
      */
     async getVtxos(filter) {
-        const { isDelta, fetchedExtended, address } = await this.syncVtxos();
         const f = filter ?? { withRecoverable: true, withUnrolled: false };
-        // For delta syncs, read the full merged set from cache so old
-        // Virtual outputs that weren't in the delta are still returned.
-        const vtxos = isDelta
-            ? await this.walletRepository.getVtxos(address)
-            : fetchedExtended;
-        return vtxos.filter((vtxo) => {
+        const contractManager = await this.getContractManager();
+        const contractsWithVtxos = await contractManager.getContractsWithVtxos();
+        return contractsWithVtxos.flatMap(({ vtxos }) => vtxos.filter((vtxo) => {
             if (isSpendable(vtxo)) {
                 if (!f.withRecoverable &&
                     (isRecoverable(vtxo) || isExpired(vtxo))) {
@@ -303,7 +309,7 @@ export class ReadonlyWallet {
                 return true;
             }
             return !!(f.withUnrolled && vtxo.isUnrolled);
-        });
+        }));
     }
     /**
      * Return wallet transaction history derived from Arkade state and boarding transactions.
@@ -773,7 +779,6 @@ export class ReadonlyWallet {
             indexerProvider: this.indexerProvider,
             contractRepository: this.contractRepository,
             walletRepository: this.walletRepository,
-            getDefaultAddress: () => this.getAddress(),
             watcherConfig: this.watcherConfig,
         });
         // Register the wallet's current address as a contract

package/dist/types/contracts/contractManager.d.ts

@@ -118,8 +118,6 @@ export interface ContractManagerConfig {
     contractRepository: ContractRepository;
     /** The wallet repository for virtual output storage (single source of truth) */
     walletRepository: WalletRepository;
-    /** Function to get the wallet's default Arkade address */
-    getDefaultAddress: () => Promise<string>;
     /** Watcher configuration */
     watcherConfig?: Partial<ContractWatcherConfig>;
 }
@@ -148,8 +146,6 @@ export type CreateContractParams = Omit<Contract, "createdAt" | "state"> & {
  * const manager = await ContractManager.create({
  *   indexerProvider: wallet.indexerProvider,
  *   contractRepository: wallet.contractRepository,
- *   walletRepository: wallet.walletRepository,
- *   getDefaultAddress: () => wallet.getAddress(),
  * });
  *
  * // Create a new VHTLC contract
@@ -185,6 +181,7 @@ export declare class ContractManager implements IContractManager {
     private initialized;
     private eventCallbacks;
     private stopWatcherFn?;
+    private syncVtxosCallInflight?;
     private constructor();
     /**
      * Static factory method for creating a new ContractManager.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.4.16",
+  "version": "0.4.17",
   "description": "TypeScript SDK for building Bitcoin wallets using the Arkade protocol",
   "type": "module",
   "main": "./dist/cjs/index.js",