@arkade-os/sdk 0.4.21 → 0.4.23

package/dist/esm/repositories/sqlite/walletRepository.js

@@ -1,4 +1,4 @@
-import { serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, } from '../serialization.js';
+import { serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, serializeAssets, deserializeAssets, } from '../serialization.js';
 import { scriptFromArkAddress } from '../scriptFromAddress.js';
 /**
  * SQLite-based implementation of WalletRepository.
@@ -299,7 +299,9 @@ export class SQLiteWalletRepository {
                 tx.amount,
                 tx.settled ? 1 : 0,
                 tx.createdAt,
-                tx.assets ? JSON.stringify(tx.assets) : null,
+                tx.assets
+                    ? JSON.stringify(serializeAssets(tx.assets))
+                    : null,
             ]);
         }
     }
@@ -406,7 +408,7 @@ function txRowToDomain(row) {
         createdAt: row.created_at,
     };
     if (row.assets_json) {
-        tx.assets = JSON.parse(row.assets_json);
+        tx.assets = deserializeAssets(JSON.parse(row.assets_json));
     }
     return tx;
 }

package/dist/esm/script/address.js

@@ -1,5 +1,6 @@
 import { bech32m } from "@scure/base";
 import { Script } from "@scure/btc-signer/script.js";
+import { DEFAULT_ARKADE_HRP } from '../wallet/index.js';
 /**
  * ArkAddress allows creating and decoding bech32m-encoded Arkade addresses.
  *
@@ -40,7 +41,7 @@ export class ArkAddress {
      * @defaultValue `version = 0`
      * @throws Error if either public key is not 32 bytes long
      */
-    constructor(serverPubKey, vtxoTaprootKey, hrp, version = 0) {
+    constructor(serverPubKey, vtxoTaprootKey, hrp = DEFAULT_ARKADE_HRP, version = 0) {
         this.serverPubKey = serverPubKey;
         this.vtxoTaprootKey = vtxoTaprootKey;
         this.hrp = hrp;

package/dist/esm/utils/transactionHistory.js

@@ -9,7 +9,7 @@ function collectAssets(vtxos) {
     for (const vtxo of vtxos) {
         if (vtxo.assets) {
             for (const a of vtxo.assets) {
-                map.set(a.assetId, (map.get(a.assetId) ?? 0) + a.amount);
+                map.set(a.assetId, (map.get(a.assetId) ?? 0n) + a.amount);
             }
         }
     }
@@ -22,16 +22,16 @@ function subtractAssets(spent, change) {
     for (const vtxo of change) {
         if (vtxo.assets) {
             for (const a of vtxo.assets) {
-                map.set(a.assetId, (map.get(a.assetId) ?? 0) + a.amount);
+                map.set(a.assetId, (map.get(a.assetId) ?? 0n) + a.amount);
             }
         }
     }
     for (const vtxo of spent) {
         if (vtxo.assets) {
             for (const a of vtxo.assets) {
-                const current = map.get(a.assetId) ?? 0;
+                const current = map.get(a.assetId) ?? 0n;
                 const remaining = current - a.amount;
-                if (remaining !== 0) {
+                if (remaining !== 0n) {
                     map.set(a.assetId, remaining);
                 }
                 else {

package/dist/esm/wallet/asset-manager.js

@@ -40,7 +40,7 @@ export class AssetManager extends ReadonlyAssetManager {
      * ```
      */
     async issue(params) {
-        if (params.amount <= 0) {
+        if (params.amount <= 0n) {
             throw new Error(`Issue amount must be greater than 0, got ${params.amount}`);
         }
         const metadata = castMetadata(params.metadata);
@@ -60,12 +60,12 @@ export class AssetManager extends ReadonlyAssetManager {
                 continue;
             for (const { assetId, amount } of coin.assets) {
                 const existing = assetChanges.get(assetId) ?? 0n;
-                assetChanges.set(assetId, existing + BigInt(amount));
+                assetChanges.set(assetId, existing + amount);
             }
         }
         const groups = [];
         // issued asset group
-        const issuedAssetOutput = AssetOutput.create(0, BigInt(params.amount));
+        const issuedAssetOutput = AssetOutput.create(0, params.amount);
         const issuedAssetGroup = AssetGroup.create(null, controlAssetRef, [], [issuedAssetOutput], metadata);
         groups.push(issuedAssetGroup);
         // add asset groups for each asset change
@@ -78,7 +78,7 @@ export class AssetManager extends ReadonlyAssetManager {
                     for (const asset of assets) {
                         if (asset.assetId !== assetId)
                             continue;
-                        changeInputs.push(AssetInput.create(inputIndex, BigInt(asset.amount)));
+                        changeInputs.push(AssetInput.create(inputIndex, asset.amount));
                     }
                 }
                 // add the change asset group
@@ -119,7 +119,7 @@ export class AssetManager extends ReadonlyAssetManager {
      * ```
      */
     async reissue(params) {
-        if (params.amount <= 0) {
+        if (params.amount <= 0n) {
             throw new Error(`Reissuance amount must be greater than 0, got ${params.amount}`);
         }
         const { controlAssetId } = await this.getAssetDetails(params.assetId);
@@ -140,11 +140,11 @@ export class AssetManager extends ReadonlyAssetManager {
                 continue;
             for (const { assetId, amount } of coin.assets) {
                 if (assetId === params.assetId) {
-                    assetToReissueAmount += BigInt(amount);
+                    assetToReissueAmount += amount;
                     continue;
                 }
                 const existing = assetChanges.get(assetId) ?? 0n;
-                assetChanges.set(assetId, existing + BigInt(amount));
+                assetChanges.set(assetId, existing + amount);
             }
         }
         // select at least dust amount
@@ -159,11 +159,11 @@ export class AssetManager extends ReadonlyAssetManager {
                     continue;
                 for (const { assetId, amount } of coin.assets) {
                     if (assetId === params.assetId) {
-                        assetToReissueAmount += BigInt(amount);
+                        assetToReissueAmount += amount;
                         continue;
                     }
                     const existing = assetChanges.get(assetId) ?? 0n;
-                    assetChanges.set(assetId, existing + BigInt(amount));
+                    assetChanges.set(assetId, existing + amount);
                 }
             }
             selectedCoins = [...selectedCoins, ...additional.inputs];
@@ -176,11 +176,11 @@ export class AssetManager extends ReadonlyAssetManager {
             for (const asset of assets) {
                 if (asset.assetId !== params.assetId)
                     continue;
-                reissueInputs.push(AssetInput.create(inputIndex, BigInt(asset.amount)));
+                reissueInputs.push(AssetInput.create(inputIndex, asset.amount));
             }
         }
         // the total output amount of the asset to reissue = new + (optional) selected amount
-        const totalAssetAmount = assetToReissueAmount + BigInt(params.amount);
+        const totalAssetAmount = assetToReissueAmount + params.amount;
         const reissueAssetIdObj = AssetId.fromString(params.assetId);
         // create the reissuance asset group
         const reissueAssetGroup = AssetGroup.create(reissueAssetIdObj, null, reissueInputs, [AssetOutput.create(0, totalAssetAmount)], []);
@@ -192,7 +192,7 @@ export class AssetManager extends ReadonlyAssetManager {
                 for (const asset of assets) {
                     if (asset.assetId !== assetId)
                         continue;
-                    changeInputs.push(AssetInput.create(inputIndex, BigInt(asset.amount)));
+                    changeInputs.push(AssetInput.create(inputIndex, asset.amount));
                 }
             }
             groups.push(AssetGroup.create(AssetId.fromString(assetId), null, changeInputs, [AssetOutput.create(0, amount)], []));
@@ -226,7 +226,7 @@ export class AssetManager extends ReadonlyAssetManager {
      * ```
      */
     async burn(params) {
-        if (params.amount <= 0) {
+        if (params.amount <= 0n) {
             throw new Error(`Burn amount must be greater than 0, got ${params.amount}`);
         }
         const virtualCoins = await this.wallet.getVtxos({
@@ -234,7 +234,7 @@ export class AssetManager extends ReadonlyAssetManager {
         });
         const assetChanges = new Map();
         // select virtual outputs with the asset to burn
-        const { selected: assetCoins } = selectCoinsWithAsset(virtualCoins, params.assetId, BigInt(params.amount));
+        const { selected: assetCoins } = selectCoinsWithAsset(virtualCoins, params.assetId, params.amount);
         const selectedCoins = [...assetCoins];
         let totalBtcSelected = 0;
         // add the selected coins to asset changes, including the asset to burn
@@ -244,11 +244,11 @@ export class AssetManager extends ReadonlyAssetManager {
                 continue;
             for (const { assetId, amount } of coin.assets) {
                 const existing = assetChanges.get(assetId) ?? 0n;
-                assetChanges.set(assetId, existing + BigInt(amount));
+                assetChanges.set(assetId, existing + amount);
             }
         }
         // subtract the amount to burn from the asset change
-        assetChanges.set(params.assetId, (assetChanges.get(params.assetId) ?? 0n) - BigInt(params.amount));
+        assetChanges.set(params.assetId, (assetChanges.get(params.assetId) ?? 0n) - params.amount);
         const minBtcNeeded = Number(this.wallet.dustAmount);
         // we need to ensure at least dust amount is selected
         // if not, select additional coins
@@ -262,7 +262,7 @@ export class AssetManager extends ReadonlyAssetManager {
                     continue;
                 for (const { assetId, amount } of coin.assets) {
                     const existing = assetChanges.get(assetId) ?? 0n;
-                    assetChanges.set(assetId, existing + BigInt(amount));
+                    assetChanges.set(assetId, existing + amount);
                 }
             }
             selectedCoins.push(...additional.inputs);
@@ -276,7 +276,7 @@ export class AssetManager extends ReadonlyAssetManager {
                 for (const asset of assets) {
                     if (asset.assetId !== assetId)
                         continue;
-                    changeInputs.push(AssetInput.create(inputIndex, BigInt(asset.amount)));
+                    changeInputs.push(AssetInput.create(inputIndex, asset.amount));
                 }
             }
             groups.push(AssetGroup.create(AssetId.fromString(assetId), null, changeInputs, amount > 0n ? [AssetOutput.create(0, amount)] : [], []));

package/dist/esm/wallet/asset.js

@@ -15,7 +15,7 @@ export function createAssetPacket(assetInputs, receivers, changeReceiver) {
             const existing = inputsByAssetId.get(asset.assetId);
             inputsByAssetId.set(asset.assetId, [
                 ...(existing ?? []),
-                AssetInput.create(inputIndex, BigInt(asset.amount)),
+                AssetInput.create(inputIndex, asset.amount),
             ]);
         }
     }
@@ -29,7 +29,7 @@ export function createAssetPacket(assetInputs, receivers, changeReceiver) {
                 const existing = outputsByAssetId.get(asset.assetId);
                 outputsByAssetId.set(asset.assetId, [
                     ...(existing ?? []),
-                    AssetOutput.create(outputIndex, BigInt(asset.amount)),
+                    AssetOutput.create(outputIndex, asset.amount),
                 ]);
             }
         }
@@ -41,7 +41,7 @@ export function createAssetPacket(assetInputs, receivers, changeReceiver) {
             const existing = outputsByAssetId.get(asset.assetId);
             outputsByAssetId.set(asset.assetId, [
                 ...(existing ?? []),
-                AssetOutput.create(outputIndex, BigInt(asset.amount)),
+                AssetOutput.create(outputIndex, asset.amount),
             ]);
         }
     }
@@ -69,9 +69,11 @@ export function selectCoinsWithAsset(coins, assetId, requiredAmount) {
     const coinsWithAsset = coins.filter((coin) => coin.assets?.some((a) => a.assetId === assetId));
     // sort by asset amount (smallest first for better selection)
     coinsWithAsset.sort((a, b) => {
-        const amountA = a.assets?.find((asset) => asset.assetId === assetId)?.amount ?? 0;
-        const amountB = b.assets?.find((asset) => asset.assetId === assetId)?.amount ?? 0;
-        return amountA - amountB;
+        const amountA = a.assets?.find((asset) => asset.assetId === assetId)?.amount ?? 0n;
+        const amountB = b.assets?.find((asset) => asset.assetId === assetId)?.amount ?? 0n;
+        // Array.sort callback returns number; reduce the bigint diff to
+        // -1/0/1 (the only thing sort actually consults).
+        return amountA < amountB ? -1 : amountA > amountB ? 1 : 0;
     });
     const selected = [];
     let totalAssetAmount = 0n;
@@ -79,8 +81,8 @@ export function selectCoinsWithAsset(coins, assetId, requiredAmount) {
         if (totalAssetAmount >= requiredAmount)
             break;
         selected.push(coin);
-        const assetAmount = coin.assets?.find((a) => a.assetId === assetId)?.amount ?? 0;
-        totalAssetAmount += BigInt(assetAmount);
+        const assetAmount = coin.assets?.find((a) => a.assetId === assetId)?.amount ?? 0n;
+        totalAssetAmount += assetAmount;
     }
     if (totalAssetAmount < requiredAmount) {
         throw new Error(`Insufficient asset balance: have ${totalAssetAmount}, need ${requiredAmount}`);

package/dist/esm/wallet/delegator.js

@@ -25,20 +25,30 @@ export class DelegatorManagerImpl {
         // fetch server and delegator info once, shared across all groups
         const arkInfo = await this.arkInfoProvider.getInfo();
         const delegateInfo = await this.delegatorProvider.getDelegateInfo();
+        // keep only vtxos that can be signed by the delegate
+        const eligible = vtxos
+            .filter((v) => findDelegateTapLeaf(v, delegateInfo.pubkey) !== undefined)
+            .map((v) => v);
+        if (eligible.length === 0) {
+            return { delegated: [], failed: [] };
+        }
         // if explicit delegateAt is provided, delegate all virtual outputs at once without sorting
         if (delegateAt) {
             try {
-                await delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, vtxos, destinationScript, delegateAt);
+                await delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, eligible, destinationScript, delegateAt);
             }
             catch (error) {
-                return { delegated: [], failed: [{ outpoints: vtxos, error }] };
+                return {
+                    delegated: [],
+                    failed: [{ outpoints: eligible, error }],
+                };
             }
-            return { delegated: vtxos, failed: [] };
+            return { delegated: eligible, failed: [] };
         }
         // if no explicit delegateAt is provided, sort virtual outputs by expiry and delegate in groups of the same expiry day
         const groupByExpiry = new Map();
         let recoverableVtxos = [];
-        for (const vtxo of vtxos) {
+        for (const vtxo of eligible) {
             if (isRecoverable(vtxo)) {
                 recoverableVtxos.push(vtxo);
                 continue;
@@ -185,20 +195,7 @@ async function delegate(identity, delegatorProvider, arkInfo, delegateInfo, vtxo
     await delegatorProvider.delegate(registerIntent, forfeits);
 }
 async function makeDelegateForfeitTx(input, connectorAmount, delegatePubkey, forfeitOutputScript, identity) {
-    if (delegatePubkey.length === 66) {
-        delegatePubkey = delegatePubkey.slice(2);
-    }
-    const vtxoScript = VtxoScript.decode(input.tapTree);
-    const delegateTapLeaf = vtxoScript.leaves.find((tapLeaf) => {
-        const arkTapscript = decodeTapscript(scriptFromTapLeafScript(tapLeaf));
-        if (!MultisigTapscript.is(arkTapscript))
-            return false;
-        if (!arkTapscript.params.pubkeys
-            .map(hex.encode)
-            .includes(delegatePubkey))
-            return false;
-        return true;
-    });
+    const delegateTapLeaf = findDelegateTapLeaf(input, delegatePubkey);
     if (!delegateTapLeaf) {
         throw new Error(`delegate tap leaf not found for input: ${input.txid}:${input.vout}`);
     }
@@ -243,12 +240,12 @@ async function makeSignedDelegateIntent(identity, coins, outputs, onchainOutputs
         for (const [, assets] of assetInputs) {
             for (const asset of assets) {
                 const existing = allAssets.get(asset.assetId) ?? 0n;
-                allAssets.set(asset.assetId, existing + BigInt(asset.amount));
+                allAssets.set(asset.assetId, existing + asset.amount);
             }
         }
         outputAssets = [];
         for (const [assetId, amount] of allAssets) {
-            outputAssets.push({ assetId, amount: Number(amount) });
+            outputAssets.push({ assetId, amount });
         }
     }
     const recipients = outputs.map((output, i) => ({
@@ -286,3 +283,15 @@ function getDayTimestamp(timestamp) {
     date.setUTCHours(0, 0, 0, 0);
     return date.getTime();
 }
+function findDelegateTapLeaf(vtxo, delegatePubkey) {
+    if (!vtxo.tapTree)
+        return undefined;
+    const pk = delegatePubkey.length === 66 ? delegatePubkey.slice(2) : delegatePubkey;
+    const vtxoScript = VtxoScript.decode(vtxo.tapTree);
+    return vtxoScript.leaves.find((tapLeaf) => {
+        const arkTapscript = decodeTapscript(scriptFromTapLeafScript(tapLeaf));
+        if (!MultisigTapscript.is(arkTapscript))
+            return false;
+        return arkTapscript.params.pubkeys.map(hex.encode).includes(pk);
+    });
+}

package/dist/esm/wallet/hdDescriptorProvider.js

@@ -0,0 +1,155 @@
+import { expand, networks } from "@bitcoinerlab/descriptors-scure";
+import { isMainnetDescriptor } from '../identity/descriptor.js';
+import { updateWalletState } from '../utils/syncCursors.js';
+/** Settings key under {@link WalletState.settings} where HD state lives. */
+const HD_SETTINGS_KEY = "hd";
+/**
+ * HD-wallet {@link DescriptorProvider} that allocates a fresh signing
+ * descriptor on every call. The provider holds no notion of "current" — it
+ * is a pure rotating allocator. The question of "which descriptor is the
+ * wallet currently bound to?" is answered by querying the contract
+ * repository for active contracts, not by asking this provider.
+ *
+ * State is persisted under `WalletRepository.getWalletState().settings.hd` so
+ * that no storage-schema migration is required when switching a wallet from
+ * single-key to HD. The provider is backed by an {@link HDCapableIdentity},
+ * which carries the wildcard account descriptor template (for derivation)
+ * and the signing primitives.
+ *
+ * The read-modify-write of the persisted index runs inside the shared per-
+ * repo `updateWalletState` mutex, so two `getNextSigningDescriptor` callers
+ * — including those driving separate `HDDescriptorProvider` instances on
+ * the same repo — can never observe the same index.
+ *
+ * @example
+ * ```ts
+ * const provider = await HDDescriptorProvider.create(identity, walletRepo);
+ * const descriptor = await provider.getNextSigningDescriptor();
+ * // descriptor: tr([fp/86'/0'/0']xpub/0/0)
+ * const next = await provider.getNextSigningDescriptor();
+ * // next: tr([fp/86'/0'/0']xpub/0/1)
+ * ```
+ */
+export class HDDescriptorProvider {
+    constructor(identity, walletRepository) {
+        this.identity = identity;
+        this.walletRepository = walletRepository;
+    }
+    /**
+     * Construct an HDDescriptorProvider. No I/O is performed here;
+     * persisted state is read lazily on the first call to
+     * `getNextSigningDescriptor`. A descriptor-mismatch error surfaces on
+     * first use rather than at boot.
+     */
+    static async create(identity, walletRepository) {
+        return new HDDescriptorProvider(identity, walletRepository);
+    }
+    /**
+     * Allocate the next descriptor and return it. The first call on a fresh
+     * wallet returns descriptor at index 0; subsequent calls return 1, 2, 3,
+     * ... in order. Each call is atomic with respect to other rotations on
+     * the same repo: two concurrent callers can never observe the same
+     * index.
+     */
+    async getNextSigningDescriptor() {
+        return this.mutate((settings) => {
+            const next = settings.lastIndexUsed === undefined
+                ? 0
+                : settings.lastIndexUsed + 1;
+            settings.lastIndexUsed = next;
+            return this.materializeAt(next);
+        });
+    }
+    /**
+     * Returns true when the given descriptor is derivable from this wallet's
+     * seed. Delegates to the underlying identity, which handles both HD and
+     * simple `tr(pubkey)` descriptors.
+     */
+    isOurs(descriptor) {
+        return this.identity.isOurs(descriptor);
+    }
+    /**
+     * Signs each request with the key derived from its descriptor. Delegates
+     * to the identity's signing primitives — the identity, not the provider,
+     * holds the seed.
+     */
+    async signWithDescriptor(requests) {
+        return this.identity.signWithDescriptor(requests);
+    }
+    /** Signs a message using the key derived from `descriptor`. */
+    async signMessageWithDescriptor(descriptor, message, signatureType = "schnorr") {
+        return this.identity.signMessageWithDescriptor(descriptor, message, signatureType);
+    }
+    // ── internals ────────────────────────────────────────────────────
+    /**
+     * Substitute the wildcard in the identity's account-descriptor template
+     * with a concrete index, going through the descriptors-scure parser
+     * rather than ad-hoc string substitution. The parser's `expand({ index })`
+     * call validates that the input is a ranged template AND produces a
+     * canonical materialized key expression at the given index.
+     */
+    materializeAt(index) {
+        const descriptor = this.identity.descriptor;
+        const network = isMainnetDescriptor(descriptor)
+            ? networks.bitcoin
+            : networks.testnet;
+        const expansion = expand({ descriptor, network, index });
+        const keyInfo = expansion.expansionMap?.["@0"];
+        if (!keyInfo?.keyExpression) {
+            throw new Error(`HDDescriptorProvider: cannot materialize descriptor at index ${index}`);
+        }
+        return `tr(${keyInfo.keyExpression})`;
+    }
+    /**
+     * Run the read-modify-write of HD settings inside the shared per-repo
+     * wallet-state mutex. The closure receives a freshly-validated settings
+     * snapshot, mutates it, and returns whatever value the caller wants to
+     * surface; the mutated settings are then persisted as part of the same
+     * atomic update.
+     *
+     * Doing the read inside the lock is what prevents two providers (or two
+     * concurrent callers on the same provider) from racing on a stale index.
+     */
+    async mutate(fn) {
+        let result;
+        await updateWalletState(this.walletRepository, (state) => {
+            const settings = this.parseSettings(state);
+            result = fn(settings);
+            return {
+                ...state,
+                settings: {
+                    ...(state.settings ?? {}),
+                    [HD_SETTINGS_KEY]: settings,
+                },
+            };
+        });
+        return result;
+    }
+    /**
+     * Validate the persisted HD settings (or initialize a fresh record when
+     * absent) and return a clone safe for the caller to mutate.
+     *
+     * The cast to `HDWalletSettings` trusts storage; a corrupted or
+     * partially-migrated repo could otherwise produce `NaN` descriptors.
+     * Fail loud rather than silently derive garbage.
+     */
+    parseSettings(state) {
+        const stored = state.settings?.[HD_SETTINGS_KEY];
+        const expected = this.identity.descriptor;
+        if (!stored) {
+            return { descriptor: expected };
+        }
+        if (stored.descriptor !== expected) {
+            throw new Error(`HD descriptor mismatch: stored "${stored.descriptor}", expected "${expected}". ` +
+                `Refusing to reuse HD state from a different identity.`);
+        }
+        if (stored.lastIndexUsed !== undefined &&
+            (typeof stored.lastIndexUsed !== "number" ||
+                !Number.isInteger(stored.lastIndexUsed) ||
+                stored.lastIndexUsed < 0)) {
+            throw new Error(`Corrupt HD settings: lastIndexUsed is not a non-negative integer (got ${String(stored.lastIndexUsed)}).`);
+        }
+        // Shallow clone so the closure may mutate without aliasing the repo's copy.
+        return { ...stored };
+    }
+}

package/dist/esm/wallet/index.js

@@ -1,3 +1,7 @@
+/** Defaults */
+export const DEFAULT_ARKADE_SERVER_URL = "https://arkade.computer";
+export const DEFAULT_ARKADE_HRP = "ark";
+export const DEFAULT_NETWORK_NAME = "bitcoin";
 /** Wallet transaction direction. */
 export var TxType;
 (function (TxType) {

package/dist/esm/wallet/onchain.js

@@ -1,4 +1,5 @@
 import { p2tr } from "@scure/btc-signer";
+import { DEFAULT_NETWORK_NAME } from './index.js';
 import { getNetwork } from '../networks.js';
 import { ESPLORA_URL, EsploraProvider, } from '../providers/onchain.js';
 import { findP2AOutput, P2A } from '../utils/anchor.js';
@@ -39,7 +40,7 @@ export class OnchainWallet {
      * @defaultValue `provider = new EsploraProvider('https://mempool.space/api')`
      * @throws Error if the configured identity cannot produce a valid x-only public key
      */
-    static async create(identity, networkName, provider) {
+    static async create(identity, networkName = DEFAULT_NETWORK_NAME, provider) {
         const pubkey = await identity.xOnlyPublicKey();
         if (!pubkey) {
             throw new Error("Invalid configured public key");

package/dist/esm/wallet/serviceWorker/wallet-message-handler.js

@@ -508,7 +508,7 @@ export class WalletMessageHandler {
         for (const vtxo of spendableVtxos) {
             if (vtxo.assets) {
                 for (const a of vtxo.assets) {
-                    const current = assetBalances.get(a.assetId) ?? 0;
+                    const current = assetBalances.get(a.assetId) ?? 0n;
                     assetBalances.set(a.assetId, current + a.amount);
                 }
             }
@@ -700,7 +700,9 @@ export class WalletMessageHandler {
         const { vtxoOutpoints, destination, delegateAt } = message.payload;
         const allVtxos = await wallet.getVtxos();
         const outpointSet = new Set(vtxoOutpoints.map((o) => `${o.txid}:${o.vout}`));
-        const filtered = allVtxos.filter((v) => outpointSet.has(`${v.txid}:${v.vout}`));
+        const filtered = allVtxos
+            .filter((v) => outpointSet.has(`${v.txid}:${v.vout}`))
+            .map((v) => ({ ...v, contractScript: v.script }));
         const result = await delegatorManager.delegate(filtered, destination, delegateAt !== undefined ? new Date(delegateAt) : undefined);
         return {
             tag: this.messageTag,

package/dist/esm/wallet/serviceWorker/wallet.js

@@ -5,6 +5,7 @@ import { IndexedDBContractRepository, IndexedDBWalletRepository, } from '../../r
 import { DEFAULT_MESSAGE_TAG, } from './wallet-message-handler.js';
 import { getRandomId } from '../utils.js';
 import { MESSAGE_BUS_NOT_INITIALIZED, ServiceWorkerTimeoutError, } from '../../worker/errors.js';
+import { getArkadeServerUrl } from '../wallet.js';
 // Check by error message content instead of instanceof because postMessage uses the
 // structured clone algorithm which strips the prototype chain — the page
 // receives a plain Error, not the original MessageBusNotInitializedError.
@@ -211,7 +212,7 @@ export class ServiceWorkerReadonlyWallet {
             .then(hex.encode);
         const initWalletPayload = {
             key: { publicKey },
-            arkServerUrl: options.arkServerUrl,
+            arkServerUrl: getArkadeServerUrl(options),
             arkServerPublicKey: options.arkServerPublicKey,
             delegatorUrl: options.delegatorUrl,
         };
@@ -226,7 +227,7 @@ export class ServiceWorkerReadonlyWallet {
         const busInitConfig = {
             wallet: serializedWallet,
             arkServer: {
-                url: options.arkServerUrl,
+                url: getArkadeServerUrl(options),
                 publicKey: options.arkServerPublicKey,
             },
             delegatorUrl: options.delegatorUrl,
@@ -884,7 +885,7 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
             : null;
         const initWalletPayload = {
             key: legacyPrivateKey ? { privateKey: legacyPrivateKey } : {},
-            arkServerUrl: options.arkServerUrl,
+            arkServerUrl: getArkadeServerUrl(options),
             arkServerPublicKey: options.arkServerPublicKey,
             delegatorUrl: options.delegatorUrl,
         };
@@ -899,7 +900,7 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
         const busInitConfig = {
             wallet: serializedWallet,
             arkServer: {
-                url: options.arkServerUrl,
+                url: getArkadeServerUrl(options),
                 publicKey: options.arkServerPublicKey,
             },
             delegatorUrl: options.delegatorUrl,

package/dist/esm/wallet/validation.js

@@ -136,8 +136,7 @@ function validateAssetGroupOutput(packet, outputIndex, assetId, expectedAmount)
     if (!assetOutput) {
         throw ErrAssetOutputNotFound(assetId, outputIndex);
     }
-    const expectedAmountBigInt = BigInt(expectedAmount);
-    if (assetOutput.amount !== expectedAmountBigInt) {
-        throw ErrInvalidAssetOutputAmount(assetOutput.amount, expectedAmountBigInt, assetId);
+    if (assetOutput.amount !== expectedAmount) {
+        throw ErrInvalidAssetOutputAmount(assetOutput.amount, expectedAmount, assetId);
     }
 }

package/dist/esm/wallet/vtxo-manager.js

@@ -693,11 +693,13 @@ export class VtxoManager {
                         console.error("Error renewing VTXOs:", e);
                     });
                 }
-                delegatorManager
-                    ?.delegate(event.vtxos, destination)
-                    .catch((e) => {
-                    console.error("Error delegating VTXOs:", e);
-                });
+                if (delegatorManager) {
+                    delegatorManager
+                        .delegate(event.vtxos, destination)
+                        .catch((e) => {
+                        console.error("Error delegating VTXOs:", e);
+                    });
+                }
             });
             return stopWatching;
         }