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

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/cjs/worker/browser/service-worker-manager.js

@@ -4,15 +4,111 @@ exports.__resetServiceWorkerManager = void 0;
 exports.setupServiceWorkerOnce = setupServiceWorkerOnce;
 exports.getActiveServiceWorker = getActiveServiceWorker;
 const registrations = new Map();
+let handshakes = new WeakSet();
 function ensureServiceWorkerSupport() {
     if (!("serviceWorker" in navigator)) {
         throw new Error("Service workers are not supported in this browser");
     }
 }
-function registerOnce(path) {
+function debugLog(debug, ...args) {
+    if (debug) {
+        // eslint-disable-next-line no-console
+        console.debug(...args);
+    }
+}
+function normalizeOptions(pathOrOptions) {
+    if (typeof pathOrOptions === "string") {
+        return {
+            path: pathOrOptions,
+            updateViaCache: "none",
+            autoReload: true,
+            debug: false,
+            activationTimeoutMs: 10000,
+        };
+    }
+    return {
+        path: pathOrOptions.path,
+        updateViaCache: pathOrOptions.updateViaCache ?? "none",
+        autoReload: pathOrOptions.autoReload ?? true,
+        onNeedRefresh: pathOrOptions.onNeedRefresh,
+        onUpdated: pathOrOptions.onUpdated,
+        debug: pathOrOptions.debug ?? false,
+        activationTimeoutMs: pathOrOptions.activationTimeoutMs ?? 10000,
+    };
+}
+function sendSkipWaiting(worker, debug) {
+    if (!worker)
+        return;
+    try {
+        worker.postMessage({ type: "SKIP_WAITING" });
+        debugLog(debug, "Sent SKIP_WAITING to waiting service worker");
+    }
+    catch (error) {
+        console.warn("Failed to post SKIP_WAITING to service worker", error);
+    }
+}
+function attachUpdateHandlers(registration, options) {
+    // Guard: only the first caller per registration attaches handlers.
+    // Subsequent calls with different options are silently ignored.
+    if (handshakes.has(registration))
+        return;
+    handshakes.add(registration);
+    const { autoReload, onNeedRefresh, onUpdated, activationTimeoutMs, debug } = options;
+    let reloadTriggered = false;
+    const maybeReload = () => {
+        if (reloadTriggered)
+            return;
+        reloadTriggered = true;
+        debugLog(debug, "Service worker controller change detected");
+        onUpdated?.();
+        if (autoReload &&
+            typeof window !== "undefined" &&
+            typeof window.location?.reload === "function") {
+            window.location.reload();
+        }
+    };
+    const handleWaiting = (worker) => {
+        if (!worker)
+            return;
+        onNeedRefresh?.();
+        sendSkipWaiting(worker, debug);
+        if (activationTimeoutMs > 0 && typeof window !== "undefined") {
+            window.setTimeout(() => {
+                if (registration.waiting) {
+                    debugLog(debug, "Waiting worker still pending; re-sending SKIP_WAITING");
+                    sendSkipWaiting(registration.waiting, debug);
+                    registration
+                        .update()
+                        .catch(() => debugLog(debug, "Service worker update retry failed (timeout path)"));
+                }
+            }, activationTimeoutMs);
+        }
+    };
+    // Handle an already waiting worker at startup.
+    if (registration.waiting) {
+        handleWaiting(registration.waiting);
+    }
+    // Listen for newly installed workers becoming waiting.
+    registration.addEventListener("updatefound", () => {
+        const installing = registration.installing;
+        if (!installing)
+            return;
+        installing.addEventListener("statechange", () => {
+            if (installing.state === "installed") {
+                handleWaiting(registration.waiting);
+            }
+        });
+    });
+    // Reload (or callback) once the new controller takes over.
+    navigator.serviceWorker.addEventListener("controllerchange", maybeReload, {
+        once: true,
+    });
+}
+function registerOnce(options) {
+    const { path, updateViaCache } = options;
     if (!registrations.has(path)) {
         const registrationPromise = navigator.serviceWorker
-            .register(path)
+            .register(path, { updateViaCache })
             .then(async (registration) => {
             try {
                 await registration.update();
@@ -29,18 +125,23 @@ function registerOnce(path) {
         });
         registrations.set(path, registrationPromise);
     }
-    return registrations.get(path);
+    return registrations.get(path).then((registration) => {
+        attachUpdateHandlers(registration, options);
+        return registration;
+    });
 }
 /**
- * Registers a service worker for the given path only once and caches the
- * registration promise for subsequent calls.
+ * Registers a service worker for the given path only once, attaches an
+ * update/activation handshake (SKIP_WAITING + controllerchange reload), and
+ * caches the registration promise for subsequent calls.
  *
- * @param path - Service worker script path to register.
+ * @param pathOrOptions - Service worker script path or a configuration object.
  * @throws if service workers are not supported or registration fails.
  */
-async function setupServiceWorkerOnce(path) {
+async function setupServiceWorkerOnce(pathOrOptions) {
     ensureServiceWorkerSupport();
-    return registerOnce(path);
+    const options = normalizeOptions(pathOrOptions);
+    return registerOnce(options);
 }
 /**
  * Returns an active service worker instance, optionally ensuring a specific
@@ -51,9 +152,8 @@ async function setupServiceWorkerOnce(path) {
  */
 async function getActiveServiceWorker(path) {
     ensureServiceWorkerSupport();
-    // Avoid mixing registrations when a specific script path is provided.
     const registration = path
-        ? await registerOnce(path)
+        ? await registerOnce(normalizeOptions(path))
         : await navigator.serviceWorker.ready;
     let serviceWorker = registration.active ||
         registration.waiting ||
@@ -78,5 +178,6 @@ async function getActiveServiceWorker(path) {
  */
 const __resetServiceWorkerManager = () => {
     registrations.clear();
+    handshakes = new WeakSet();
 };
 exports.__resetServiceWorkerManager = __resetServiceWorkerManager;

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;
+}