@arkade-os/sdk 0.4.0-next.2 → 0.4.0-next.3

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetManager = exports.ReadonlyAssetManager = void 0;
-const asset_1 = require("../asset");
+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) {
@@ -24,30 +25,21 @@ class AssetManager extends ReadonlyAssetManager {
      * 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.controlAssetId - Optional control asset ID (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);
+     * 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.issueAsset({
+     * const result = await wallet.assetManager.issue({
      *   amount: 1000,
-     *   controlAsset: 'controlAssetId'
+     *   controlAssetId: 'existingControlAssetId'
      * });
-     * console.log('Control Asset ID:', result.controlAssetId);
      * console.log('Asset ID:', result.assetId);
      * ```
      */
@@ -105,7 +97,7 @@ class AssetManager extends ReadonlyAssetManager {
                 script: outputAddress.pkScript,
                 amount: BigInt(totalBtcSelected),
             },
-            asset_1.Packet.create(groups).txOut(),
+            extension_1.Extension.create([asset_1.Packet.create(groups)]).txOut(),
         ];
         const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(coinSelection.inputs, outputs);
         return {
@@ -217,7 +209,7 @@ class AssetManager extends ReadonlyAssetManager {
                 script: outputAddress.pkScript,
                 amount: BigInt(totalBtcSelected),
             },
-            asset_1.Packet.create(groups).txOut(),
+            extension_1.Extension.create([asset_1.Packet.create(groups)]).txOut(),
         ];
         const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(selectedCoins, outputs);
         return arkTxid;
@@ -301,7 +293,7 @@ class AssetManager extends ReadonlyAssetManager {
                 script: outputAddress.pkScript,
                 amount: BigInt(totalBtcSelected),
             },
-            asset_1.Packet.create(groups).txOut(),
+            extension_1.Extension.create([asset_1.Packet.create(groups)]).txOut(),
         ];
         const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(selectedCoins, outputs);
         return arkTxid;

package/dist/cjs/wallet/asset.js

@@ -4,7 +4,7 @@ exports.createAssetPacket = createAssetPacket;
 exports.selectCoinsWithAsset = selectCoinsWithAsset;
 exports.computeAssetChange = computeAssetChange;
 exports.selectedCoinsToAssetInputs = selectedCoinsToAssetInputs;
-const asset_1 = require("../asset");
+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

package/dist/cjs/wallet/validation.js

@@ -4,7 +4,7 @@ exports.ErrInvalidOffchainOutputAmount = exports.ErrOnchainOutputNotFound = expo
 exports.validateBatchRecipients = validateBatchRecipients;
 const utils_js_1 = require("@scure/btc-signer/utils.js");
 const address_1 = require("../script/address");
-const asset_1 = require("../asset");
+const extension_1 = require("../extension");
 const btc_signer_1 = require("@scure/btc-signer");
 const ErrOffchainOutputNotFound = (address) => new Error(`offchain send output not found: ${address}`);
 exports.ErrOffchainOutputNotFound = ErrOffchainOutputNotFound;
@@ -125,7 +125,11 @@ function validateOffchainRecipient(leaves, arkAddress, recipient, usedOutputs //
     }
 }
 function validateAssetOutputs(leafTx, outputIndex, expectedAssets) {
-    const assetPacket = asset_1.Packet.fromTx(leafTx);
+    const ext = extension_1.Extension.fromTx(leafTx);
+    const assetPacket = ext.getAssetPacket();
+    if (!assetPacket) {
+        throw new Error("no asset packet found in extension");
+    }
     for (const { assetId, amount } of expectedAssets) {
         validateAssetGroupOutput(assetPacket, outputIndex, assetId, amount);
     }

package/dist/cjs/wallet/wallet.js

@@ -30,6 +30,7 @@ const batch_1 = require("./batch");
 const arkfee_1 = require("../arkfee");
 const transactionHistory_1 = require("../utils/transactionHistory");
 const asset_manager_1 = require("./asset-manager");
+const extension_1 = require("../extension");
 const delegate_1 = require("../script/delegate");
 const delegator_1 = require("./delegator");
 const repositories_1 = require("../repositories");
@@ -918,7 +919,7 @@ class Wallet extends ReadonlyWallet {
         }));
         if (outputAssets && outputAssets.length > 0) {
             const assetPacket = (0, asset_1.createAssetPacket)(assetInputs, recipients);
-            outputs.push(assetPacket.txOut());
+            outputs.push(extension_1.Extension.create([assetPacket]).txOut());
         }
         // session holds the state of the musig2 signing process of the vtxo tree
         let session;
@@ -931,15 +932,15 @@ class Wallet extends ReadonlyWallet {
             this.makeRegisterIntentSignature(params.inputs, outputs, onchainOutputIndexes, signingPublicKeys),
             this.makeDeleteIntentSignature(params.inputs),
         ]);
-        const intentId = await this.safeRegisterIntent(intent);
         const topics = [
             ...signingPublicKeys,
             ...params.inputs.map((input) => `${input.txid}:${input.vout}`),
         ];
-        const handler = this.createBatchHandler(intentId, params.inputs, recipients, session);
         const abortController = new AbortController();
         try {
             const stream = this.arkProvider.getEventStream(abortController.signal, topics);
+            const intentId = await this.safeRegisterIntent(intent);
+            const handler = this.createBatchHandler(intentId, params.inputs, recipients, session);
             const commitmentTxid = await batch_1.Batch.join(stream, handler, {
                 abortController,
                 skipVtxoTreeSigning: !hasOffchainOutputs,
@@ -1404,7 +1405,7 @@ class Wallet extends ReadonlyWallet {
             recipients.some((r) => r.assets && r.assets.length > 0);
         if (hasAssets) {
             const assetPacket = (0, asset_1.createAssetPacket)(assetInputs, recipients, changeReceiver);
-            outputs.push(assetPacket.txOut());
+            outputs.push(extension_1.Extension.create([assetPacket]).txOut());
         }
         const sentAmount = recipients.reduce((sum, r) => sum + r.amount, 0);
         const { arkTxid, signedCheckpointTxs } = await this.buildAndSubmitOffchainTx(selectedCoins, outputs);

package/dist/esm/{asset → extension/asset}/index.js

@@ -5,4 +5,4 @@ export { AssetInput, AssetInputs } from './assetInput.js';
 export { AssetOutput, AssetOutputs } from './assetOutput.js';
 export { Metadata, MetadataList } from './metadata.js';
 export { AssetGroup } from './assetGroup.js';
-export { Packet, AssetPacketNotFoundError } from './packet.js';
+export { Packet } from './packet.js';

package/dist/esm/extension/asset/packet.js

@@ -0,0 +1,107 @@
+import { hex } from "@scure/base";
+import { AssetRefType } from './types.js';
+import { AssetGroup } from './assetGroup.js';
+import { BufferReader, BufferWriter } from './utils.js';
+/**
+ * Packet represents a collection of asset groups.
+ * It encodes/decodes as raw bytes only — OP_RETURN framing is handled by the Extension module.
+ */
+export class Packet {
+    constructor(groups) {
+        this.groups = groups;
+    }
+    static create(groups) {
+        const p = new Packet(groups);
+        p.validate();
+        return p;
+    }
+    /**
+     * fromBytes parses a Packet from raw bytes.
+     */
+    static fromBytes(buf) {
+        return Packet.fromReader(new BufferReader(buf));
+    }
+    /**
+     * fromString parses a Packet from a raw hex string (not an OP_RETURN script).
+     */
+    static fromString(s) {
+        if (!s) {
+            throw new Error("missing packet data");
+        }
+        let buf;
+        try {
+            buf = hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid packet format, must be hex");
+        }
+        return Packet.fromBytes(buf);
+    }
+    /**
+     * type returns the TLV packet type tag. Implements ExtensionPacket interface.
+     */
+    type() {
+        return Packet.PACKET_TYPE;
+    }
+    leafTxPacket(intentTxid) {
+        const leafGroups = this.groups.map((group) => group.toBatchLeafAssetGroup(intentTxid));
+        return new Packet(leafGroups);
+    }
+    /**
+     * serialize encodes the packet as raw bytes (varint group count + group data).
+     * Does NOT include OP_RETURN, ARK magic, or TLV type/length — those are
+     * added by the Extension module.
+     */
+    serialize() {
+        if (this.groups.length === 0) {
+            return new Uint8Array(0);
+        }
+        const writer = new BufferWriter();
+        writer.writeVarUint(this.groups.length);
+        for (const group of this.groups) {
+            group.serializeTo(writer);
+        }
+        return writer.toBytes();
+    }
+    /**
+     * toString returns the hex-encoded raw packet bytes.
+     */
+    toString() {
+        return hex.encode(this.serialize());
+    }
+    validate() {
+        if (this.groups.length === 0) {
+            throw new Error("missing assets");
+        }
+        const seenAssetIds = new Set();
+        for (const group of this.groups) {
+            if (group.assetId !== null) {
+                const key = group.assetId.toString();
+                if (seenAssetIds.has(key)) {
+                    throw new Error(`duplicate asset group for asset ${key}`);
+                }
+                seenAssetIds.add(key);
+            }
+            if (group.controlAsset !== null &&
+                group.controlAsset.ref.type === AssetRefType.ByGroup &&
+                group.controlAsset.ref.groupIndex >= this.groups.length) {
+                throw new Error(`invalid control asset group index, ${group.controlAsset.ref.groupIndex} out of range [0, ${this.groups.length - 1}]`);
+            }
+        }
+    }
+    static fromReader(reader) {
+        const count = Number(reader.readVarUint());
+        const groups = [];
+        for (let i = 0; i < count; i++) {
+            groups.push(AssetGroup.fromReader(reader));
+        }
+        if (reader.remaining() > 0) {
+            throw new Error(`invalid packet length, left ${reader.remaining()} unknown bytes to read`);
+        }
+        const packet = new Packet(groups);
+        packet.validate();
+        return packet;
+    }
+}
+/** PACKET_TYPE is the 1-byte TLV type tag used in the Extension envelope. */
+Packet.PACKET_TYPE = 0;

package/dist/esm/{asset → extension/asset}/types.js

@@ -17,6 +17,3 @@ export var AssetRefType;
 export const MASK_ASSET_ID = 0x01;
 export const MASK_CONTROL_ASSET = 0x02;
 export const MASK_METADATA = 0x04;
-// ARK magic bytes and marker
-export const ARKADE_MAGIC = new Uint8Array([0x41, 0x52, 0x4b]); // "ARK"
-export const MARKER_ASSET_PAYLOAD = 0x00;

package/dist/esm/extension/index.js

@@ -0,0 +1,248 @@
+import { hex } from "@scure/base";
+import { Script } from "@scure/btc-signer";
+import { equalBytes } from "@scure/btc-signer/utils.js";
+import { Packet } from './asset/packet.js';
+import { BufferReader } from './asset/utils.js';
+import { UnknownPacket } from './packet.js';
+export { UnknownPacket } from './packet.js';
+/**
+ * ArkadeMagic is the 3-byte magic prefix ("ARK") that identifies an OP_RETURN
+ * output as an ark extension blob.
+ */
+export const ARKADE_MAGIC = new Uint8Array([0x41, 0x52, 0x4b]); // "ARK"
+/**
+ * ErrExtensionNotFound is thrown when no extension output is found in a transaction.
+ */
+export class ExtensionNotFoundError extends Error {
+    constructor() {
+        super("no extension output found in transaction");
+        this.name = "ExtensionNotFoundError";
+    }
+}
+/**
+ * Extension is a set of typed packets encoded in an OP_RETURN output.
+ *
+ * Wire format:
+ *   OP_RETURN | <push> | ARK(3B) | [type(1B) | varint_len | data]...
+ */
+export class Extension {
+    constructor(packets) {
+        this.packets = packets;
+    }
+    static create(packets) {
+        if (packets.length === 0) {
+            throw new Error("missing packets");
+        }
+        const seen = new Set();
+        for (const p of packets) {
+            if (seen.has(p.type())) {
+                throw new Error(`duplicate packet type ${p.type()}`);
+            }
+            seen.add(p.type());
+        }
+        return new Extension(packets);
+    }
+    /**
+     * isExtension returns true if the script is an OP_RETURN whose push data
+     * begins with the ARK magic bytes.
+     */
+    static isExtension(script) {
+        try {
+            const decoded = Script.decode(script);
+            if (decoded.length < 2 || decoded[0] !== "RETURN")
+                return false;
+            const data = decoded[1];
+            if (!(data instanceof Uint8Array))
+                return false;
+            return (data.length >= ARKADE_MAGIC.length &&
+                equalBytes(data.slice(0, ARKADE_MAGIC.length), ARKADE_MAGIC));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * fromBytes parses an Extension from a raw OP_RETURN script.
+     */
+    static fromBytes(script) {
+        if (!script || script.length === 0) {
+            throw new Error("missing OP_RETURN");
+        }
+        let decoded;
+        try {
+            decoded = Script.decode(script);
+        }
+        catch {
+            throw new Error("expected OP_RETURN");
+        }
+        if (decoded.length === 0 || decoded[0] !== "RETURN") {
+            throw new Error("expected OP_RETURN");
+        }
+        const dataPushes = decoded
+            .slice(1)
+            .filter((x) => x instanceof Uint8Array);
+        if (dataPushes.length === 0) {
+            throw new Error("missing magic prefix: EOF");
+        }
+        // Concatenate all data pushes (handles OP_PUSHDATA1/2/4)
+        const payload = new Uint8Array(dataPushes.reduce((acc, d) => acc + d.length, 0));
+        let offset = 0;
+        for (const d of dataPushes) {
+            payload.set(d, offset);
+            offset += d.length;
+        }
+        // Check ARK magic
+        if (payload.length < ARKADE_MAGIC.length ||
+            !equalBytes(payload.slice(0, ARKADE_MAGIC.length), ARKADE_MAGIC)) {
+            throw new Error(`expected magic prefix ${hex.encode(ARKADE_MAGIC)}, got ${hex.encode(payload.slice(0, Math.min(payload.length, ARKADE_MAGIC.length)))}`);
+        }
+        // Parse TLV records
+        const reader = new BufferReader(payload.slice(ARKADE_MAGIC.length));
+        const packets = [];
+        while (reader.remaining() > 0) {
+            const packetType = reader.readByte();
+            let data;
+            try {
+                data = reader.readVarSlice();
+            }
+            catch {
+                throw new Error("missing packet data");
+            }
+            packets.push(parsePacket(packetType, data));
+        }
+        if (packets.length === 0) {
+            throw new Error("missing packets");
+        }
+        // Reject duplicate packet types
+        const seen = new Set();
+        for (const p of packets) {
+            if (seen.has(p.type())) {
+                throw new Error(`duplicate packet type ${p.type()}`);
+            }
+            seen.add(p.type());
+        }
+        return new Extension(packets);
+    }
+    /**
+     * fromTx searches the transaction outputs for an extension blob and parses it.
+     * Throws ExtensionNotFoundError if none is found.
+     */
+    static fromTx(tx) {
+        for (let i = 0; i < tx.outputsLength; i++) {
+            const output = tx.getOutput(i);
+            if (!output?.script)
+                continue;
+            if (Extension.isExtension(output.script)) {
+                return Extension.fromBytes(output.script);
+            }
+        }
+        throw new ExtensionNotFoundError();
+    }
+    /**
+     * serialize encodes the extension as an OP_RETURN script.
+     *
+     * Layout: OP_RETURN | <push> | ARK | [type | varint_len | data]...
+     */
+    serialize() {
+        // Build payload: ARK magic + TLV records
+        const parts = [ARKADE_MAGIC];
+        for (const p of this.packets) {
+            const data = p.serialize();
+            // type (1 byte)
+            const typeByte = new Uint8Array([p.type()]);
+            // varint length prefix + data
+            const lengthBuf = encodeVarUint(data.length);
+            parts.push(typeByte, lengthBuf, data);
+        }
+        const totalLen = parts.reduce((acc, p) => acc + p.length, 0);
+        const payload = new Uint8Array(totalLen);
+        let off = 0;
+        for (const p of parts) {
+            payload.set(p, off);
+            off += p.length;
+        }
+        return buildOpReturnScript(payload);
+    }
+    /**
+     * txOut returns the extension as a zero-value OP_RETURN transaction output.
+     */
+    txOut() {
+        return {
+            script: this.serialize(),
+            amount: 0n,
+        };
+    }
+    /**
+     * getAssetPacket returns the embedded Packet, or null if not present.
+     */
+    getAssetPacket() {
+        for (const p of this.packets) {
+            if (p instanceof Packet) {
+                return p;
+            }
+        }
+        return null;
+    }
+}
+/**
+ * parsePacket dispatches to a known packet type or falls back to UnknownPacket.
+ */
+function parsePacket(packetType, data) {
+    if (packetType === Packet.PACKET_TYPE) {
+        return Packet.fromBytes(data);
+    }
+    return new UnknownPacket(packetType, data);
+}
+/**
+ * encodeVarUint encodes a non-negative integer as a LEB128 unsigned varint.
+ */
+function encodeVarUint(value) {
+    const bytes = [];
+    let remaining = value;
+    do {
+        let byte = remaining & 0x7f;
+        remaining >>>= 7;
+        if (remaining > 0)
+            byte |= 0x80;
+        bytes.push(byte);
+    } while (remaining > 0);
+    return new Uint8Array(bytes);
+}
+/**
+ * buildOpReturnScript builds an OP_RETURN script with an arbitrary-length data push.
+ * Manually constructed to avoid the 520-byte cap in some script builders.
+ *
+ * Opcodes: 0x6a=OP_RETURN, 0x4c=OP_PUSHDATA1, 0x4d=OP_PUSHDATA2, 0x4e=OP_PUSHDATA4
+ */
+function buildOpReturnScript(data) {
+    const n = data.length;
+    let script;
+    if (n <= 75) {
+        script = new Uint8Array(2 + n);
+        script[0] = 0x6a; // OP_RETURN
+        script[1] = n;
+        script.set(data, 2);
+    }
+    else if (n <= 255) {
+        script = new Uint8Array(3 + n);
+        script[0] = 0x6a;
+        script[1] = 0x4c; // OP_PUSHDATA1
+        script[2] = n;
+        script.set(data, 3);
+    }
+    else if (n <= 65535) {
+        script = new Uint8Array(4 + n);
+        script[0] = 0x6a;
+        script[1] = 0x4d; // OP_PUSHDATA2
+        new DataView(script.buffer).setUint16(2, n, true);
+        script.set(data, 4);
+    }
+    else {
+        script = new Uint8Array(6 + n);
+        script[0] = 0x6a;
+        script[1] = 0x4e; // OP_PUSHDATA4
+        new DataView(script.buffer).setUint32(2, n, true);
+        script.set(data, 6);
+    }
+    return script;
+}

package/dist/esm/extension/packet.js

@@ -0,0 +1,16 @@
+/**
+ * UnknownPacket holds a packet whose type is not recognized by this implementation.
+ * It round-trips opaquely: the raw bytes are preserved as-is.
+ */
+export class UnknownPacket {
+    constructor(packetType, data) {
+        this.packetType = packetType;
+        this.data = data;
+    }
+    type() {
+        return this.packetType;
+    }
+    serialize() {
+        return this.data;
+    }
+}

package/dist/esm/index.js

@@ -35,7 +35,7 @@ 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';
+export * as asset from './extension/asset/index.js';
 // Contracts
 import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, } from './contracts/index.js';
 import { closeDatabase, openDatabase } from './repositories/indexedDB/manager.js';

package/dist/esm/providers/ark.js

@@ -221,54 +221,69 @@ export class RestArkProvider {
             handleError(errorText, `Failed to submit forfeit transactions: ${response.statusText}`);
         }
     }
-    async *getEventStream(signal, topics) {
+    getEventStream(signal, topics) {
         const url = `${this.serverUrl}/v1/batch/events`;
         const queryParams = topics.length > 0
             ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}`
             : "";
-        while (!signal?.aborted) {
-            try {
-                const eventSource = new EventSource(url + queryParams);
-                // Set up abort handling
-                const abortHandler = () => {
-                    eventSource.close();
-                };
-                signal?.addEventListener("abort", abortHandler);
+        // Create first EventSource eagerly so events are buffered
+        // before the caller starts iterating, preventing race conditions
+        // where the server emits events before iteration begins.
+        const eagerEventSource = new EventSource(url + queryParams);
+        const eagerIterator = eventSourceIterator(eagerEventSource);
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return (async function* () {
+            let firstIteration = true;
+            while (!signal?.aborted) {
+                const eventSource = firstIteration
+                    ? eagerEventSource
+                    : new EventSource(url + queryParams);
+                const iterator = firstIteration
+                    ? eagerIterator
+                    : eventSourceIterator(eventSource);
+                firstIteration = false;
                 try {
-                    for await (const event of eventSourceIterator(eventSource)) {
-                        if (signal?.aborted)
-                            break;
-                        try {
-                            const data = JSON.parse(event.data);
-                            const settlementEvent = this.parseSettlementEvent(data);
-                            if (settlementEvent) {
-                                yield settlementEvent;
+                    const abortHandler = () => {
+                        eventSource.close();
+                    };
+                    signal?.addEventListener("abort", abortHandler);
+                    try {
+                        for await (const event of iterator) {
+                            if (signal?.aborted)
+                                break;
+                            try {
+                                const data = JSON.parse(event.data);
+                                const settlementEvent = self.parseSettlementEvent(data);
+                                if (settlementEvent) {
+                                    yield settlementEvent;
+                                }
+                            }
+                            catch (err) {
+                                console.error("Failed to parse event:", err);
+                                throw err;
                             }
-                        }
-                        catch (err) {
-                            console.error("Failed to parse event:", err);
-                            throw err;
                         }
                     }
+                    finally {
+                        signal?.removeEventListener("abort", abortHandler);
+                        eventSource.close();
+                    }
                 }
-                finally {
-                    signal?.removeEventListener("abort", abortHandler);
-                    eventSource.close();
-                }
-            }
-            catch (error) {
-                if (error instanceof Error && error.name === "AbortError") {
-                    break;
-                }
-                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
-                if (isFetchTimeoutError(error)) {
-                    console.debug("Timeout error ignored");
-                    continue;
+                catch (error) {
+                    if (error instanceof Error && error.name === "AbortError") {
+                        break;
+                    }
+                    // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                    if (isFetchTimeoutError(error)) {
+                        console.debug("Timeout error ignored");
+                        continue;
+                    }
+                    console.error("Event stream error:", error);
+                    throw error;
                 }
-                console.error("Event stream error:", error);
-                throw error;
             }
-        }
+        })();
     }
     async *getTransactionsStream(signal) {
         const url = `${this.serverUrl}/v1/txs`;

package/dist/esm/providers/indexer.js

@@ -1,7 +1,7 @@
 import { hex } from "@scure/base";
 import { isFetchTimeoutError } from './ark.js';
 import { eventSourceIterator } from './utils.js';
-import { MetadataList } from '../asset/index.js';
+import { MetadataList } from '../extension/asset/index.js';
 export var IndexerTxType;
 (function (IndexerTxType) {
     IndexerTxType[IndexerTxType["INDEXER_TX_TYPE_UNSPECIFIED"] = 0] = "INDEXER_TX_TYPE_UNSPECIFIED";