@arkade-os/sdk 0.3.12 → 0.4.0-next.0

package/dist/esm/identity/seedIdentity.js

@@ -0,0 +1,249 @@
+import { validateMnemonic, mnemonicToSeedSync } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { pubECDSA, pubSchnorr } from "@scure/btc-signer/utils.js";
+import { SigHash } from "@scure/btc-signer";
+import { TreeSignerSession } from '../tree/signingSession.js';
+import { schnorr, signAsync } from "@noble/secp256k1";
+import { defaultFactory, scureBIP32 as BIP32, networks, scriptExpressions, } from "@kukks/bitcoin-descriptors";
+const { expand } = defaultFactory;
+const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
+/**
+ * Detects the network from a descriptor string by checking for tpub (testnet)
+ * vs xpub (mainnet) key prefix.
+ * @internal
+ */
+function detectNetwork(descriptor) {
+    return descriptor.includes("tpub") ? networks.testnet : networks.bitcoin;
+}
+function hasDescriptor(opts) {
+    return "descriptor" in opts && typeof opts.descriptor === "string";
+}
+/**
+ * Builds a BIP86 Taproot output descriptor from a seed and network flag.
+ * @internal
+ */
+function buildDescriptor(seed, isMainnet) {
+    const network = isMainnet ? networks.bitcoin : networks.testnet;
+    const masterNode = BIP32.fromSeed(seed, network);
+    return scriptExpressions.trBIP32({
+        masterNode,
+        network,
+        account: 0,
+        change: 0,
+        index: 0,
+    });
+}
+/**
+ * Seed-based identity derived from a raw seed and an output descriptor.
+ *
+ * This is the recommended identity type for most applications. It uses
+ * standard BIP86 (Taproot) derivation by default and stores an output
+ * descriptor for interoperability with other wallets. The descriptor
+ * format is HD-ready, allowing future support for multiple addresses
+ * and change derivation.
+ *
+ * Prefer this (or {@link MnemonicIdentity}) over `SingleKey` for new
+ * integrations — `SingleKey` exists for backward compatibility with
+ * raw nsec-style keys.
+ *
+ * @example
+ * ```typescript
+ * const seed = mnemonicToSeedSync(mnemonic);
+ *
+ * // Testnet (BIP86 path m/86'/1'/0'/0/0)
+ * const identity = SeedIdentity.fromSeed(seed, { isMainnet: false });
+ *
+ * // Mainnet (BIP86 path m/86'/0'/0'/0/0)
+ * const identity = SeedIdentity.fromSeed(seed, { isMainnet: true });
+ *
+ * // Custom descriptor
+ * const identity = SeedIdentity.fromSeed(seed, { descriptor });
+ * ```
+ */
+export class SeedIdentity {
+    constructor(seed, descriptor) {
+        if (seed.length !== 64) {
+            throw new Error("Seed must be 64 bytes");
+        }
+        this.seed = seed;
+        this.descriptor = descriptor;
+        const network = detectNetwork(descriptor);
+        // Parse and validate the descriptor using the library
+        const expansion = expand({ descriptor, network });
+        const keyInfo = expansion.expansionMap?.["@0"];
+        if (!keyInfo?.originPath) {
+            throw new Error("Descriptor must include a key origin path");
+        }
+        // Verify the xpub in the descriptor matches our seed
+        const masterNode = BIP32.fromSeed(seed, network);
+        const accountNode = masterNode.derivePath(`m${keyInfo.originPath}`);
+        if (accountNode.neutered().toBase58() !== keyInfo.bip32?.toBase58()) {
+            throw new Error("xpub mismatch: derived key does not match descriptor");
+        }
+        // Derive the private key using the full path from the descriptor
+        if (!keyInfo.path) {
+            throw new Error("Descriptor must specify a full derivation path");
+        }
+        const derivedNode = masterNode.derivePath(keyInfo.path);
+        if (!derivedNode.privateKey) {
+            throw new Error("Failed to derive private key");
+        }
+        this.derivedKey = derivedNode.privateKey;
+    }
+    /**
+     * Creates a SeedIdentity from a raw 64-byte seed.
+     *
+     * Pass `{ isMainnet }` for default BIP86 derivation, or
+     * `{ descriptor }` for a custom derivation path.
+     *
+     * @param seed - 64-byte seed (typically from mnemonicToSeedSync)
+     * @param opts - Network selection or custom descriptor.
+     */
+    static fromSeed(seed, opts) {
+        const descriptor = hasDescriptor(opts)
+            ? opts.descriptor
+            : buildDescriptor(seed, opts.isMainnet);
+        return new SeedIdentity(seed, descriptor);
+    }
+    async xOnlyPublicKey() {
+        return pubSchnorr(this.derivedKey);
+    }
+    async compressedPublicKey() {
+        return pubECDSA(this.derivedKey, true);
+    }
+    async sign(tx, inputIndexes) {
+        const txCpy = tx.clone();
+        if (!inputIndexes) {
+            try {
+                if (!txCpy.sign(this.derivedKey, ALL_SIGHASH)) {
+                    throw new Error("Failed to sign transaction");
+                }
+            }
+            catch (e) {
+                if (e instanceof Error &&
+                    e.message.includes("No inputs signed")) {
+                    // ignore
+                }
+                else {
+                    throw e;
+                }
+            }
+            return txCpy;
+        }
+        for (const inputIndex of inputIndexes) {
+            if (!txCpy.signIdx(this.derivedKey, inputIndex, ALL_SIGHASH)) {
+                throw new Error(`Failed to sign input #${inputIndex}`);
+            }
+        }
+        return txCpy;
+    }
+    async signMessage(message, signatureType = "schnorr") {
+        if (signatureType === "ecdsa") {
+            return signAsync(message, this.derivedKey, { prehash: false });
+        }
+        return schnorr.signAsync(message, this.derivedKey);
+    }
+    signerSession() {
+        return TreeSignerSession.random();
+    }
+    /**
+     * Converts to a watch-only identity that cannot sign.
+     */
+    async toReadonly() {
+        return ReadonlyDescriptorIdentity.fromDescriptor(this.descriptor);
+    }
+}
+/**
+ * Mnemonic-based identity derived from a BIP39 phrase.
+ *
+ * This is the most user-friendly identity type — recommended for wallet
+ * applications where users manage their own backup phrase. Extends
+ * {@link SeedIdentity} with mnemonic validation and optional passphrase
+ * support.
+ *
+ * @example
+ * ```typescript
+ * const identity = MnemonicIdentity.fromMnemonic(
+ *   'abandon abandon abandon ...',
+ *   { isMainnet: true, passphrase: 'secret' }
+ * );
+ * ```
+ */
+export class MnemonicIdentity extends SeedIdentity {
+    constructor(seed, descriptor) {
+        super(seed, descriptor);
+    }
+    /**
+     * Creates a MnemonicIdentity from a BIP39 mnemonic phrase.
+     *
+     * Pass `{ isMainnet }` for default BIP86 derivation, or
+     * `{ descriptor }` for a custom derivation path.
+     *
+     * @param phrase - BIP39 mnemonic phrase (12 or 24 words)
+     * @param opts - Network selection or custom descriptor, plus optional passphrase
+     */
+    static fromMnemonic(phrase, opts) {
+        if (!validateMnemonic(phrase, wordlist)) {
+            throw new Error("Invalid mnemonic");
+        }
+        const passphrase = opts.passphrase;
+        const seed = mnemonicToSeedSync(phrase, passphrase);
+        const descriptor = hasDescriptor(opts)
+            ? opts.descriptor
+            : buildDescriptor(seed, opts.isMainnet);
+        return new MnemonicIdentity(seed, descriptor);
+    }
+}
+/**
+ * Watch-only identity from an output descriptor.
+ *
+ * Can derive public keys but cannot sign transactions. Use this for
+ * watch-only wallets or when sharing identity information without
+ * exposing private keys.
+ *
+ * @example
+ * ```typescript
+ * const descriptor = "tr([fingerprint/86'/0'/0']xpub.../0/0)";
+ * const readonly = ReadonlyDescriptorIdentity.fromDescriptor(descriptor);
+ * const pubKey = await readonly.xOnlyPublicKey();
+ * ```
+ */
+export class ReadonlyDescriptorIdentity {
+    constructor(descriptor) {
+        this.descriptor = descriptor;
+        const network = detectNetwork(descriptor);
+        const expansion = expand({ descriptor, network });
+        const keyInfo = expansion.expansionMap?.["@0"];
+        if (!keyInfo?.pubkey) {
+            throw new Error("Failed to derive public key from descriptor");
+        }
+        // For taproot, the library returns 32-byte x-only pubkey
+        this.xOnlyPubKey = keyInfo.pubkey;
+        // Get 33-byte compressed key with correct parity from the bip32 node
+        if (keyInfo.bip32 && keyInfo.keyPath) {
+            // Strip leading "/" — the library's derivePath prepends "m/" itself
+            const relPath = keyInfo.keyPath.replace(/^\//, "");
+            this.compressedPubKey = keyInfo.bip32.derivePath(relPath).publicKey;
+        }
+        else if (keyInfo.bip32) {
+            this.compressedPubKey = keyInfo.bip32.publicKey;
+        }
+        else {
+            throw new Error("Cannot determine compressed public key parity from descriptor");
+        }
+    }
+    /**
+     * Creates a ReadonlyDescriptorIdentity from an output descriptor.
+     *
+     * @param descriptor - Taproot descriptor: tr([fingerprint/path']xpub.../child/path)
+     */
+    static fromDescriptor(descriptor) {
+        return new ReadonlyDescriptorIdentity(descriptor);
+    }
+    async xOnlyPublicKey() {
+        return this.xOnlyPubKey;
+    }
+    async compressedPublicKey() {
+        return this.compressedPubKey;
+    }
+}

package/dist/esm/index.js

@@ -1,25 +1,26 @@
 import { Transaction } from './utils/transaction.js';
 import { SingleKey, ReadonlySingleKey } from './identity/singleKey.js';
+import { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, } from './identity/seedIdentity.js';
 import { ArkAddress } from './script/address.js';
 import { VHTLC } from './script/vhtlc.js';
 import { DefaultVtxo } from './script/default.js';
-import { VtxoScript, TapTreeCoder, } from './script/base.js';
+import { DelegateVtxo } from './script/delegate.js';
+import { MessageBus, } from './worker/messageBus.js';
+import { VtxoScript, TapTreeCoder, getSequence, } from './script/base.js';
 import { TxType, isSpendable, isSubdust, isRecoverable, isExpired, } from './wallet/index.js';
 import { Batch } from './wallet/batch.js';
-import { Wallet, ReadonlyWallet, waitForIncomingFunds, getSequence, } from './wallet/wallet.js';
+import { Wallet, ReadonlyWallet, waitForIncomingFunds, } from './wallet/wallet.js';
 import { TxTree } from './tree/txTree.js';
 import { Ramps } from './wallet/ramps.js';
 import { isVtxoExpiringSoon, VtxoManager } from './wallet/vtxo-manager.js';
 import { ServiceWorkerWallet, ServiceWorkerReadonlyWallet, } from './wallet/serviceWorker/wallet.js';
 import { OnchainWallet } from './wallet/onchain.js';
-import { setupServiceWorker } from './wallet/serviceWorker/utils.js';
-import { Worker } from './wallet/serviceWorker/worker.js';
-import { Request } from './wallet/serviceWorker/request.js';
-import { Response } from './wallet/serviceWorker/response.js';
+import { setupServiceWorker } from './worker/browser/utils.js';
 import { ESPLORA_URL, EsploraProvider, } from './providers/onchain.js';
 import { RestArkProvider, SettlementEventType, } from './providers/ark.js';
+import { RestDelegatorProvider, } from './providers/delegator.js';
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, } from './script/tapscript.js';
-import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, combineTapscriptSigs, } from './utils/arkTransaction.js';
+import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, combineTapscriptSigs, isValidArkAddress, } from './utils/arkTransaction.js';
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from './utils/unknownFields.js';
 import { Intent } from './intent/index.js';
 import { ArkNote } from './arknote/index.js';
@@ -27,35 +28,42 @@ import { networks } from './networks.js';
 import { RestIndexerProvider, IndexerTxType, ChainTxType, } from './providers/indexer.js';
 import { P2A } from './utils/anchor.js';
 import { Unroll } from './wallet/unroll.js';
-import { WalletRepositoryImpl } from './repositories/walletRepository.js';
-import { ContractRepositoryImpl } from './repositories/contractRepository.js';
 import { ArkError, maybeArkError } from './providers/errors.js';
 import { validateVtxoTxGraph, validateConnectorsTxGraph, } from './tree/validation.js';
 import { buildForfeitTx } from './forfeit.js';
+import { IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, } from './repositories/index.js';
+import { DelegatorManagerImpl } from './wallet/delegator.js';
 export * from './arkfee/index.js';
+export * as asset from './asset/index.js';
+// Contracts
+import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, } from './contracts/index.js';
+import { closeDatabase, openDatabase } from './db/manager.js';
+import { WalletMessageHandler } from './wallet/serviceWorker/wallet-message-handler.js';
 export { 
 // Wallets
-Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, OnchainWallet, Ramps, VtxoManager, 
+Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, OnchainWallet, Ramps, VtxoManager, DelegatorManagerImpl, RestDelegatorProvider, 
 // Providers
 ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, 
 // Script-related
-ArkAddress, DefaultVtxo, VtxoScript, VHTLC, 
+ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC, 
 // Enums
 TxType, IndexerTxType, ChainTxType, SettlementEventType, 
 // Service Worker
-setupServiceWorker, Worker, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, Request, Response, 
+setupServiceWorker, MessageBus, WalletMessageHandler, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, 
 // Tapscript
 decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, 
 // Ark PSBT fields
 ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, 
 // Utils
-buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, 
+buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, isValidArkAddress, 
 // Arknote
 ArkNote, 
 // Network
 networks, 
+// DB
+closeDatabase, openDatabase, 
 // Repositories
-WalletRepositoryImpl, ContractRepositoryImpl, 
+IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, 
 // Intent proof
 Intent, 
 // TxTree
@@ -65,4 +73,6 @@ P2A, Unroll, Transaction,
 // Errors
 ArkError, maybeArkError, 
 // Batch session
-Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, };
+Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, 
+// Contracts
+ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, };

package/dist/esm/intent/index.js

@@ -1,6 +1,9 @@
 import { OP, Script, SigHash } from "@scure/btc-signer";
 import { schnorr } from "@noble/curves/secp256k1.js";
 import { Transaction } from '../utils/transaction.js';
+import { ConditionWitness, VtxoTaprootTree } from '../utils/unknownFields.js';
+import { hex } from "@scure/base";
+import { getSequence, VtxoScript } from '../script/base.js';
 /**
  * Intent proof implementation for Bitcoin message signing.
  *
@@ -38,12 +41,13 @@ export var Intent;
      * @param outputs - Optional array of transaction outputs
      * @returns An unsigned Intent proof transaction
      */
-    function create(message, inputs, outputs = []) {
+    function create(message, ins, outputs = []) {
         if (typeof message !== "string") {
             message = encodeMessage(message);
         }
-        if (inputs.length == 0)
+        if (ins.length == 0)
             throw new Error("intent proof requires at least one input");
+        const inputs = ins.map(prepareCoinAsIntentProofInput);
         if (!validateInputs(inputs))
             throw new Error("invalid inputs");
         if (!validateOutputs(outputs))
@@ -202,3 +206,25 @@ function craftToSignTx(toSpend, inputs, outputs) {
 function hashMessage(message) {
     return schnorr.utils.taggedHash(TAG_INTENT_PROOF, new TextEncoder().encode(message));
 }
+function prepareCoinAsIntentProofInput(coin) {
+    if (!("tapTree" in coin)) {
+        return coin;
+    }
+    const vtxoScript = VtxoScript.decode(coin.tapTree);
+    const sequence = getSequence(coin.intentTapLeafScript);
+    const unknown = [VtxoTaprootTree.encode(coin.tapTree)];
+    if (coin.extraWitness) {
+        unknown.push(ConditionWitness.encode(coin.extraWitness));
+    }
+    return {
+        txid: hex.decode(coin.txid),
+        index: coin.vout,
+        witnessUtxo: {
+            amount: BigInt(coin.value),
+            script: vtxoScript.pkScript,
+        },
+        sequence,
+        tapLeafScript: [coin.intentTapLeafScript],
+        unknown,
+    };
+}

package/dist/esm/providers/ark.js

@@ -12,6 +12,7 @@ export var SettlementEventType;
     SettlementEventType["TreeNonces"] = "tree_nonces";
     SettlementEventType["TreeTx"] = "tree_tx";
     SettlementEventType["TreeSignature"] = "tree_signature";
+    SettlementEventType["StreamStarted"] = "stream_started";
 })(SettlementEventType || (SettlementEventType = {}));
 /**
  * REST-based Ark provider implementation.
@@ -420,6 +421,12 @@ export class RestArkProvider {
                 signature: data.treeSignature.signature,
             };
         }
+        if (data.streamStarted) {
+            return {
+                type: SettlementEventType.StreamStarted,
+                id: data.streamStarted.id,
+            };
+        }
         // Skip heartbeat events
         if (data.heartbeat) {
             return null;

package/dist/esm/providers/delegator.js

@@ -0,0 +1,62 @@
+import { Intent } from '../intent/index.js';
+/**
+ * REST-based Delegator provider implementation.
+ * @example
+ * ```typescript
+ * const provider = new RestDelegatorProvider('https://delegator.example.com');
+ * const info = await provider.getDelegateInfo();
+ * await provider.delegate(intent, forfeitTxs);
+ * ```
+ */
+export class RestDelegatorProvider {
+    constructor(url) {
+        this.url = url;
+    }
+    async delegate(intent, forfeitTxs, options) {
+        const url = `${this.url}/v1/delegate`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                intent: {
+                    message: Intent.encodeMessage(intent.message),
+                    proof: intent.proof,
+                },
+                forfeit_txs: forfeitTxs,
+                reject_replace: options?.rejectReplace ?? false,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to delegate: ${errorText}`);
+        }
+    }
+    async getDelegateInfo() {
+        const url = `${this.url}/v1/delegator/info`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to get delegate info: ${errorText}`);
+        }
+        const data = await response.json();
+        if (!isDelegateInfo(data)) {
+            throw new Error("Invalid delegate info");
+        }
+        return data;
+    }
+}
+function isDelegateInfo(data) {
+    return (!!data &&
+        typeof data === "object" &&
+        "pubkey" in data &&
+        "fee" in data &&
+        "delegatorAddress" in data &&
+        typeof data.pubkey === "string" &&
+        typeof data.fee === "string" &&
+        typeof data.delegatorAddress === "string" &&
+        data.pubkey !== "" &&
+        data.fee !== "" &&
+        data.delegatorAddress !== "");
+}

package/dist/esm/providers/expoIndexer.js

@@ -9,6 +9,7 @@ function convertVtxo(vtxo) {
         value: Number(vtxo.amount),
         status: {
             confirmed: !vtxo.isSwept && !vtxo.isPreconfirmed,
+            isLeaf: !vtxo.isPreconfirmed,
         },
         virtualStatus: {
             state: vtxo.isSwept
@@ -27,6 +28,10 @@ function convertVtxo(vtxo) {
         createdAt: new Date(Number(vtxo.createdAt) * 1000),
         isUnrolled: vtxo.isUnrolled,
         isSpent: vtxo.isSpent,
+        assets: vtxo.assets?.map((a) => ({
+            assetId: a.assetId,
+            amount: Number(a.amount),
+        })),
     };
 }
 /**

package/dist/esm/providers/indexer.js

@@ -1,5 +1,7 @@
+import { hex } from "@scure/base";
 import { isFetchTimeoutError } from './ark.js';
 import { eventSourceIterator } from './utils.js';
+import { MetadataList } from '../asset/index.js';
 export var IndexerTxType;
 (function (IndexerTxType) {
     IndexerTxType[IndexerTxType["INDEXER_TX_TYPE_UNSPECIFIED"] = 0] = "INDEXER_TX_TYPE_UNSPECIFIED";
@@ -298,6 +300,26 @@ export class RestIndexerProvider {
             page: data.page,
         };
     }
+    async getAssetDetails(assetId) {
+        const url = `${this.serverUrl}/v1/indexer/asset/${encodeURIComponent(assetId)}`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`Failed to fetch asset details: ${res.statusText}`);
+        }
+        const data = await res.json();
+        if (!Response.isGetAssetResponse(data)) {
+            throw new Error("Invalid get asset response");
+        }
+        const metadata = data.metadata?.length
+            ? parseAssetMetadata(data.metadata)
+            : undefined;
+        return {
+            assetId: data.assetId ?? assetId,
+            supply: Number(data.supply ?? 0),
+            metadata,
+            controlAssetId: data.controlAsset || undefined,
+        };
+    }
     async subscribeForScripts(scripts, subscriptionId) {
         const url = `${this.serverUrl}/v1/indexer/script/subscribe`;
         const res = await fetch(url, {
@@ -331,6 +353,29 @@ export class RestIndexerProvider {
         }
     }
 }
+function parseAssetMetadata(metadata) {
+    const metadataList = MetadataList.fromString(metadata);
+    const out = {};
+    const decoder = new TextDecoder();
+    for (const { key, value } of metadataList.items) {
+        const keyString = decoder.decode(key);
+        switch (keyString) {
+            case "decimals":
+                const n = Number(decoder.decode(value));
+                out[keyString] = Number.isFinite(n) ? n : hex.encode(value);
+                break;
+            case "name":
+            case "ticker":
+            case "icon":
+                out[keyString] = decoder.decode(value);
+                break;
+            default:
+                out[keyString] = hex.encode(value);
+                break;
+        }
+    }
+    return out;
+}
 function convertVtxo(vtxo) {
     return {
         txid: vtxo.outpoint.txid,
@@ -357,6 +402,10 @@ function convertVtxo(vtxo) {
         createdAt: new Date(Number(vtxo.createdAt) * 1000),
         isUnrolled: vtxo.isUnrolled,
         isSpent: vtxo.isSpent,
+        assets: vtxo.assets?.map((a) => ({
+            assetId: a.assetId,
+            amount: Number(a.amount),
+        })),
     };
 }
 // Unexported namespace for type guards only
@@ -431,6 +480,12 @@ var Response;
         return Array.isArray(data) && data.every(isTxid);
     }
     Response.isTxidArray = isTxidArray;
+    function isVtxoAsset(data) {
+        return (typeof data === "object" &&
+            data !== null &&
+            typeof data.assetId === "string" &&
+            typeof data.amount === "string");
+    }
     function isVtxo(data) {
         return (typeof data === "object" &&
             isOutpoint(data.outpoint) &&
@@ -446,7 +501,9 @@ var Response;
             (!data.settledBy || typeof data.settledBy === "string") &&
             (!data.arkTxid || typeof data.arkTxid === "string") &&
             Array.isArray(data.commitmentTxids) &&
-            data.commitmentTxids.every(isTxid));
+            data.commitmentTxids.every(isTxid) &&
+            (data.assets === undefined ||
+                (Array.isArray(data.assets) && data.assets.every(isVtxoAsset))));
     }
     function isPageResponse(data) {
         return (typeof data === "object" &&
@@ -515,4 +572,14 @@ var Response;
             (!data.page || isPageResponse(data.page)));
     }
     Response.isVtxosResponse = isVtxosResponse;
+    function isGetAssetResponse(data) {
+        return (typeof data === "object" &&
+            data !== null &&
+            typeof data.assetId === "string" &&
+            typeof data.supply === "string" &&
+            (data.controlAsset === undefined ||
+                typeof data.controlAsset === "string") &&
+            (data.metadata === undefined || typeof data.metadata === "string"));
+    }
+    Response.isGetAssetResponse = isGetAssetResponse;
 })(Response || (Response = {}));

package/dist/esm/providers/onchain.js

@@ -231,14 +231,14 @@ export class EsploraProvider {
 function isValidBlocksTip(tip) {
     return (Array.isArray(tip) &&
         tip.every((t) => {
-            t &&
+            return (t &&
                 typeof t === "object" &&
                 typeof t.id === "string" &&
                 t.id.length > 0 &&
                 typeof t.height === "number" &&
                 t.height >= 0 &&
                 typeof t.mediantime === "number" &&
-                t.mediantime > 0;
+                t.mediantime > 0);
         }));
 }
 const isExplorerTransaction = (tx) => {

package/dist/esm/providers/utils.js

@@ -14,6 +14,7 @@ export async function* eventSourceIterator(eventSource) {
     };
     const errorHandler = () => {
         const error = new Error("EventSource error");
+        error.name = "EventSourceError";
         if (errorResolve) {
             errorResolve(error);
             errorResolve = null;