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

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";

package/dist/esm/providers/utils.js

@@ -1,4 +1,10 @@
-export async function* eventSourceIterator(eventSource) {
+/**
+ * Creates an async iterator over EventSource messages that attaches listeners
+ * eagerly (at call time) rather than lazily (at first .next() call).
+ * This ensures events are buffered immediately, preventing race conditions
+ * where events arrive before iteration begins.
+ */
+export function eventSourceIterator(eventSource) {
     const messageQueue = [];
     const errorQueue = [];
     let messageResolve = null;
@@ -23,36 +29,40 @@ export async function* eventSourceIterator(eventSource) {
             errorQueue.push(error);
         }
     };
+    // Attach listeners immediately so events are buffered
+    // even before the caller starts iterating
     eventSource.addEventListener("message", messageHandler);
     eventSource.addEventListener("error", errorHandler);
-    try {
-        while (true) {
-            // if we have queued messages, yield the first one, remove it from the queue
-            if (messageQueue.length > 0) {
-                yield messageQueue.shift();
-                continue;
-            }
-            // if we have queued errors, throw the first one, remove it from the queue
-            if (errorQueue.length > 0) {
-                const error = errorQueue.shift();
-                throw error;
-            }
-            // wait for the next message or error
-            const result = await new Promise((resolve, reject) => {
-                messageResolve = resolve;
-                errorResolve = reject;
-            }).finally(() => {
-                messageResolve = null;
-                errorResolve = null;
-            });
-            if (result) {
-                yield result;
+    return (async function* () {
+        try {
+            while (true) {
+                // if we have queued messages, yield the first one, remove it from the queue
+                if (messageQueue.length > 0) {
+                    yield messageQueue.shift();
+                    continue;
+                }
+                // if we have queued errors, throw the first one, remove it from the queue
+                if (errorQueue.length > 0) {
+                    const error = errorQueue.shift();
+                    throw error;
+                }
+                // wait for the next message or error
+                const result = await new Promise((resolve, reject) => {
+                    messageResolve = resolve;
+                    errorResolve = reject;
+                }).finally(() => {
+                    messageResolve = null;
+                    errorResolve = null;
+                });
+                if (result) {
+                    yield result;
+                }
             }
         }
-    }
-    finally {
-        // clean up
-        eventSource.removeEventListener("message", messageHandler);
-        eventSource.removeEventListener("error", errorHandler);
-    }
+        finally {
+            // clean up
+            eventSource.removeEventListener("message", messageHandler);
+            eventSource.removeEventListener("error", errorHandler);
+        }
+    })();
 }

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

@@ -1,6 +1,7 @@
-import { AssetGroup, AssetId, AssetInput, AssetOutput, AssetRef, Metadata, Packet, } from '../asset/index.js';
+import { AssetGroup, AssetId, AssetInput, AssetOutput, AssetRef, Metadata, Packet, } from '../extension/asset/index.js';
 import { ArkAddress } from '../script/address.js';
 import { selectedCoinsToAssetInputs, selectCoinsWithAsset } from './asset.js';
+import { Extension } from '../extension/index.js';
 import { selectVirtualCoins } from './wallet.js';
 export class ReadonlyAssetManager {
     constructor(indexer) {
@@ -20,30 +21,21 @@ export 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);
      * ```
      */
@@ -101,7 +93,7 @@ export class AssetManager extends ReadonlyAssetManager {
                 script: outputAddress.pkScript,
                 amount: BigInt(totalBtcSelected),
             },
-            Packet.create(groups).txOut(),
+            Extension.create([Packet.create(groups)]).txOut(),
         ];
         const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(coinSelection.inputs, outputs);
         return {
@@ -213,7 +205,7 @@ export class AssetManager extends ReadonlyAssetManager {
                 script: outputAddress.pkScript,
                 amount: BigInt(totalBtcSelected),
             },
-            Packet.create(groups).txOut(),
+            Extension.create([Packet.create(groups)]).txOut(),
         ];
         const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(selectedCoins, outputs);
         return arkTxid;
@@ -297,7 +289,7 @@ export class AssetManager extends ReadonlyAssetManager {
                 script: outputAddress.pkScript,
                 amount: BigInt(totalBtcSelected),
             },
-            Packet.create(groups).txOut(),
+            Extension.create([Packet.create(groups)]).txOut(),
         ];
         const { arkTxid } = await this.wallet.buildAndSubmitOffchainTx(selectedCoins, outputs);
         return arkTxid;

package/dist/esm/wallet/asset.js

@@ -1,4 +1,4 @@
-import { AssetGroup, AssetId, AssetInput, AssetOutput, Packet, } from '../asset/index.js';
+import { AssetGroup, AssetId, AssetInput, AssetOutput, Packet, } from '../extension/asset/index.js';
 /**
  * Creates an asset packet from asset inputs and receivers.
  * Groups inputs and outputs by asset ID and creates the Packet object

package/dist/esm/wallet/serviceWorker/wallet.js

@@ -166,12 +166,20 @@ export class ServiceWorkerReadonlyWallet {
     // send a message and wait for a response
     async sendMessage(request) {
         return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                navigator.serviceWorker.removeEventListener("message", messageHandler);
+            };
+            const timeoutId = setTimeout(() => {
+                cleanup();
+                reject(new Error(`Service worker message timed out (${request.type})`));
+            }, 30000);
             const messageHandler = (event) => {
                 const response = event.data;
                 if (request.id !== response.id) {
                     return;
                 }
-                navigator.serviceWorker.removeEventListener("message", messageHandler);
+                cleanup();
                 if (response.error) {
                     reject(response.error);
                 }

package/dist/esm/wallet/validation.js

@@ -1,6 +1,6 @@
 import { equalBytes } from "@scure/btc-signer/utils.js";
 import { ArkAddress } from '../script/address.js';
-import { Packet } from '../asset/index.js';
+import { Extension } from '../extension/index.js';
 import { Address, OutScript } from "@scure/btc-signer";
 export const ErrOffchainOutputNotFound = (address) => new Error(`offchain send output not found: ${address}`);
 export const ErrInvalidAssetOutputAmount = (got, want, assetId) => new Error(`invalid asset output amount for ${assetId}: got ${got}, want ${want}`);
@@ -113,7 +113,11 @@ function validateOffchainRecipient(leaves, arkAddress, recipient, usedOutputs //
     }
 }
 function validateAssetOutputs(leafTx, outputIndex, expectedAssets) {
-    const assetPacket = Packet.fromTx(leafTx);
+    const ext = 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/esm/wallet/wallet.js

@@ -25,6 +25,7 @@ import { Batch } from './batch.js';
 import { Estimator } from '../arkfee/index.js';
 import { buildTransactionHistory } from '../utils/transactionHistory.js';
 import { AssetManager, ReadonlyAssetManager } from './asset-manager.js';
+import { Extension } from '../extension/index.js';
 import { DelegateVtxo } from '../script/delegate.js';
 import { DelegatorManagerImpl } from './delegator.js';
 import { IndexedDBContractRepository, IndexedDBWalletRepository, } from '../repositories/index.js';
@@ -912,7 +913,7 @@ export class Wallet extends ReadonlyWallet {
         }));
         if (outputAssets && outputAssets.length > 0) {
             const assetPacket = createAssetPacket(assetInputs, recipients);
-            outputs.push(assetPacket.txOut());
+            outputs.push(Extension.create([assetPacket]).txOut());
         }
         // session holds the state of the musig2 signing process of the vtxo tree
         let session;
@@ -925,15 +926,15 @@ export 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.join(stream, handler, {
                 abortController,
                 skipVtxoTreeSigning: !hasOffchainOutputs,
@@ -1398,7 +1399,7 @@ export class Wallet extends ReadonlyWallet {
             recipients.some((r) => r.assets && r.assets.length > 0);
         if (hasAssets) {
             const assetPacket = createAssetPacket(assetInputs, recipients, changeReceiver);
-            outputs.push(assetPacket.txOut());
+            outputs.push(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/worker/messageBus.js

@@ -104,8 +104,19 @@ export class MessageBus {
         }
     }
     async waitForInit(config) {
-        if (this.initialized)
-            return;
+        if (this.initialized) {
+            // Stop existing handlers before re-initializing.
+            // This handles the case where CLEAR was called, which nullifies
+            // handler state (readonlyWallet, etc.) without resetting the
+            // initialized flag. Without this, handlers never get start()
+            // called again and all messages fail with "not initialized".
+            //
+            // Clear the flag first so onMessage() rejects incoming messages
+            // during the stop/start window instead of routing them to
+            // half-reset handlers. Restored to true after start() completes.
+            this.initialized = false;
+            await Promise.all(Array.from(this.handlers.values()).map((h) => h.stop().catch(() => { })));
+        }
         const services = await this.buildServicesFn(config);
         // Start all handlers
         for (const updater of this.handlers.values()) {
@@ -165,6 +176,15 @@ export class MessageBus {
         if (!this.initialized) {
             if (this.debug)
                 console.warn("Event received before initialization, dropping", event.data);
+            // Send error response so the caller's promise rejects instead of
+            // hanging forever. This happens when the browser kills and restarts
+            // the service worker — the new instance has initialized=false and
+            // messages arrive before INITIALIZE_MESSAGE_BUS is re-sent.
+            event.source?.postMessage({
+                id,
+                tag: tag ?? "unknown",
+                error: new Error("MessageBus not initialized"),
+            });
             return;
         }
         if (!id || !tag) {

package/dist/types/{asset → extension/asset}/index.d.ts

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

package/dist/types/extension/asset/packet.d.ts

@@ -0,0 +1,38 @@
+import type { ExtensionPacket } from "../packet";
+import { AssetGroup } from "./assetGroup";
+/**
+ * Packet represents a collection of asset groups.
+ * It encodes/decodes as raw bytes only — OP_RETURN framing is handled by the Extension module.
+ */
+export declare class Packet implements ExtensionPacket {
+    readonly groups: AssetGroup[];
+    /** PACKET_TYPE is the 1-byte TLV type tag used in the Extension envelope. */
+    static readonly PACKET_TYPE = 0;
+    private constructor();
+    static create(groups: AssetGroup[]): Packet;
+    /**
+     * fromBytes parses a Packet from raw bytes.
+     */
+    static fromBytes(buf: Uint8Array): Packet;
+    /**
+     * fromString parses a Packet from a raw hex string (not an OP_RETURN script).
+     */
+    static fromString(s: string): Packet;
+    /**
+     * type returns the TLV packet type tag. Implements ExtensionPacket interface.
+     */
+    type(): number;
+    leafTxPacket(intentTxid: Uint8Array): Packet;
+    /**
+     * 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(): Uint8Array;
+    /**
+     * toString returns the hex-encoded raw packet bytes.
+     */
+    toString(): string;
+    validate(): void;
+    private static fromReader;
+}

package/dist/types/{asset → extension/asset}/types.d.ts

@@ -14,5 +14,3 @@ export declare enum AssetRefType {
 export declare const MASK_ASSET_ID = 1;
 export declare const MASK_CONTROL_ASSET = 2;
 export declare const MASK_METADATA = 4;
-export declare const ARKADE_MAGIC: Uint8Array<ArrayBuffer>;
-export declare const MARKER_ASSET_PAYLOAD = 0;

package/dist/types/extension/index.d.ts

@@ -0,0 +1,56 @@
+import { Packet } from "./asset/packet";
+import { ExtensionPacket } from "./packet";
+import type { TransactionOutput } from "@scure/btc-signer/psbt";
+import type { Transaction } from "../utils/transaction";
+export type { ExtensionPacket } from "./packet";
+export { UnknownPacket } from "./packet";
+/**
+ * ArkadeMagic is the 3-byte magic prefix ("ARK") that identifies an OP_RETURN
+ * output as an ark extension blob.
+ */
+export declare const ARKADE_MAGIC: Uint8Array<ArrayBuffer>;
+/**
+ * ErrExtensionNotFound is thrown when no extension output is found in a transaction.
+ */
+export declare class ExtensionNotFoundError extends Error {
+    constructor();
+}
+/**
+ * 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 declare class Extension {
+    private readonly packets;
+    private constructor();
+    static create(packets: ExtensionPacket[]): Extension;
+    /**
+     * isExtension returns true if the script is an OP_RETURN whose push data
+     * begins with the ARK magic bytes.
+     */
+    static isExtension(script: Uint8Array): boolean;
+    /**
+     * fromBytes parses an Extension from a raw OP_RETURN script.
+     */
+    static fromBytes(script: Uint8Array): Extension;
+    /**
+     * fromTx searches the transaction outputs for an extension blob and parses it.
+     * Throws ExtensionNotFoundError if none is found.
+     */
+    static fromTx(tx: Transaction): Extension;
+    /**
+     * serialize encodes the extension as an OP_RETURN script.
+     *
+     * Layout: OP_RETURN | <push> | ARK | [type | varint_len | data]...
+     */
+    serialize(): Uint8Array;
+    /**
+     * txOut returns the extension as a zero-value OP_RETURN transaction output.
+     */
+    txOut(): Required<Pick<TransactionOutput, "script" | "amount">>;
+    /**
+     * getAssetPacket returns the embedded Packet, or null if not present.
+     */
+    getAssetPacket(): Packet | null;
+}

package/dist/types/extension/packet.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ExtensionPacket is the interface that all extension packets must implement.
+ * It mirrors the Go extension.Packet interface.
+ */
+export interface ExtensionPacket {
+    /** type returns the 1-byte packet type tag */
+    type(): number;
+    /** serialize returns the raw bytes of the packet (without type or length prefix) */
+    serialize(): Uint8Array;
+}
+/**
+ * UnknownPacket holds a packet whose type is not recognized by this implementation.
+ * It round-trips opaquely: the raw bytes are preserved as-is.
+ */
+export declare class UnknownPacket implements ExtensionPacket {
+    private readonly packetType;
+    private readonly data;
+    constructor(packetType: number, data: Uint8Array);
+    type(): number;
+    serialize(): Uint8Array;
+}

package/dist/types/index.d.ts

@@ -41,7 +41,7 @@ import { IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletR
 import type { MigrationStatus } from "./repositories";
 import { DelegatorManagerImpl, DelegatorManager } from "./wallet/delegator";
 export * from "./arkfee";
-export * as asset from "./asset";
+export * as asset from "./extension/asset";
 import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract } from "./contracts";
 import type { Contract, ContractVtxo, ContractState, ContractEvent, ContractEventCallback, ContractBalance, ContractWithVtxos, ContractHandler, PathSelection, PathContext, ContractManagerConfig, CreateContractParams, ContractWatcherConfig, ParsedArkContract, DefaultContractParams, DelegateContractParams, VHTLCContractParams } from "./contracts";
 import { IContractManager } from "./contracts/contractManager";

package/dist/types/providers/utils.d.ts

@@ -1 +1,7 @@
+/**
+ * Creates an async iterator over EventSource messages that attaches listeners
+ * eagerly (at call time) rather than lazily (at first .next() call).
+ * This ensures events are buffered immediately, preventing race conditions
+ * where events arrive before iteration begins.
+ */
 export declare function eventSourceIterator(eventSource: EventSource): AsyncGenerator<MessageEvent, void, unknown>;

package/dist/types/wallet/asset-manager.d.ts

@@ -13,30 +13,21 @@ export declare class AssetManager extends ReadonlyAssetManager implements IAsset
      * 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);
      * ```
      */

package/dist/types/wallet/asset.d.ts

@@ -1,4 +1,4 @@
-import { Packet } from "../asset";
+import { Packet } from "../extension/asset";
 import { Asset, Recipient, VirtualCoin } from "./index";
 /**
  * Creates an asset packet from asset inputs and receivers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.4.0-next.1",
+  "version": "0.4.0-next.3",
   "description": "Bitcoin wallet SDK with Taproot and Ark integration",
   "type": "module",
   "main": "./dist/cjs/index.js",