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

package/dist/cjs/providers/indexer.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestIndexerProvider = exports.ChainTxType = exports.IndexerTxType = void 0;
+const base_1 = require("@scure/base");
 const ark_1 = require("./ark");
 const utils_1 = require("./utils");
+const asset_1 = require("../asset");
 var IndexerTxType;
 (function (IndexerTxType) {
     IndexerTxType[IndexerTxType["INDEXER_TX_TYPE_UNSPECIFIED"] = 0] = "INDEXER_TX_TYPE_UNSPECIFIED";
@@ -301,6 +303,26 @@ 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, {
@@ -335,6 +357,29 @@ class RestIndexerProvider {
     }
 }
 exports.RestIndexerProvider = RestIndexerProvider;
+function parseAssetMetadata(metadata) {
+    const metadataList = asset_1.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 : base_1.hex.encode(value);
+                break;
+            case "name":
+            case "ticker":
+            case "icon":
+                out[keyString] = decoder.decode(value);
+                break;
+            default:
+                out[keyString] = base_1.hex.encode(value);
+                break;
+        }
+    }
+    return out;
+}
 function convertVtxo(vtxo) {
     return {
         txid: vtxo.outpoint.txid,
@@ -361,6 +406,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
@@ -435,6 +484,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) &&
@@ -450,7 +505,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" &&
@@ -519,4 +576,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/cjs/providers/onchain.js

@@ -235,14 +235,14 @@ exports.EsploraProvider = 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/cjs/providers/utils.js

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

package/dist/cjs/repositories/contractRepository.js

@@ -1,105 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContractRepositoryImpl = void 0;
-const getContractStorageKey = (id, key) => `contract:${id}:${key}`;
-const getCollectionStorageKey = (type) => `collection:${type}`;
-class ContractRepositoryImpl {
-    constructor(storage) {
-        this.storage = storage;
-    }
-    async getContractData(contractId, key) {
-        const stored = await this.storage.getItem(getContractStorageKey(contractId, key));
-        if (!stored)
-            return null;
-        try {
-            const data = JSON.parse(stored);
-            return data;
-        }
-        catch (error) {
-            console.error(`Failed to parse contract data for ${contractId}:${key}:`, error);
-            return null;
-        }
-    }
-    async setContractData(contractId, key, data) {
-        try {
-            await this.storage.setItem(getContractStorageKey(contractId, key), JSON.stringify(data));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract data for ${contractId}:${key}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async deleteContractData(contractId, key) {
-        try {
-            await this.storage.removeItem(getContractStorageKey(contractId, key));
-        }
-        catch (error) {
-            console.error(`Failed to remove contract data for ${contractId}:${key}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async getContractCollection(contractType) {
-        const stored = await this.storage.getItem(getCollectionStorageKey(contractType));
-        if (!stored)
-            return [];
-        try {
-            const collection = JSON.parse(stored);
-            return collection;
-        }
-        catch (error) {
-            console.error(`Failed to parse contract collection ${contractType}:`, error);
-            return [];
-        }
-    }
-    async saveToContractCollection(contractType, item, idField) {
-        const collection = await this.getContractCollection(contractType);
-        // Validate that the item has the required id field
-        const itemId = item[idField];
-        if (itemId === undefined || itemId === null) {
-            throw new Error(`Item is missing required field '${String(idField)}'`);
-        }
-        // Find existing item index without mutating the original collection
-        const existingIndex = collection.findIndex((i) => i[idField] === itemId);
-        // Build new collection without mutating the cached one
-        let newCollection;
-        if (existingIndex !== -1) {
-            // Replace existing item
-            newCollection = [
-                ...collection.slice(0, existingIndex),
-                item,
-                ...collection.slice(existingIndex + 1),
-            ];
-        }
-        else {
-            // Add new item
-            newCollection = [...collection, item];
-        }
-        try {
-            await this.storage.setItem(getCollectionStorageKey(contractType), JSON.stringify(newCollection));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract collection ${contractType}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async removeFromContractCollection(contractType, id, idField) {
-        // Validate input parameters
-        if (id === undefined || id === null) {
-            throw new Error(`Invalid id provided for removal: ${String(id)}`);
-        }
-        const collection = await this.getContractCollection(contractType);
-        // Build new collection without the specified item
-        const filtered = collection.filter((item) => item[idField] !== id);
-        try {
-            await this.storage.setItem(getCollectionStorageKey(contractType), JSON.stringify(filtered));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract collection removal for ${contractType}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async clearContractData() {
-        await this.storage.clear();
-    }
-}
-exports.ContractRepositoryImpl = ContractRepositoryImpl;

package/dist/cjs/repositories/inMemory/contractRepository.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryContractRepository = void 0;
+/**
+ * In-memory implementation of ContractRepository.
+ * Data is ephemeral and scoped to the instance.
+ */
+class InMemoryContractRepository {
+    constructor() {
+        this.version = 1;
+        this.contractData = new Map();
+        this.collections = new Map();
+        this.contractsByScript = new Map();
+    }
+    async clear() {
+        this.contractData.clear();
+        this.collections.clear();
+        this.contractsByScript.clear();
+    }
+    // Contract entity management methods
+    async getContracts(filter) {
+        const contracts = this.contractsByScript.values();
+        if (!filter) {
+            return [...contracts];
+        }
+        const matches = (value, criterion) => {
+            if (criterion === undefined) {
+                return true;
+            }
+            return Array.isArray(criterion)
+                ? criterion.includes(value)
+                : value === criterion;
+        };
+        const results = [];
+        for (const contract of contracts) {
+            if (matches(contract.script, filter.script) &&
+                matches(contract.state, filter.state) &&
+                matches(contract.type, filter.type)) {
+                results.push(contract);
+            }
+        }
+        return results;
+    }
+    async saveContract(contract) {
+        this.contractsByScript.set(contract.script, contract);
+    }
+    async deleteContract(script) {
+        this.contractsByScript.delete(script);
+    }
+    async [Symbol.asyncDispose]() {
+        // nothing to dispose, data is ephemeral and scoped to the instance
+        return;
+    }
+}
+exports.InMemoryContractRepository = InMemoryContractRepository;

package/dist/cjs/repositories/inMemory/walletRepository.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryWalletRepository = void 0;
+/**
+ * In-memory implementation of WalletRepository.
+ * Data is ephemeral and scoped to the instance.
+ */
+class InMemoryWalletRepository {
+    constructor() {
+        this.version = 1;
+        this.vtxosByAddress = new Map();
+        this.utxosByAddress = new Map();
+        this.txsByAddress = new Map();
+        this.walletState = null;
+    }
+    async getVtxos(address) {
+        return this.vtxosByAddress.get(address) ?? [];
+    }
+    async saveVtxos(address, vtxos) {
+        const existing = this.vtxosByAddress.get(address) ?? [];
+        const next = mergeByKey(existing, vtxos, (item) => `${item.txid}:${item.vout}`);
+        this.vtxosByAddress.set(address, next);
+    }
+    async deleteVtxos(address) {
+        this.vtxosByAddress.delete(address);
+    }
+    async getUtxos(address) {
+        return this.utxosByAddress.get(address) ?? [];
+    }
+    async saveUtxos(address, utxos) {
+        const existing = this.utxosByAddress.get(address) ?? [];
+        const next = mergeByKey(existing, utxos, (item) => `${item.txid}:${item.vout}`);
+        this.utxosByAddress.set(address, next);
+    }
+    async deleteUtxos(address) {
+        this.utxosByAddress.delete(address);
+    }
+    async getTransactionHistory(address) {
+        return this.txsByAddress.get(address) ?? [];
+    }
+    async saveTransactions(address, txs) {
+        const existing = this.txsByAddress.get(address) ?? [];
+        const next = mergeByKey(existing, txs, serializeTxKey);
+        this.txsByAddress.set(address, next);
+    }
+    async deleteTransactions(address) {
+        this.txsByAddress.delete(address);
+    }
+    async getWalletState() {
+        return this.walletState;
+    }
+    async saveWalletState(state) {
+        this.walletState = state;
+    }
+    async clear() {
+        this.vtxosByAddress.clear();
+        this.utxosByAddress.clear();
+        this.txsByAddress.clear();
+        this.walletState = null;
+    }
+    async [Symbol.asyncDispose]() {
+        // nothing to dispose, data is ephemeral and scoped to the instance
+        return;
+    }
+}
+exports.InMemoryWalletRepository = InMemoryWalletRepository;
+function serializeTxKey(tx) {
+    const key = tx.key;
+    return `${key.boardingTxid}:${key.commitmentTxid}:${key.arkTxid}`;
+}
+function mergeByKey(existing, incoming, toKey) {
+    const next = new Map();
+    existing.forEach((item) => {
+        next.set(toKey(item), item);
+    });
+    incoming.forEach((item) => {
+        next.set(toKey(item), item);
+    });
+    return Array.from(next.values());
+}

package/dist/cjs/repositories/index.js

@@ -14,5 +14,21 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractRepositoryImpl = exports.WalletRepositoryImpl = exports.rollbackMigration = exports.getMigrationStatus = exports.requiresMigration = exports.migrateWalletRepository = exports.MIGRATION_KEY = void 0;
 __exportStar(require("./walletRepository"), exports);
 __exportStar(require("./contractRepository"), exports);
+__exportStar(require("./inMemory/walletRepository"), exports);
+__exportStar(require("./inMemory/contractRepository"), exports);
+__exportStar(require("./indexedDB/contractRepository"), exports);
+__exportStar(require("./indexedDB/walletRepository"), exports);
+var fromStorageAdapter_1 = require("./migrations/fromStorageAdapter");
+Object.defineProperty(exports, "MIGRATION_KEY", { enumerable: true, get: function () { return fromStorageAdapter_1.MIGRATION_KEY; } });
+Object.defineProperty(exports, "migrateWalletRepository", { enumerable: true, get: function () { return fromStorageAdapter_1.migrateWalletRepository; } });
+Object.defineProperty(exports, "requiresMigration", { enumerable: true, get: function () { return fromStorageAdapter_1.requiresMigration; } });
+Object.defineProperty(exports, "getMigrationStatus", { enumerable: true, get: function () { return fromStorageAdapter_1.getMigrationStatus; } });
+Object.defineProperty(exports, "rollbackMigration", { enumerable: true, get: function () { return fromStorageAdapter_1.rollbackMigration; } });
+// Deprecated
+var walletRepositoryImpl_1 = require("./migrations/walletRepositoryImpl");
+Object.defineProperty(exports, "WalletRepositoryImpl", { enumerable: true, get: function () { return walletRepositoryImpl_1.WalletRepositoryImpl; } });
+var contractRepositoryImpl_1 = require("./migrations/contractRepositoryImpl");
+Object.defineProperty(exports, "ContractRepositoryImpl", { enumerable: true, get: function () { return contractRepositoryImpl_1.ContractRepositoryImpl; } });

package/dist/cjs/repositories/indexedDB/contractRepository.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDBContractRepository = void 0;
+const db_1 = require("./db");
+const manager_1 = require("../../db/manager");
+const schema_1 = require("./schema");
+const utils_1 = require("../../worker/browser/utils");
+/**
+ * IndexedDB-based implementation of ContractRepository.
+ *
+ * Data is stored as JSON strings in key/value stores.
+ */
+class IndexedDBContractRepository {
+    constructor(dbName = utils_1.DEFAULT_DB_NAME) {
+        this.dbName = dbName;
+        this.version = 1;
+        this.db = null;
+    }
+    async clear() {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([db_1.STORE_CONTRACTS], "readwrite");
+                const contractDataStore = transaction.objectStore(db_1.STORE_CONTRACTS);
+                const contractsStore = transaction.objectStore(db_1.STORE_CONTRACTS);
+                const contractDataRequest = contractDataStore.clear();
+                const contractsRequest = contractsStore.clear();
+                let completed = 0;
+                const checkComplete = () => {
+                    completed++;
+                    if (completed === 2) {
+                        resolve();
+                    }
+                };
+                contractDataRequest.onsuccess = checkComplete;
+                contractsRequest.onsuccess = checkComplete;
+                contractDataRequest.onerror = () => reject(contractDataRequest.error);
+                contractsRequest.onerror = () => reject(contractsRequest.error);
+            });
+        }
+        catch (error) {
+            console.error("Failed to clear contract data:", error);
+            throw error;
+        }
+    }
+    async getContracts(filter) {
+        try {
+            const db = await this.getDB();
+            const store = db
+                .transaction([db_1.STORE_CONTRACTS], "readonly")
+                .objectStore(db_1.STORE_CONTRACTS);
+            if (!filter || Object.keys(filter).length === 0) {
+                return new Promise((resolve, reject) => {
+                    const request = store.getAll();
+                    request.onerror = () => reject(request.error);
+                    request.onsuccess = () => resolve(request.result ?? []);
+                });
+            }
+            const normalizedFilter = normalizeFilter(filter);
+            // first by script, primary key
+            if (normalizedFilter.has("script")) {
+                const scripts = normalizedFilter.get("script");
+                const contracts = await Promise.all(scripts.map((script) => new Promise((resolve, reject) => {
+                    const req = store.get(script);
+                    req.onerror = () => reject(req.error);
+                    req.onsuccess = () => resolve(req.result);
+                })));
+                return this.applyContractFilter(contracts, normalizedFilter);
+            }
+            // by state, still an index
+            if (normalizedFilter.has("state")) {
+                const contracts = await this.getContractsByIndexValues(store, "state", normalizedFilter.get("state"));
+                return this.applyContractFilter(contracts, normalizedFilter);
+            }
+            // by type, still an index
+            if (normalizedFilter.has("type")) {
+                const contracts = await this.getContractsByIndexValues(store, "type", normalizedFilter.get("type"));
+                return this.applyContractFilter(contracts, normalizedFilter);
+            }
+            // any other filtering happens in-memory
+            const allContracts = await new Promise((resolve, reject) => {
+                const request = store.getAll();
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve(request.result ?? []);
+            });
+            return this.applyContractFilter(allContracts, normalizedFilter);
+        }
+        catch (error) {
+            console.error("Failed to get contracts:", error);
+            return [];
+        }
+    }
+    async saveContract(contract) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([db_1.STORE_CONTRACTS], "readwrite");
+                const store = transaction.objectStore(db_1.STORE_CONTRACTS);
+                const request = store.put(contract);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve();
+            });
+        }
+        catch (error) {
+            console.error("Failed to save contract:", error);
+            throw error;
+        }
+    }
+    async deleteContract(script) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([db_1.STORE_CONTRACTS], "readwrite");
+                const store = transaction.objectStore(db_1.STORE_CONTRACTS);
+                const getRequest = store.get(script);
+                getRequest.onerror = () => reject(getRequest.error);
+                getRequest.onsuccess = () => {
+                    const request = store.delete(script);
+                    request.onerror = () => reject(request.error);
+                    request.onsuccess = () => resolve();
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to delete contract ${script}:`, error);
+            throw error;
+        }
+    }
+    getContractsByIndexValues(store, indexName, values) {
+        if (values.length === 0)
+            return Promise.resolve([]);
+        const index = store.index(indexName);
+        const requests = values.map((value) => new Promise((resolve, reject) => {
+            const request = index.getAll(value);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result ?? []);
+        }));
+        return Promise.all(requests).then((results) => results.flatMap((result) => result));
+    }
+    applyContractFilter(
+    // can filter directly the result of a query
+    contracts, filter) {
+        return contracts.filter((contract) => {
+            if (contract === undefined)
+                return false;
+            if (filter.has("script") &&
+                !filter.get("script")?.includes(contract.script))
+                return false;
+            if (filter.has("state") &&
+                !filter.get("state")?.includes(contract.state))
+                return false;
+            if (filter.has("type") &&
+                !filter.get("type")?.includes(contract.type))
+                return false;
+            return true;
+        });
+    }
+    async getDB() {
+        if (this.db)
+            return this.db;
+        this.db = await (0, manager_1.openDatabase)(this.dbName, db_1.DB_VERSION, schema_1.initDatabase);
+        return this.db;
+    }
+    async [Symbol.asyncDispose]() {
+        if (!this.db)
+            return;
+        await (0, manager_1.closeDatabase)(this.dbName);
+        this.db = null;
+    }
+}
+exports.IndexedDBContractRepository = IndexedDBContractRepository;
+const FILTER_FIELDS = ["script", "state", "type"];
+// Transform all filter fields into an array of values
+function normalizeFilter(filter) {
+    const res = new Map();
+    FILTER_FIELDS.forEach((current) => {
+        if (!filter?.[current])
+            return;
+        if (Array.isArray(filter[current])) {
+            res.set(current, filter[current]);
+        }
+        else {
+            res.set(current, [filter[current]]);
+        }
+    });
+    return res;
+}

package/dist/cjs/repositories/indexedDB/db.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeUtxo = exports.deserializeVtxo = exports.deserializeTapLeaf = exports.serializeUtxo = exports.serializeVtxo = exports.serializeTapLeaf = exports.DB_VERSION = exports.LEGACY_STORE_CONTRACT_COLLECTIONS = exports.STORE_CONTRACTS = exports.STORE_WALLET_STATE = exports.STORE_TRANSACTIONS = exports.STORE_UTXOS = exports.STORE_VTXOS = void 0;
+const base_1 = require("@scure/base");
+const btc_signer_1 = require("@scure/btc-signer");
+const schema_1 = require("./schema");
+Object.defineProperty(exports, "DB_VERSION", { enumerable: true, get: function () { return schema_1.DB_VERSION; } });
+Object.defineProperty(exports, "STORE_CONTRACTS", { enumerable: true, get: function () { return schema_1.STORE_CONTRACTS; } });
+Object.defineProperty(exports, "LEGACY_STORE_CONTRACT_COLLECTIONS", { enumerable: true, get: function () { return schema_1.LEGACY_STORE_CONTRACT_COLLECTIONS; } });
+Object.defineProperty(exports, "STORE_TRANSACTIONS", { enumerable: true, get: function () { return schema_1.STORE_TRANSACTIONS; } });
+Object.defineProperty(exports, "STORE_UTXOS", { enumerable: true, get: function () { return schema_1.STORE_UTXOS; } });
+Object.defineProperty(exports, "STORE_VTXOS", { enumerable: true, get: function () { return schema_1.STORE_VTXOS; } });
+Object.defineProperty(exports, "STORE_WALLET_STATE", { enumerable: true, get: function () { return schema_1.STORE_WALLET_STATE; } });
+const serializeTapLeaf = ([cb, s]) => ({
+    cb: base_1.hex.encode(btc_signer_1.TaprootControlBlock.encode(cb)),
+    s: base_1.hex.encode(s),
+});
+exports.serializeTapLeaf = serializeTapLeaf;
+const serializeVtxo = (v) => ({
+    ...v,
+    tapTree: base_1.hex.encode(v.tapTree),
+    forfeitTapLeafScript: (0, exports.serializeTapLeaf)(v.forfeitTapLeafScript),
+    intentTapLeafScript: (0, exports.serializeTapLeaf)(v.intentTapLeafScript),
+    extraWitness: v.extraWitness?.map(base_1.hex.encode),
+});
+exports.serializeVtxo = serializeVtxo;
+const serializeUtxo = (u) => ({
+    ...u,
+    tapTree: base_1.hex.encode(u.tapTree),
+    forfeitTapLeafScript: (0, exports.serializeTapLeaf)(u.forfeitTapLeafScript),
+    intentTapLeafScript: (0, exports.serializeTapLeaf)(u.intentTapLeafScript),
+    extraWitness: u.extraWitness?.map(base_1.hex.encode),
+});
+exports.serializeUtxo = serializeUtxo;
+const deserializeTapLeaf = (t) => {
+    const cb = btc_signer_1.TaprootControlBlock.decode(base_1.hex.decode(t.cb));
+    const s = base_1.hex.decode(t.s);
+    return [cb, s];
+};
+exports.deserializeTapLeaf = deserializeTapLeaf;
+const deserializeVtxo = (o) => ({
+    ...o,
+    createdAt: new Date(o.createdAt),
+    tapTree: base_1.hex.decode(o.tapTree),
+    forfeitTapLeafScript: (0, exports.deserializeTapLeaf)(o.forfeitTapLeafScript),
+    intentTapLeafScript: (0, exports.deserializeTapLeaf)(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(base_1.hex.decode),
+});
+exports.deserializeVtxo = deserializeVtxo;
+const deserializeUtxo = (o) => ({
+    ...o,
+    tapTree: base_1.hex.decode(o.tapTree),
+    forfeitTapLeafScript: (0, exports.deserializeTapLeaf)(o.forfeitTapLeafScript),
+    intentTapLeafScript: (0, exports.deserializeTapLeaf)(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(base_1.hex.decode),
+});
+exports.deserializeUtxo = deserializeUtxo;