@arkade-os/sdk 0.3.13 → 0.4.0-next.1

package/dist/cjs/utils/arkTransaction.js

@@ -4,6 +4,7 @@ exports.buildOffchainTx = buildOffchainTx;
 exports.hasBoardingTxExpired = hasBoardingTxExpired;
 exports.verifyTapscriptSignatures = verifyTapscriptSignatures;
 exports.combineTapscriptSigs = combineTapscriptSigs;
+exports.isValidArkAddress = isValidArkAddress;
 const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
 const base_1 = require("@scure/base");
 const btc_signer_1 = require("@scure/btc-signer");
@@ -13,6 +14,7 @@ const base_2 = require("../script/base");
 const anchor_1 = require("./anchor");
 const unknownFields_1 = require("./unknownFields");
 const transaction_1 = require("./transaction");
+const address_1 = require("../script/address");
 /**
  * Builds an offchain transaction with checkpoint transactions.
  *
@@ -238,3 +240,17 @@ function combineTapscriptSigs(signedTx, originalTx) {
     }
     return originalTx;
 }
+/**
+ * Validates if a given string is a valid Ark address by attempting to decode it.
+ * @param address The Ark address to validate.
+ * @returns True if the address is valid, false otherwise.
+ */
+function isValidArkAddress(address) {
+    try {
+        address_1.ArkAddress.decode(address);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}

package/dist/cjs/utils/transactionHistory.js

@@ -7,6 +7,46 @@ const txKey = {
     boardingTxid: "",
     arkTxid: "",
 };
+function collectAssets(vtxos) {
+    const map = new Map();
+    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);
+            }
+        }
+    }
+    if (map.size === 0)
+        return undefined;
+    return Array.from(map, ([assetId, amount]) => ({ assetId, amount }));
+}
+function subtractAssets(spent, change) {
+    const map = new Map();
+    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);
+            }
+        }
+    }
+    for (const vtxo of spent) {
+        if (vtxo.assets) {
+            for (const a of vtxo.assets) {
+                const current = map.get(a.assetId) ?? 0;
+                const remaining = current - a.amount;
+                if (remaining !== 0) {
+                    map.set(a.assetId, remaining);
+                }
+                else {
+                    map.delete(a.assetId);
+                }
+            }
+        }
+    }
+    if (map.size === 0)
+        return undefined;
+    return Array.from(map, ([assetId, amount]) => ({ assetId, amount }));
+}
 /**
  * Builds the transaction history by analyzing virtual coins (VTXOs), boarding transactions, and ignored commitments.
  * History is sorted from newest to oldest and is composed only of SENT and RECEIVED transactions.
@@ -26,6 +66,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
             // it's translated into a received batch transaction
             if (!commitmentsToIgnore.has(vtxo.virtualStatus.commitmentTxIds[0]) &&
                 fromOldestVtxo.filter((v) => v.settledBy === vtxo.virtualStatus.commitmentTxIds[0]).length === 0) {
+                const assets = collectAssets([vtxo]);
                 received.push({
                     key: {
                         ...txKey,
@@ -36,12 +77,14 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
                     amount: vtxo.value,
                     settled: vtxo.status.isLeaf || vtxo.isSpent,
                     createdAt: vtxo.createdAt.getTime(),
+                    ...(assets && { assets }),
                 });
             }
         }
         else if (fromOldestVtxo.filter((v) => v.arkTxId === vtxo.txid).length === 0) {
             // If this vtxo is preconfirmed and does not spend any other vtxos,
             // it's translated into a received offchain transaction
+            const assets = collectAssets([vtxo]);
             received.push({
                 key: { ...txKey, arkTxid: vtxo.txid },
                 tag: "offchain",
@@ -49,6 +92,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
                 amount: vtxo.value,
                 settled: vtxo.status.isLeaf || vtxo.isSpent,
                 createdAt: vtxo.createdAt.getTime(),
+                ...(assets && { assets }),
             });
         }
         // If the vtxo is spent, it's translated into a sent transaction unless:
@@ -77,6 +121,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
                         ? await getTxCreatedAt(vtxo.arkTxId)
                         : vtxo.createdAt.getTime() + 1;
                 }
+                const assets = subtractAssets(allSpent, changes);
                 sent.push({
                     key: { ...txKey, arkTxid: vtxo.arkTxId },
                     tag: "offchain",
@@ -84,6 +129,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
                     amount: txAmount,
                     settled: true,
                     createdAt: txTime,
+                    ...(assets && { assets }),
                 });
             }
             // If the vtxo is forfeited in a batch and the total sum of forfeited vtxos is bigger than the sum of new vtxos,
@@ -100,6 +146,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
                     // forfeitAmount > settledAmount --> collaborative exit with offchain change
                     // TODO: make this support fees!
                     if (forfeitAmount > settledAmount) {
+                        const assets = subtractAssets(forfeitVtxos, changes);
                         sent.push({
                             key: { ...txKey, commitmentTxid: vtxo.settledBy },
                             tag: "exit",
@@ -107,11 +154,13 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
                             amount: forfeitAmount - settledAmount,
                             settled: true,
                             createdAt: changes[0].createdAt.getTime(),
+                            ...(assets && { assets }),
                         });
                     }
                 }
                 else {
                     // forfeitAmount > 0 && settledAmount == 0 --> collaborative exit without any offchain change
+                    const assets = subtractAssets(forfeitVtxos, []);
                     sent.push({
                         key: { ...txKey, commitmentTxid: vtxo.settledBy },
                         tag: "exit",
@@ -120,6 +169,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
                         settled: true,
                         // TODO: fetch commitment tx with /v1/indexer/commitmentTx/<commitmentTxid> to know when the tx was made
                         createdAt: vtxo.createdAt.getTime() + 1,
+                        ...(assets && { assets }),
                     });
                 }
             }

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

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetManager = exports.ReadonlyAssetManager = void 0;
+const asset_1 = require("../asset");
+const address_1 = require("../script/address");
+const asset_2 = require("./asset");
+const wallet_1 = require("./wallet");
+class ReadonlyAssetManager {
+    constructor(indexer) {
+        this.indexer = indexer;
+    }
+    async getAssetDetails(assetId) {
+        // TODO: rely on db, and fallback to indexer if not found
+        return this.indexer.getAssetDetails(assetId);
+    }
+}
+exports.ReadonlyAssetManager = ReadonlyAssetManager;
+class AssetManager extends ReadonlyAssetManager {
+    constructor(wallet) {
+        super(wallet.indexerProvider);
+        this.wallet = wallet;
+    }
+    /**
+     * Issue a new asset.
+     * @param params - Parameters for asset issuance
+     * @param params.amount - Amount of asset units to issue
+     * @param params.controlAsset - Optional control asset (for reissuable assets)
+     * @param params.metadata - Optional metadata to attach to the asset
+     * @returns Promise resolving to the ark transaction ID and asset ID
+     *
+     * @example
+     * ```typescript
+     * // Issue a simple non-reissuable asset
+     * const result = await wallet.issueAsset({ amount: 1000 });
+     * console.log('Asset ID:', result.assetId);
+     *
+     * // Issue a reissuable asset with a new control asset
+     * const result = await wallet.issueAsset({
+     *   amount: 1000,
+     *   controlAsset: 1 // creates new control asset with amount 1
+     * });
+     * console.log('Control Asset ID:', result.controlAssetId);
+     * console.log('Asset ID:', result.assetId);
+     *
+     * // Issue a reissuable asset with an existing control asset
+     * const result = await wallet.issueAsset({
+     *   amount: 1000,
+     *   controlAsset: 'controlAssetId'
+     * });
+     * console.log('Control Asset ID:', result.controlAssetId);
+     * console.log('Asset ID:', result.assetId);
+     * ```
+     */
+    async issue(params) {
+        if (params.amount <= 0) {
+            throw new Error(`Issue amount must be greater than 0, got ${params.amount}`);
+        }
+        const metadata = castMetadata(params.metadata);
+        const virtualCoins = await this.wallet.getVtxos({
+            withRecoverable: false,
+        });
+        const controlAssetRef = params.controlAssetId
+            ? asset_1.AssetRef.fromId(asset_1.AssetId.fromString(params.controlAssetId))
+            : null;
+        const coinSelection = (0, wallet_1.selectVirtualCoins)(virtualCoins, Number(this.wallet.dustAmount));
+        let totalBtcSelected = 0n;
+        // keep track of asset changes
+        const assetChanges = new Map();
+        for (const coin of coinSelection.inputs) {
+            totalBtcSelected += BigInt(coin.value);
+            if (!coin.assets)
+                continue;
+            for (const { assetId, amount } of coin.assets) {
+                const existing = assetChanges.get(assetId) ?? 0n;
+                assetChanges.set(assetId, existing + BigInt(amount));
+            }
+        }
+        const groups = [];
+        // issued asset group
+        const issuedAssetOutput = asset_1.AssetOutput.create(0, BigInt(params.amount));
+        const issuedAssetGroup = asset_1.AssetGroup.create(null, controlAssetRef, [], [issuedAssetOutput], metadata);
+        groups.push(issuedAssetGroup);
+        // add asset groups for each asset change
+        if (assetChanges.size > 0) {
+            const assetInputs = (0, asset_2.selectedCoinsToAssetInputs)(coinSelection.inputs);
+            for (const [assetId, amount] of assetChanges) {
+                const changeInputs = [];
+                // collect all inputs for the asset change
+                for (const [inputIndex, assets] of assetInputs) {
+                    for (const asset of assets) {
+                        if (asset.assetId !== assetId)
+                            continue;
+                        changeInputs.push(asset_1.AssetInput.create(inputIndex, BigInt(asset.amount)));
+                    }
+                }
+                // add the change asset group
+                groups.push(asset_1.AssetGroup.create(asset_1.AssetId.fromString(assetId), null, changeInputs, [asset_1.AssetOutput.create(0, amount)], []));
+            }
+        }
+        // build transaction outputs
+        const address = await this.wallet.getAddress();
+        const outputAddress = address_1.ArkAddress.decode(address);
+        const outputs = [
+            {
+                script: outputAddress.pkScript,
+                amount: BigInt(totalBtcSelected),
+            },
+            asset_1.Packet.create(groups).txOut(),
+        ];
+        const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(coinSelection.inputs, outputs);
+        return {
+            arkTxId: arkTxid,
+            assetId: asset_1.AssetId.create(arkTxid, 0).toString(),
+        };
+    }
+    /**
+     * Reissue more units of an existing asset.
+     * Requires ownership of the control asset.
+     *
+     * @param params - Parameters for asset reissuance
+     * @param params.assetId - The asset ID to reissue (control asset ID is resolved via getAssetDetails)
+     * @param params.amount - Amount of additional units to issue
+     * @returns Promise resolving to the ark transaction ID
+     *
+     * @example
+     * ```typescript
+     * const txid = await wallet.assetManager.reissue({
+     *   assetId: 'def456...',
+     *   amount: 500
+     * });
+     * ```
+     */
+    async reissue(params) {
+        if (params.amount <= 0) {
+            throw new Error(`Reissuance amount must be greater than 0, got ${params.amount}`);
+        }
+        const { controlAssetId } = await this.getAssetDetails(params.assetId);
+        if (!controlAssetId) {
+            throw new Error(`Asset ${params.assetId} is not reissuable`);
+        }
+        const virtualCoins = await this.wallet.getVtxos({
+            withRecoverable: false,
+        });
+        const assetChanges = new Map();
+        // select control asset inputs
+        const { selected: controlCoins } = (0, asset_2.selectCoinsWithAsset)(virtualCoins, controlAssetId, 1n);
+        let selectedCoins = [...controlCoins];
+        let assetToReissueAmount = 0n;
+        // all control inputs assets go to asset changes, including the control asset itself
+        for (const coin of controlCoins) {
+            if (!coin.assets)
+                continue;
+            for (const { assetId, amount } of coin.assets) {
+                if (assetId === params.assetId) {
+                    assetToReissueAmount += BigInt(amount);
+                    continue;
+                }
+                const existing = assetChanges.get(assetId) ?? 0n;
+                assetChanges.set(assetId, existing + BigInt(amount));
+            }
+        }
+        // select at least dust amount
+        const minBtcNeeded = Number(this.wallet.dustAmount);
+        let totalBtcSelected = selectedCoins.reduce((sum, c) => sum + c.value, 0);
+        if (totalBtcSelected < minBtcNeeded) {
+            const remainingCoins = virtualCoins.filter((c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout));
+            const additional = (0, wallet_1.selectVirtualCoins)(remainingCoins, minBtcNeeded - totalBtcSelected);
+            for (const coin of additional.inputs) {
+                // additional inputs assets go to asset changes
+                if (!coin.assets)
+                    continue;
+                for (const { assetId, amount } of coin.assets) {
+                    if (assetId === params.assetId) {
+                        assetToReissueAmount += BigInt(amount);
+                        continue;
+                    }
+                    const existing = assetChanges.get(assetId) ?? 0n;
+                    assetChanges.set(assetId, existing + BigInt(amount));
+                }
+            }
+            selectedCoins = [...selectedCoins, ...additional.inputs];
+            totalBtcSelected += additional.inputs.reduce((sum, c) => sum + c.value, 0);
+        }
+        const assetInputs = (0, asset_2.selectedCoinsToAssetInputs)(selectedCoins);
+        // collect all inputs for the asset to reissue
+        const reissueInputs = [];
+        for (const [inputIndex, assets] of assetInputs) {
+            for (const asset of assets) {
+                if (asset.assetId !== params.assetId)
+                    continue;
+                reissueInputs.push(asset_1.AssetInput.create(inputIndex, BigInt(asset.amount)));
+            }
+        }
+        // the total output amount of the asset to reissue = new + (optional) selected amount
+        const totalAssetAmount = assetToReissueAmount + BigInt(params.amount);
+        const reissueAssetIdObj = asset_1.AssetId.fromString(params.assetId);
+        // create the reissuance asset group
+        const reissueAssetGroup = asset_1.AssetGroup.create(reissueAssetIdObj, null, reissueInputs, [asset_1.AssetOutput.create(0, totalAssetAmount)], []);
+        const groups = [reissueAssetGroup];
+        // for each asset change, create a new asset group
+        for (const [assetId, amount] of assetChanges) {
+            const changeInputs = [];
+            for (const [inputIndex, assets] of assetInputs) {
+                for (const asset of assets) {
+                    if (asset.assetId !== assetId)
+                        continue;
+                    changeInputs.push(asset_1.AssetInput.create(inputIndex, BigInt(asset.amount)));
+                }
+            }
+            groups.push(asset_1.AssetGroup.create(asset_1.AssetId.fromString(assetId), null, changeInputs, [asset_1.AssetOutput.create(0, amount)], []));
+        }
+        // build transaction outputs
+        const address = await this.wallet.getAddress();
+        const outputAddress = address_1.ArkAddress.decode(address);
+        const outputs = [
+            {
+                script: outputAddress.pkScript,
+                amount: BigInt(totalBtcSelected),
+            },
+            asset_1.Packet.create(groups).txOut(),
+        ];
+        const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(selectedCoins, outputs);
+        return arkTxid;
+    }
+    /**
+     * Burn assets.
+     * @param params - Parameters for burning
+     * @param params.assetId - The asset ID to burn
+     * @param params.amount - Amount of units to burn
+     * @returns Promise resolving to the ark transaction ID
+     *
+     * @example
+     * ```typescript
+     * const txid = await wallet.assetManager.burn({
+     *   assetId: 'abc123...',
+     *   amount: 100
+     * });
+     * ```
+     */
+    async burn(params) {
+        if (params.amount <= 0) {
+            throw new Error(`Burn amount must be greater than 0, got ${params.amount}`);
+        }
+        const virtualCoins = await this.wallet.getVtxos({
+            withRecoverable: false,
+        });
+        const assetChanges = new Map();
+        // select vtxos with the asset to burn
+        const { selected: assetCoins } = (0, asset_2.selectCoinsWithAsset)(virtualCoins, params.assetId, BigInt(params.amount));
+        const selectedCoins = [...assetCoins];
+        let totalBtcSelected = 0;
+        // add the selected coins to asset changes, including the asset to burn
+        for (const coin of assetCoins) {
+            totalBtcSelected += coin.value;
+            if (!coin.assets)
+                continue;
+            for (const { assetId, amount } of coin.assets) {
+                const existing = assetChanges.get(assetId) ?? 0n;
+                assetChanges.set(assetId, existing + BigInt(amount));
+            }
+        }
+        // subtract the amount to burn from the asset change
+        assetChanges.set(params.assetId, (assetChanges.get(params.assetId) ?? 0n) - BigInt(params.amount));
+        const minBtcNeeded = Number(this.wallet.dustAmount);
+        // we need to ensure at least dust amount is selected
+        // if not, select additional coins
+        if (totalBtcSelected < minBtcNeeded) {
+            const remainingCoins = virtualCoins.filter((c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout));
+            const additional = (0, wallet_1.selectVirtualCoins)(remainingCoins, minBtcNeeded - totalBtcSelected);
+            // additional inputs assets go to asset changes
+            for (const coin of additional.inputs) {
+                totalBtcSelected += coin.value;
+                if (!coin.assets)
+                    continue;
+                for (const { assetId, amount } of coin.assets) {
+                    const existing = assetChanges.get(assetId) ?? 0n;
+                    assetChanges.set(assetId, existing + BigInt(amount));
+                }
+            }
+            selectedCoins.push(...additional.inputs);
+        }
+        const groups = [];
+        const assetInputs = (0, asset_2.selectedCoinsToAssetInputs)(selectedCoins);
+        // for each asset, create a new asset group
+        for (const [assetId, amount] of assetChanges) {
+            const changeInputs = [];
+            for (const [inputIndex, assets] of assetInputs) {
+                for (const asset of assets) {
+                    if (asset.assetId !== assetId)
+                        continue;
+                    changeInputs.push(asset_1.AssetInput.create(inputIndex, BigInt(asset.amount)));
+                }
+            }
+            groups.push(asset_1.AssetGroup.create(asset_1.AssetId.fromString(assetId), null, changeInputs, amount > 0n ? [asset_1.AssetOutput.create(0, amount)] : [], []));
+        }
+        // build transaction outputs
+        const address = await this.wallet.getAddress();
+        const outputAddress = address_1.ArkAddress.decode(address);
+        const outputs = [
+            {
+                script: outputAddress.pkScript,
+                amount: BigInt(totalBtcSelected),
+            },
+            asset_1.Packet.create(groups).txOut(),
+        ];
+        const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(selectedCoins, outputs);
+        return arkTxid;
+    }
+}
+exports.AssetManager = AssetManager;
+function castMetadata(metadata) {
+    if (!metadata) {
+        return [];
+    }
+    const md = [];
+    const textEncoder = new TextEncoder();
+    for (const [key, value] of Object.entries(metadata)) {
+        // convert value to bytes
+        let valueBytes;
+        if (typeof value === "string") {
+            valueBytes = textEncoder.encode(value);
+        }
+        else if (typeof value === "number") {
+            valueBytes = textEncoder.encode(String(value));
+        }
+        else if (value instanceof Uint8Array) {
+            valueBytes = value;
+        }
+        else if (value instanceof ArrayBuffer) {
+            valueBytes = new Uint8Array(value);
+        }
+        else {
+            throw new Error("Invalid metadata value type");
+        }
+        md.push(asset_1.Metadata.create(textEncoder.encode(key), valueBytes));
+    }
+    return md;
+}

package/dist/cjs/wallet/asset.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAssetPacket = createAssetPacket;
+exports.selectCoinsWithAsset = selectCoinsWithAsset;
+exports.computeAssetChange = computeAssetChange;
+exports.selectedCoinsToAssetInputs = selectedCoinsToAssetInputs;
+const asset_1 = require("../asset");
+/**
+ * Creates an asset packet from asset inputs and receivers.
+ * Groups inputs and outputs by asset ID and creates the Packet object
+ * @param assetInputs - map input index -> assets
+ * @param receivers - array of recipients with their asset allocations
+ * @param changeReceiver - (optional) change receiver containing remaining assets
+ * @returns packet containing all asset groups
+ */
+function createAssetPacket(assetInputs, receivers, changeReceiver) {
+    // map inputs by asset id
+    const inputsByAssetId = new Map();
+    for (const [inputIndex, assets] of assetInputs) {
+        for (const asset of assets) {
+            const existing = inputsByAssetId.get(asset.assetId);
+            inputsByAssetId.set(asset.assetId, [
+                ...(existing ?? []),
+                asset_1.AssetInput.create(inputIndex, BigInt(asset.amount)),
+            ]);
+        }
+    }
+    // map outputs by asset id
+    const outputsByAssetId = new Map();
+    // track tx output index
+    let outputIndex = 0;
+    for (const receiver of receivers) {
+        if (receiver.assets) {
+            for (const asset of receiver.assets) {
+                const existing = outputsByAssetId.get(asset.assetId);
+                outputsByAssetId.set(asset.assetId, [
+                    ...(existing ?? []),
+                    asset_1.AssetOutput.create(outputIndex, BigInt(asset.amount)),
+                ]);
+            }
+        }
+        outputIndex++;
+    }
+    // add change receiver assets if present
+    if (changeReceiver?.assets) {
+        for (const asset of changeReceiver.assets) {
+            const existing = outputsByAssetId.get(asset.assetId);
+            outputsByAssetId.set(asset.assetId, [
+                ...(existing ?? []),
+                asset_1.AssetOutput.create(outputIndex, BigInt(asset.amount)),
+            ]);
+        }
+    }
+    const groups = [];
+    // get all unique asset ids from both inputs and outputs
+    const allAssetIds = new Set([
+        ...inputsByAssetId.keys(),
+        ...outputsByAssetId.keys(),
+    ]);
+    for (const assetIdStr of allAssetIds) {
+        const inputs = inputsByAssetId.get(assetIdStr);
+        const outputs = outputsByAssetId.get(assetIdStr);
+        const assetId = asset_1.AssetId.fromString(assetIdStr);
+        const group = asset_1.AssetGroup.create(assetId, null, inputs ?? [], outputs ?? [], []);
+        groups.push(group);
+    }
+    return asset_1.Packet.create(groups);
+}
+/**
+ * Selects coins that contain a specific asset.
+ * Returns coins sorted by amount (smallest first for better coin selection).
+ */
+function selectCoinsWithAsset(coins, assetId, requiredAmount) {
+    // filter only coins that have the specified asset
+    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 selected = [];
+    let totalAssetAmount = 0n;
+    for (const coin of coinsWithAsset) {
+        if (totalAssetAmount >= requiredAmount)
+            break;
+        selected.push(coin);
+        const assetAmount = coin.assets?.find((a) => a.assetId === assetId)?.amount ?? 0;
+        totalAssetAmount += BigInt(assetAmount);
+    }
+    if (totalAssetAmount < requiredAmount) {
+        throw new Error(`Insufficient asset balance: have ${totalAssetAmount}, need ${requiredAmount}`);
+    }
+    return { selected, totalAssetAmount };
+}
+function computeAssetChange(inputAssets, outputAssets) {
+    const change = new Map();
+    for (const [assetId, inputAmount] of inputAssets) {
+        const outputAmount = outputAssets.get(assetId) ?? 0n;
+        const changeAmount = inputAmount - outputAmount;
+        if (changeAmount > 0n) {
+            change.set(assetId, changeAmount);
+        }
+    }
+    return change;
+}
+function selectedCoinsToAssetInputs(selectedCoins) {
+    const assetInputs = new Map();
+    for (let inputIndex = 0; inputIndex < selectedCoins.length; inputIndex++) {
+        const coin = selectedCoins[inputIndex];
+        if (!coin.assets || coin.assets.length === 0) {
+            continue;
+        }
+        assetInputs.set(inputIndex, coin.assets);
+    }
+    return assetInputs;
+}

package/dist/cjs/wallet/batch.js

@@ -11,7 +11,7 @@ const base_1 = require("@scure/base");
  * @example
  * ```typescript
  * // use wallet handler or create a custom one
- * const handler = wallet.createBatchHandler(intentId, inputs, musig2session);
+ * const handler = wallet.createBatchHandler(intentId, inputs, expectedRecipients, musig2session);
  *
  * const abortController = new AbortController();
  * // Get event stream from Ark provider