@arkade-os/sdk 0.4.78 → 0.4.79

package/README.md

@@ -1555,7 +1555,7 @@ For integration tests, use the root commands (`pnpm run test:integration:ts-sdk`
 
 ### Releasing
 
-Package-local releases are disabled. Releases run from the monorepo root and are package-scoped: `pnpm run release -- sdk patch` bumps `@arkade-os/sdk`, creates a `@arkade-os/sdk/<version>` tag, and also bumps `@arkade-os/boltz-swap` (which depends on SDK via `workspace:*`). See the [root README](../../README.md#releasing) for full flags and `pnpm run release -- --help`.
+Package-local releases are disabled. Releases run from the monorepo root and are package-scoped: `pnpm run release -- sdk patch` bumps `@arkade-os/sdk`, creates a `@arkade-os/sdk/<version>` tag, and also bumps `@arkade-os/swap` (which depends on SDK via `workspace:*`). See the [root README](../../README.md#releasing) for full flags and `pnpm run release -- --help`.
 
 ## License
 

package/dist/adapters/expo.cjs

@@ -1,19 +1,19 @@
 'use strict';
 
-var chunkDFWLP3MD_cjs = require('../chunk-DFWLP3MD.cjs');
-require('../chunk-IAM5IEVT.cjs');
-require('../chunk-PWIESIO6.cjs');
+var chunkLASRYLMQ_cjs = require('../chunk-LASRYLMQ.cjs');
+require('../chunk-SJPPBR2V.cjs');
+require('../chunk-DAYCCIRO.cjs');
 require('../chunk-5BLDMQED.cjs');
 
 
 
 Object.defineProperty(exports, "ExpoArkProvider", {
   enumerable: true,
-  get: function () { return chunkDFWLP3MD_cjs.ExpoArkProvider; }
+  get: function () { return chunkLASRYLMQ_cjs.ExpoArkProvider; }
 });
 Object.defineProperty(exports, "ExpoIndexerProvider", {
   enumerable: true,
-  get: function () { return chunkDFWLP3MD_cjs.ExpoIndexerProvider; }
+  get: function () { return chunkLASRYLMQ_cjs.ExpoIndexerProvider; }
 });
 //# sourceMappingURL=expo.cjs.map
 //# sourceMappingURL=expo.cjs.map

package/dist/adapters/expo.d.cts

@@ -1,8 +1,8 @@
-import { o as RestArkProvider, l as SettlementEvent, T as TxNotificationEvent, p as RestIndexerProvider, q as SubscriptionResponse } from '../index-CAS4GyN-.cjs';
-export { r as ArkProvider, s as IndexerProvider } from '../index-CAS4GyN-.cjs';
+import { o as RestArkProvider, l as SettlementEvent, T as TxNotificationEvent, p as RestIndexerProvider, q as SubscriptionResponse } from '../index-Ctul0N3Y.cjs';
+export { r as ArkProvider, s as IndexerProvider } from '../index-Ctul0N3Y.cjs';
 import '@scure/btc-signer/utils.js';
-import '@scure/btc-signer/transaction.js';
 import '@scure/btc-signer';
+import '@scure/btc-signer/transaction.js';
 import '@scure/btc-signer/psbt.js';
 
 /**

package/dist/adapters/expo.d.ts

@@ -1,8 +1,8 @@
-import { o as RestArkProvider, l as SettlementEvent, T as TxNotificationEvent, p as RestIndexerProvider, q as SubscriptionResponse } from '../index-CAS4GyN-.js';
-export { r as ArkProvider, s as IndexerProvider } from '../index-CAS4GyN-.js';
+import { o as RestArkProvider, l as SettlementEvent, T as TxNotificationEvent, p as RestIndexerProvider, q as SubscriptionResponse } from '../index-Ctul0N3Y.js';
+export { r as ArkProvider, s as IndexerProvider } from '../index-Ctul0N3Y.js';
 import '@scure/btc-signer/utils.js';
-import '@scure/btc-signer/transaction.js';
 import '@scure/btc-signer';
+import '@scure/btc-signer/transaction.js';
 import '@scure/btc-signer/psbt.js';
 
 /**

package/dist/adapters/expo.js

@@ -1,6 +1,6 @@
-export { ExpoArkProvider, ExpoIndexerProvider } from '../chunk-OUHUC26M.js';
-import '../chunk-CTFYT24G.js';
-import '../chunk-7KIGEOYT.js';
+export { ExpoArkProvider, ExpoIndexerProvider } from '../chunk-VAFNWP3I.js';
+import '../chunk-QDXOTONI.js';
+import '../chunk-JCPVP7TJ.js';
 import '../chunk-NSBPE2FW.js';
 //# sourceMappingURL=expo.js.map
 //# sourceMappingURL=expo.js.map

package/dist/{asyncStorageTaskQueue-YW2t31_o.d.ts → asyncStorageTaskQueue-C5yQLJhm.d.ts}

@@ -1,4 +1,4 @@
-import { c as TaskQueue, b as TaskItem, d as TaskResult } from './taskRunner-BJj7xe35.js';
+import { c as TaskQueue, b as TaskItem, d as TaskResult } from './taskRunner-C08egG5a.js';
 
 /**
  * Minimal async key-value storage interface.

package/dist/{asyncStorageTaskQueue-DiXxP-nQ.d.cts → asyncStorageTaskQueue-Shsih-1l.d.cts}

@@ -1,4 +1,4 @@
-import { c as TaskQueue, b as TaskItem, d as TaskResult } from './taskRunner-HS2d2oda.cjs';
+import { c as TaskQueue, b as TaskItem, d as TaskResult } from './taskRunner-DB17db5n.cjs';
 
 /**
  * Minimal async key-value storage interface.

package/dist/{chunk-ZOCJ7E6M.js → chunk-4MXW2NDN.js}

@@ -1,8 +1,9 @@
-import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-7KIGEOYT.js';
+import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-JCPVP7TJ.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { hex } from '@scure/base';
 import { networks, expand } from '@bitcoinerlab/descriptors-scure';
 import { ScriptNum, OP, Script } from '@scure/btc-signer';
+import * as P from 'micro-packed';
 import { schnorr, secp256k1 } from '@noble/curves/secp256k1.js';
 import { bytesToNumberBE } from '@noble/curves/utils.js';
 
@@ -617,512 +618,6 @@ function discoverDelegateRange(entries, deps) {
     (c, index, descriptor) => ({ ...c, ...rotatedReceiveMetadata(index, descriptor) })
   );
 }
-function equalBytes(a, b) {
-  if (a.length !== b.length)
-    return false;
-  for (let i = 0; i < a.length; i++)
-    if (a[i] !== b[i])
-      return false;
-  return true;
-}
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-function isPlainObject(obj) {
-  return Object.prototype.toString.call(obj) === "[object Object]";
-}
-function isNum(num) {
-  return Number.isSafeInteger(num);
-}
-var Bitset = {
-  BITS: 32,
-  FULL_MASK: -1 >>> 0,
-  // 1<<32 will overflow
-  len: (len) => Math.ceil(len / 32),
-  create: (len) => new Uint32Array(Bitset.len(len)),
-  clean: (bs) => bs.fill(0),
-  debug: (bs) => Array.from(bs).map((i) => (i >>> 0).toString(2).padStart(32, "0")),
-  checkLen: (bs, len) => {
-    if (Bitset.len(len) === bs.length)
-      return;
-    throw new Error(`wrong length=${bs.length}. Expected: ${Bitset.len(len)}`);
-  },
-  chunkLen: (bsLen, pos, len) => {
-    if (pos < 0)
-      throw new Error(`wrong pos=${pos}`);
-    if (pos + len > bsLen)
-      throw new Error(`wrong range=${pos}/${len} of ${bsLen}`);
-  },
-  set: (bs, chunk, value, allowRewrite = true) => {
-    if (!allowRewrite && (bs[chunk] & value) !== 0)
-      return false;
-    bs[chunk] |= value;
-    return true;
-  },
-  pos: (pos, i) => ({
-    chunk: Math.floor((pos + i) / 32),
-    mask: 1 << 32 - (pos + i) % 32 - 1
-  }),
-  indices: (bs, len, invert = false) => {
-    Bitset.checkLen(bs, len);
-    const { FULL_MASK, BITS } = Bitset;
-    const left = BITS - len % BITS;
-    const lastMask = left ? FULL_MASK >>> left << left : FULL_MASK;
-    const res = [];
-    for (let i = 0; i < bs.length; i++) {
-      let c = bs[i];
-      if (invert)
-        c = ~c;
-      if (i === bs.length - 1)
-        c &= lastMask;
-      if (c === 0)
-        continue;
-      for (let j = 0; j < BITS; j++) {
-        const m = 1 << BITS - j - 1;
-        if (c & m)
-          res.push(i * BITS + j);
-      }
-    }
-    return res;
-  },
-  range: (arr) => {
-    const res = [];
-    let cur;
-    for (const i of arr) {
-      if (cur === void 0 || i !== cur.pos + cur.length)
-        res.push(cur = { pos: i, length: 1 });
-      else
-        cur.length += 1;
-    }
-    return res;
-  },
-  rangeDebug: (bs, len, invert = false) => `[${Bitset.range(Bitset.indices(bs, len, invert)).map((i) => `(${i.pos}/${i.length})`).join(", ")}]`,
-  setRange: (bs, bsLen, pos, len, allowRewrite = true) => {
-    Bitset.chunkLen(bsLen, pos, len);
-    const { FULL_MASK, BITS } = Bitset;
-    const first = pos % BITS ? Math.floor(pos / BITS) : void 0;
-    const lastPos = pos + len;
-    const last = lastPos % BITS ? Math.floor(lastPos / BITS) : void 0;
-    if (first !== void 0 && first === last)
-      return Bitset.set(bs, first, FULL_MASK >>> BITS - len << BITS - len - pos, allowRewrite);
-    if (first !== void 0) {
-      if (!Bitset.set(bs, first, FULL_MASK >>> pos % BITS, allowRewrite))
-        return false;
-    }
-    const start = first !== void 0 ? first + 1 : pos / BITS;
-    const end = last !== void 0 ? last : lastPos / BITS;
-    for (let i = start; i < end; i++)
-      if (!Bitset.set(bs, i, FULL_MASK, allowRewrite))
-        return false;
-    if (last !== void 0 && first !== last) {
-      if (!Bitset.set(bs, last, FULL_MASK << BITS - lastPos % BITS, allowRewrite))
-        return false;
-    }
-    return true;
-  }
-};
-var Path = {
-  /**
-   * Internal method for handling stack of paths (debug, errors, dynamic fields via path)
-   * This is looks ugly (callback), but allows us to force stack cleaning by construction (.pop always after function).
-   * Also, this makes impossible:
-   * - pushing field when stack is empty
-   * - pushing field inside of field (real bug)
-   * NOTE: we don't want to do '.pop' on error!
-   */
-  pushObj: (stack, obj, objFn) => {
-    const last = { obj };
-    stack.push(last);
-    objFn((field, fieldFn) => {
-      last.field = field;
-      fieldFn();
-      last.field = void 0;
-    });
-    stack.pop();
-  },
-  path: (stack) => {
-    const res = [];
-    for (const i of stack)
-      if (i.field !== void 0)
-        res.push(i.field);
-    return res.join("/");
-  },
-  err: (name, stack, msg) => {
-    const err = new Error(`${name}(${Path.path(stack)}): ${typeof msg === "string" ? msg : msg.message}`);
-    if (msg instanceof Error && msg.stack)
-      err.stack = msg.stack;
-    return err;
-  },
-  resolve: (stack, path) => {
-    const parts = path.split("/");
-    const objPath = stack.map((i2) => i2.obj);
-    let i = 0;
-    for (; i < parts.length; i++) {
-      if (parts[i] === "..")
-        objPath.pop();
-      else
-        break;
-    }
-    let cur = objPath.pop();
-    for (; i < parts.length; i++) {
-      if (!cur || cur[parts[i]] === void 0)
-        return void 0;
-      cur = cur[parts[i]];
-    }
-    return cur;
-  }
-};
-var _Reader = class __Reader {
-  pos = 0;
-  data;
-  opts;
-  stack;
-  parent;
-  parentOffset;
-  bitBuf = 0;
-  bitPos = 0;
-  bs;
-  // bitset
-  view;
-  constructor(data, opts = {}, stack = [], parent = void 0, parentOffset = 0) {
-    this.data = data;
-    this.opts = opts;
-    this.stack = stack;
-    this.parent = parent;
-    this.parentOffset = parentOffset;
-    this.view = createView(data);
-  }
-  /** Internal method for pointers. */
-  _enablePointers() {
-    if (this.parent)
-      return this.parent._enablePointers();
-    if (this.bs)
-      return;
-    this.bs = Bitset.create(this.data.length);
-    Bitset.setRange(this.bs, this.data.length, 0, this.pos, this.opts.allowMultipleReads);
-  }
-  markBytesBS(pos, len) {
-    if (this.parent)
-      return this.parent.markBytesBS(this.parentOffset + pos, len);
-    if (!len)
-      return true;
-    if (!this.bs)
-      return true;
-    return Bitset.setRange(this.bs, this.data.length, pos, len, false);
-  }
-  markBytes(len) {
-    const pos = this.pos;
-    this.pos += len;
-    const res = this.markBytesBS(pos, len);
-    if (!this.opts.allowMultipleReads && !res)
-      throw this.err(`multiple read pos=${this.pos} len=${len}`);
-    return res;
-  }
-  pushObj(obj, objFn) {
-    return Path.pushObj(this.stack, obj, objFn);
-  }
-  readView(n, fn) {
-    if (!Number.isFinite(n))
-      throw this.err(`readView: wrong length=${n}`);
-    if (this.pos + n > this.data.length)
-      throw this.err("readView: Unexpected end of buffer");
-    const res = fn(this.view, this.pos);
-    this.markBytes(n);
-    return res;
-  }
-  // read bytes by absolute offset
-  absBytes(n) {
-    if (n > this.data.length)
-      throw new Error("Unexpected end of buffer");
-    return this.data.subarray(n);
-  }
-  finish() {
-    if (this.opts.allowUnreadBytes)
-      return;
-    if (this.bitPos) {
-      throw this.err(`${this.bitPos} bits left after unpack: ${hex.encode(this.data.slice(this.pos))}`);
-    }
-    if (this.bs && !this.parent) {
-      const notRead = Bitset.indices(this.bs, this.data.length, true);
-      if (notRead.length) {
-        const formatted = Bitset.range(notRead).map(({ pos, length }) => `(${pos}/${length})[${hex.encode(this.data.subarray(pos, pos + length))}]`).join(", ");
-        throw this.err(`unread byte ranges: ${formatted} (total=${this.data.length})`);
-      } else
-        return;
-    }
-    if (!this.isEnd()) {
-      throw this.err(`${this.leftBytes} bytes ${this.bitPos} bits left after unpack: ${hex.encode(this.data.slice(this.pos))}`);
-    }
-  }
-  // User methods
-  err(msg) {
-    return Path.err("Reader", this.stack, msg);
-  }
-  offsetReader(n) {
-    if (n > this.data.length)
-      throw this.err("offsetReader: Unexpected end of buffer");
-    return new __Reader(this.absBytes(n), this.opts, this.stack, this, n);
-  }
-  bytes(n, peek = false) {
-    if (this.bitPos)
-      throw this.err("readBytes: bitPos not empty");
-    if (!Number.isFinite(n))
-      throw this.err(`readBytes: wrong length=${n}`);
-    if (this.pos + n > this.data.length)
-      throw this.err("readBytes: Unexpected end of buffer");
-    const slice = this.data.subarray(this.pos, this.pos + n);
-    if (!peek)
-      this.markBytes(n);
-    return slice;
-  }
-  byte(peek = false) {
-    if (this.bitPos)
-      throw this.err("readByte: bitPos not empty");
-    if (this.pos + 1 > this.data.length)
-      throw this.err("readBytes: Unexpected end of buffer");
-    const data = this.data[this.pos];
-    if (!peek)
-      this.markBytes(1);
-    return data;
-  }
-  get leftBytes() {
-    return this.data.length - this.pos;
-  }
-  get totalBytes() {
-    return this.data.length;
-  }
-  isEnd() {
-    return this.pos >= this.data.length && !this.bitPos;
-  }
-  // bits are read in BE mode (left to right): (0b1000_0000).readBits(1) == 1
-  bits(bits) {
-    if (bits > 32)
-      throw this.err("BitReader: cannot read more than 32 bits in single call");
-    let out = 0;
-    while (bits) {
-      if (!this.bitPos) {
-        this.bitBuf = this.byte();
-        this.bitPos = 8;
-      }
-      const take = Math.min(bits, this.bitPos);
-      this.bitPos -= take;
-      out = out << take | this.bitBuf >> this.bitPos & 2 ** take - 1;
-      this.bitBuf &= 2 ** this.bitPos - 1;
-      bits -= take;
-    }
-    return out >>> 0;
-  }
-  find(needle, pos = this.pos) {
-    if (!isBytes(needle))
-      throw this.err(`find: needle is not bytes! ${needle}`);
-    if (this.bitPos)
-      throw this.err("findByte: bitPos not empty");
-    if (!needle.length)
-      throw this.err(`find: needle is empty`);
-    for (let idx = pos; (idx = this.data.indexOf(needle[0], idx)) !== -1; idx++) {
-      if (idx === -1)
-        return;
-      const leftBytes = this.data.length - idx;
-      if (leftBytes < needle.length)
-        return;
-      if (equalBytes(needle, this.data.subarray(idx, idx + needle.length)))
-        return idx;
-    }
-    return;
-  }
-};
-var _Writer = class {
-  pos = 0;
-  stack;
-  // We could have a single buffer here and re-alloc it with
-  // x1.5-2 size each time it full, but it will be slower:
-  // basic/encode bench: 395ns -> 560ns
-  buffers = [];
-  ptrs = [];
-  bitBuf = 0;
-  bitPos = 0;
-  viewBuf = new Uint8Array(8);
-  view;
-  finished = false;
-  constructor(stack = []) {
-    this.stack = stack;
-    this.view = createView(this.viewBuf);
-  }
-  pushObj(obj, objFn) {
-    return Path.pushObj(this.stack, obj, objFn);
-  }
-  writeView(len, fn) {
-    if (this.finished)
-      throw this.err("buffer: finished");
-    if (!isNum(len) || len > 8)
-      throw new Error(`wrong writeView length=${len}`);
-    fn(this.view);
-    this.bytes(this.viewBuf.slice(0, len));
-    this.viewBuf.fill(0);
-  }
-  // User methods
-  err(msg) {
-    if (this.finished)
-      throw this.err("buffer: finished");
-    return Path.err("Reader", this.stack, msg);
-  }
-  bytes(b) {
-    if (this.finished)
-      throw this.err("buffer: finished");
-    if (this.bitPos)
-      throw this.err("writeBytes: ends with non-empty bit buffer");
-    this.buffers.push(b);
-    this.pos += b.length;
-  }
-  byte(b) {
-    if (this.finished)
-      throw this.err("buffer: finished");
-    if (this.bitPos)
-      throw this.err("writeByte: ends with non-empty bit buffer");
-    this.buffers.push(new Uint8Array([b]));
-    this.pos++;
-  }
-  finish(clean = true) {
-    if (this.finished)
-      throw this.err("buffer: finished");
-    if (this.bitPos)
-      throw this.err("buffer: ends with non-empty bit buffer");
-    const buffers = this.buffers.concat(this.ptrs.map((i) => i.buffer));
-    const sum = buffers.map((b) => b.length).reduce((a, b) => a + b, 0);
-    const buf = new Uint8Array(sum);
-    for (let i = 0, pad = 0; i < buffers.length; i++) {
-      const a = buffers[i];
-      buf.set(a, pad);
-      pad += a.length;
-    }
-    for (let pos = this.pos, i = 0; i < this.ptrs.length; i++) {
-      const ptr = this.ptrs[i];
-      buf.set(ptr.ptr.encode(pos), ptr.pos);
-      pos += ptr.buffer.length;
-    }
-    if (clean) {
-      this.buffers = [];
-      for (const p of this.ptrs)
-        p.buffer.fill(0);
-      this.ptrs = [];
-      this.finished = true;
-      this.bitBuf = 0;
-    }
-    return buf;
-  }
-  bits(value, bits) {
-    if (bits > 32)
-      throw this.err("writeBits: cannot write more than 32 bits in single call");
-    if (value >= 2 ** bits)
-      throw this.err(`writeBits: value (${value}) >= 2**bits (${bits})`);
-    while (bits) {
-      const take = Math.min(bits, 8 - this.bitPos);
-      this.bitBuf = this.bitBuf << take | value >> bits - take;
-      this.bitPos += take;
-      bits -= take;
-      value &= 2 ** bits - 1;
-      if (this.bitPos === 8) {
-        this.bitPos = 0;
-        this.buffers.push(new Uint8Array([this.bitBuf]));
-        this.pos++;
-      }
-    }
-  }
-};
-function _wrap(inner) {
-  return {
-    // NOTE: we cannot export validate here, since it is likely mistake.
-    encodeStream: inner.encodeStream,
-    decodeStream: inner.decodeStream,
-    size: inner.size,
-    encode: (value) => {
-      const w = new _Writer();
-      inner.encodeStream(w, value);
-      return w.finish();
-    },
-    decode: (data, opts = {}) => {
-      const r = new _Reader(data, opts);
-      const res = inner.decodeStream(r);
-      r.finish();
-      return res;
-    }
-  };
-}
-function validate(inner, fn) {
-  if (!isCoder(inner))
-    throw new Error(`validate: invalid inner value ${inner}`);
-  if (typeof fn !== "function")
-    throw new Error("validate: fn should be function");
-  return _wrap({
-    size: inner.size,
-    encodeStream: (w, value) => {
-      let res;
-      try {
-        res = fn(value);
-      } catch (e) {
-        throw w.err(e);
-      }
-      inner.encodeStream(w, res);
-    },
-    decodeStream: (r) => {
-      const res = inner.decodeStream(r);
-      try {
-        return fn(res);
-      } catch (e) {
-        throw r.err(e);
-      }
-    }
-  });
-}
-var wrap = (inner) => {
-  const res = _wrap(inner);
-  return inner.validate ? validate(res, inner.validate) : res;
-};
-var isBaseCoder = (elm) => isPlainObject(elm) && typeof elm.decode === "function" && typeof elm.encode === "function";
-function isCoder(elm) {
-  return isPlainObject(elm) && isBaseCoder(elm) && typeof elm.encodeStream === "function" && typeof elm.decodeStream === "function" && (elm.size === void 0 || isNum(elm.size));
-}
-var view = (len, opts) => wrap({
-  size: len,
-  encodeStream: (w, value) => w.writeView(len, (view2) => opts.write(view2, value)),
-  decodeStream: (r) => r.readView(len, opts.read),
-  validate: (value) => {
-    if (typeof value !== "number")
-      throw new Error(`viewCoder: expected number, got ${typeof value}`);
-    if (opts.validate)
-      opts.validate(value);
-    return value;
-  }
-});
-var intView = (len, signed, opts) => {
-  const bits = len * 8;
-  const maxVal = 2 ** bits;
-  const validateUnsigned = (value) => {
-    if (!isNum(value))
-      throw new Error(`uintView: value is not safe integer: ${value}`);
-    if (0 > value || value >= maxVal) {
-      throw new Error(`uintView: value out of bounds. Expected 0 <= ${value} < ${maxVal}`);
-    }
-  };
-  return view(len, {
-    write: opts.write,
-    read: opts.read,
-    validate: validateUnsigned
-  });
-};
-var U32LE = /* @__PURE__ */ intView(4, false, {
-  read: (view2, pos) => view2.getUint32(pos, true),
-  write: (view2, value) => view2.setUint32(0, value, true)
-});
-var U16LE = /* @__PURE__ */ intView(2, false, {
-  read: (view2, pos) => view2.getUint16(pos, true),
-  write: (view2, value) => view2.setUint16(0, value, true)
-});
-var U8 = /* @__PURE__ */ intView(1, false, {
-  read: (view2, pos) => view2.getUint8(pos),
-  write: (view2, value) => view2.setUint8(0, value)
-});
 var ARKADE_OP = {
   // Merkle Branch Verification (0xb3 — repurposed NOP4 slot)
   MERKLEBRANCHVERIFY: 179,
@@ -1288,7 +783,7 @@ var ArkadeOPNames = {};
 for (const [k, v] of Object.entries(ARKADE_OPS)) {
   if (typeof v === "number") ArkadeOPNames[v] = k;
 }
-var ArkadeScript = wrap({
+var ArkadeScript = P.wrap({
   encodeStream: (w, value) => {
     for (let o of value) {
       if (typeof o === "string") {
@@ -1314,10 +809,10 @@ var ArkadeScript = wrap({
         w.byte(len);
       } else if (len <= 65535) {
         w.byte(OP.PUSHDATA2);
-        w.bytes(U16LE.encode(len));
+        w.bytes(P.U16LE.encode(len));
       } else {
         w.byte(OP.PUSHDATA4);
-        w.bytes(U32LE.encode(len));
+        w.bytes(P.U32LE.encode(len));
       }
       w.bytes(o);
     }
@@ -1329,9 +824,9 @@ var ArkadeScript = wrap({
       if (OP.OP_0 < cur && cur <= OP.PUSHDATA4) {
         let len;
         if (cur < OP.PUSHDATA1) len = cur;
-        else if (cur === OP.PUSHDATA1) len = U8.decodeStream(r);
-        else if (cur === OP.PUSHDATA2) len = U16LE.decodeStream(r);
-        else if (cur === OP.PUSHDATA4) len = U32LE.decodeStream(r);
+        else if (cur === OP.PUSHDATA1) len = P.U8.decodeStream(r);
+        else if (cur === OP.PUSHDATA2) len = P.U16LE.decodeStream(r);
+        else if (cur === OP.PUSHDATA4) len = P.U32LE.decodeStream(r);
         else throw new Error("Should be not possible");
         out.push(r.bytes(len));
       } else if (cur === 0) {
@@ -3027,5 +2522,5 @@ contractHandlers.register(BoardingContractHandler);
 contractHandlers.register(ArkadeContractHandler);
 
 export { ARKADE_OP, ARKADE_OPCODES, ARKADE_OPCODE_NAMES, ARKADE_OPCODE_VALUES, ARKADE_OPS, ArkadeContractHandler, ArkadeProgramScript, ArkadeScript, BoardingContractHandler, DefaultContractHandler, DefaultVtxo, DelegateContractHandler, DelegateVtxo, OPCODE_NAMES, OPCODE_VALUES, SUPPORTED_PROGRAM_VERSION, VHTLC, VHTLCContractHandler, VHTLCV2ContractHandler, WALLET_RECEIVE_SOURCE, arkadeScriptHash, arkadeWitnessHash, asmToBytes, bignum_exports, bytesToASM, computeArkadeScriptPublicKey, contractHandlers, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, descriptorIsOurs, deserializeArkadeContractParams, fromASM, getOpcodeName, getOpcodeValue, identityDescriptor, inputName, isCltvSatisfied, isCsvSpendable, isMainnetDescriptor, normalizeToDescriptor, parseArtifact, parseHDDescriptor, resolveAsm, serializeArkadeContractParams, speculativeReceiveMetadata, stringifyArtifact, toASM, toXOnly, validateProgram, witnessRefToBytes };
-//# sourceMappingURL=chunk-ZOCJ7E6M.js.map
-//# sourceMappingURL=chunk-ZOCJ7E6M.js.map
+//# sourceMappingURL=chunk-4MXW2NDN.js.map
+//# sourceMappingURL=chunk-4MXW2NDN.js.map