@arkade-os/sdk 0.4.26 → 0.4.28

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

@@ -1,330 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetManager = exports.ReadonlyAssetManager = void 0;
-const asset_1 = require("../extension/asset");
-const address_1 = require("../script/address");
-const asset_2 = require("./asset");
-const extension_1 = require("../extension");
-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.controlAssetId - Optional control asset ID (for reissuable assets)
-     * @param params.metadata - Optional metadata to attach to the asset
-     * @returns Promise resolving to the Arkade transaction ID and asset ID
-     *
-     * @example
-     * ```typescript
-     * // Issue a simple non-reissuable asset
-     * const result = await wallet.assetManager.issue({ amount: 1000 });
-     * console.log('Asset ID:', result.assetId);
-     *
-     * // Issue a reissuable asset with an existing control asset
-     * const result = await wallet.assetManager.issue({
-     *   amount: 1000,
-     *   controlAssetId: 'existingControlAssetId'
-     * });
-     * console.log('Asset ID:', result.assetId);
-     * ```
-     */
-    async issue(params) {
-        if (params.amount <= 0n) {
-            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 + amount);
-            }
-        }
-        const groups = [];
-        // issued asset group
-        const issuedAssetOutput = asset_1.AssetOutput.create(0, 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, 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),
-            },
-            extension_1.Extension.create([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 Arkade transaction ID
-     *
-     * @example
-     * ```typescript
-     * const txid = await wallet.assetManager.reissue({
-     *   assetId: 'def456...',
-     *   amount: 500
-     * });
-     * ```
-     */
-    async reissue(params) {
-        if (params.amount <= 0n) {
-            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 += amount;
-                    continue;
-                }
-                const existing = assetChanges.get(assetId) ?? 0n;
-                assetChanges.set(assetId, existing + 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 += amount;
-                        continue;
-                    }
-                    const existing = assetChanges.get(assetId) ?? 0n;
-                    assetChanges.set(assetId, existing + 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, asset.amount));
-            }
-        }
-        // the total output amount of the asset to reissue = new + (optional) selected amount
-        const totalAssetAmount = assetToReissueAmount + 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, 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),
-            },
-            extension_1.Extension.create([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 Arkade transaction ID
-     *
-     * @example
-     * ```typescript
-     * const txid = await wallet.assetManager.burn({
-     *   assetId: 'abc123...',
-     *   amount: 100
-     * });
-     * ```
-     */
-    async burn(params) {
-        if (params.amount <= 0n) {
-            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 virtual outputs with the asset to burn
-        const { selected: assetCoins } = (0, asset_2.selectCoinsWithAsset)(virtualCoins, params.assetId, 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 + amount);
-            }
-        }
-        // subtract the amount to burn from the asset change
-        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
-        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 + 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, 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),
-            },
-            extension_1.Extension.create([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

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAssetPacket = createAssetPacket;
-exports.selectCoinsWithAsset = selectCoinsWithAsset;
-exports.computeAssetChange = computeAssetChange;
-exports.selectedCoinsToAssetInputs = selectedCoinsToAssetInputs;
-const asset_1 = require("../extension/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, 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, 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, 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 ?? 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;
-    for (const coin of coinsWithAsset) {
-        if (totalAssetAmount >= requiredAmount)
-            break;
-        selected.push(coin);
-        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}`);
-    }
-    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

@@ -1,183 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Batch = void 0;
-const ark_1 = require("../providers/ark");
-const txTree_1 = require("../tree/txTree");
-const base_1 = require("@scure/base");
-/**
- * Batch namespace provides utilities for joining and processing batch session.
- * The batch settlement process involves multiple events, this namespace provides abstractions and types to handle them.
- * @see https://docs.arkadeos.com/learn/pillars/batch-swaps
- * @example
- * ```typescript
- * // use wallet handler or create a custom one
- * const handler = wallet.createBatchHandler(intentId, inputs, expectedRecipients, musig2session);
- *
- * const abortController = new AbortController();
- * // Get event stream from the Arkade provider
- * const eventStream = arkProvider.getEventStream(
- *   abortController.signal,
- *   ['your-topic-1', 'your-topic-2']
- * );
- *
- * // Join the batch and process events
- * try {
- *   const commitmentTxid = await Batch.join(eventStream, handler);
- *   console.log('Batch completed with commitment:', commitmentTxid);
- * } catch (error) {
- *   console.error('Batch processing failed:', error);
- * } finally {
- *   abortController.abort();
- * }
- * ```
- */
-var Batch;
-(function (Batch) {
-    // State machine steps for batch session
-    let Step;
-    (function (Step) {
-        Step["Start"] = "start";
-        Step["BatchStarted"] = "batch_started";
-        Step["TreeSigningStarted"] = "tree_signing_started";
-        Step["TreeNoncesAggregated"] = "tree_nonces_aggregated";
-        Step["BatchFinalization"] = "batch_finalization";
-    })(Step || (Step = {}));
-    /**
-     * Start the state machine that will process the batch events and join a batch.
-     * @param eventIterator - The events stream to process.
-     * @param handler - How to react to events.
-     * @param options - Options.
-     */
-    async function join(eventIterator, handler, options = {}) {
-        const { abortController, skipVtxoTreeSigning = false, eventCallback, } = options;
-        let step = Step.Start;
-        // keep track of tree transactions as they arrive
-        const flatVtxoTree = [];
-        const flatConnectorTree = [];
-        // once everything is collected, the TxTree objects are created
-        let vtxoTree = undefined;
-        let connectorTree = undefined;
-        for await (const event of eventIterator) {
-            if (abortController?.signal.aborted) {
-                throw new Error("canceled");
-            }
-            if (eventCallback) {
-                // don't wait for the callback to complete and ignore errors
-                eventCallback(event).catch(() => { });
-            }
-            switch (event.type) {
-                case ark_1.SettlementEventType.BatchStarted: {
-                    const e = event;
-                    const { skip } = await handler.onBatchStarted(e);
-                    if (!skip) {
-                        step = Step.BatchStarted;
-                        if (skipVtxoTreeSigning) {
-                            // skip TxTree events and musig2 signatures and nonces
-                            step = Step.TreeNoncesAggregated;
-                        }
-                    }
-                    continue;
-                }
-                case ark_1.SettlementEventType.BatchFinalized: {
-                    if (step !== Step.BatchFinalization) {
-                        continue;
-                    }
-                    if (handler.onBatchFinalized) {
-                        await handler.onBatchFinalized(event);
-                    }
-                    return event.commitmentTxid;
-                }
-                case ark_1.SettlementEventType.BatchFailed: {
-                    if (handler.onBatchFailed) {
-                        await handler.onBatchFailed(event);
-                        continue;
-                    }
-                    throw new Error(event.reason);
-                }
-                case ark_1.SettlementEventType.TreeTx: {
-                    if (step !== Step.BatchStarted &&
-                        step !== Step.TreeNoncesAggregated) {
-                        continue;
-                    }
-                    // batchIndex 0 = virtual output tree, batchIndex 1 = connector tree
-                    if (event.batchIndex === 0) {
-                        flatVtxoTree.push(event.chunk);
-                    }
-                    else {
-                        flatConnectorTree.push(event.chunk);
-                    }
-                    if (handler.onTreeTxEvent) {
-                        await handler.onTreeTxEvent(event);
-                    }
-                    continue;
-                }
-                case ark_1.SettlementEventType.TreeSignature: {
-                    if (step !== Step.TreeNoncesAggregated) {
-                        continue;
-                    }
-                    if (!vtxoTree) {
-                        throw new Error("vtxo tree not initialized");
-                    }
-                    // push signature to the virtual output tree
-                    const tapKeySig = base_1.hex.decode(event.signature);
-                    vtxoTree.update(event.txid, (tx) => {
-                        tx.updateInput(0, {
-                            tapKeySig,
-                        });
-                    });
-                    if (handler.onTreeSignatureEvent) {
-                        await handler.onTreeSignatureEvent(event);
-                    }
-                    continue;
-                }
-                case ark_1.SettlementEventType.TreeSigningStarted: {
-                    if (step !== Step.BatchStarted) {
-                        continue;
-                    }
-                    // create virtual output tree from collected chunks
-                    vtxoTree = txTree_1.TxTree.create(flatVtxoTree);
-                    const { skip } = await handler.onTreeSigningStarted(event, vtxoTree);
-                    if (!skip) {
-                        step = Step.TreeSigningStarted;
-                    }
-                    continue;
-                }
-                case ark_1.SettlementEventType.TreeNonces: {
-                    if (step !== Step.TreeSigningStarted) {
-                        continue;
-                    }
-                    const { fullySigned } = await handler.onTreeNonces(event);
-                    if (fullySigned) {
-                        step = Step.TreeNoncesAggregated;
-                    }
-                    continue;
-                }
-                case ark_1.SettlementEventType.BatchFinalization: {
-                    if (step !== Step.TreeNoncesAggregated) {
-                        continue;
-                    }
-                    // Build virtual output tree if it hasn't been built yet
-                    if (!vtxoTree && flatVtxoTree.length > 0) {
-                        vtxoTree = txTree_1.TxTree.create(flatVtxoTree);
-                    }
-                    if (!vtxoTree && !skipVtxoTreeSigning) {
-                        throw new Error("vtxo tree not initialized");
-                    }
-                    // Build connector tree if we have chunks
-                    if (flatConnectorTree.length > 0) {
-                        connectorTree = txTree_1.TxTree.create(flatConnectorTree);
-                    }
-                    await handler.onBatchFinalization(event, vtxoTree, connectorTree);
-                    step = Step.BatchFinalization;
-                    continue;
-                }
-                default:
-                    // unknown event type, continue
-                    continue;
-            }
-        }
-        // iterator closed without finalization, something went wrong
-        throw new Error("event stream closed");
-    }
-    Batch.join = join;
-})(Batch || (exports.Batch = Batch = {}));