@sats-connect/core 0.4.0-7a3cb13 → 0.4.0-80a221a

package/dist/index.js

@@ -217,8 +217,7 @@ async function getProviderOrThrow(getProvider) {
   return provider;
 }
 function getProviders() {
-  if (!window.btc_providers)
-    window.btc_providers = [];
+  if (!window.btc_providers) window.btc_providers = [];
   return window.btc_providers;
 }
 function getProviderById(providerId) {
@@ -300,7 +299,7 @@ var rpcResponseMessageSchema = v2.union([
 ]);
 
 // src/request/index.ts
-var v20 = __toESM(require("valibot"));
+var v25 = __toESM(require("valibot"));
 
 // src/request/types/stxMethods/callContract.ts
 var v3 = __toESM(require("valibot"));
@@ -809,7 +808,6 @@ var signPsbtParamsSchema = v13.object({
    * The key is the address and the value is an array of indexes of the inputs to sign.
    */
   signInputs: v13.record(v13.string(), v13.array(v13.number())),
-  allowedSignHash: v13.optional(v13.number()),
   /**
    * Whether to broadcast the transaction after signing.
    **/
@@ -893,275 +891,774 @@ var getBalanceRequestMessageSchema = v13.object({
 });
 
 // src/request/types/walletMethods.ts
+var v19 = __toESM(require("valibot"));
+
+// node_modules/@noble/hashes/esm/_assert.js
+function isBytes(a) {
+  return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+}
+function bytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+}
+function exists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function output(out, instance) {
+  bytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+  }
+}
+
+// node_modules/@noble/hashes/esm/utils.js
+var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes2) {
+  bytes(bytes2);
+  let hex = "";
+  for (let i = 0; i < bytes2.length; i++) {
+    hex += hexes[bytes2[i]];
+  }
+  return hex;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  bytes(data);
+  return data;
+}
+var Hash = class {
+  // Safe version that clones internal state
+  clone() {
+    return this._cloneInto();
+  }
+};
+var toStr = {}.toString;
+function wrapConstructor(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE2) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE2);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE2 ? 4 : 0;
+  const l = isLE2 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE2);
+  view.setUint32(byteOffset + l, wl, isLE2);
+}
+var Chi = (a, b, c) => a & b ^ ~a & c;
+var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
+var HashMD = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE2) {
+    super();
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE2;
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    exists(this);
+    const { view, buffer, blockLen } = this;
+    data = toBytes(data);
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    exists(this);
+    output(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE2 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    this.buffer.subarray(pos).fill(0);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE2);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.length = length;
+    to.pos = pos;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+};
+
+// node_modules/@noble/hashes/esm/sha256.js
+var SHA256_K = /* @__PURE__ */ new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_IV = /* @__PURE__ */ new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+  constructor() {
+    super(64, 32, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    SHA256_W.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    this.buffer.fill(0);
+  }
+};
+var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+
+// src/request/types/permissions/resources/account.ts
+var v16 = __toESM(require("valibot"));
+
+// src/request/types/permissions/resources/common.ts
 var v14 = __toESM(require("valibot"));
-var import_xverse_core = require("@secretkeylabs/xverse-core");
-var permissionTemplate = v14.variant("type", [
-  v14.object({
-    ...v14.omit(import_xverse_core.permissions.resources.account.accountPermissionSchema, ["clientId"]).entries
+var actionDescriptionSchema = v14.object({
+  name: v14.string(),
+  description: v14.variant("type", [
+    v14.object({ type: v14.literal("single"), value: v14.string() }),
+    v14.object({ type: v14.literal("multiple"), values: v14.array(v14.string()) })
+  ])
+});
+
+// src/request/types/permissions/utils/account-id.ts
+var v15 = __toESM(require("valibot"));
+var accountIdBrandName = "AccountId";
+var accountIdSchema = v15.pipe(v15.string(), v15.brand(accountIdBrandName));
+function makeAccountId(options) {
+  return v15.parse(
+    accountIdSchema,
+    bytesToHex(
+      sha256(
+        `account-${options.masterPubKey}-${// NOTE: This "account ID" is actually the ~account~ address index from BIP-44.
+        options.accountId}-${options.networkType}`
+      )
+    )
+  );
+}
+
+// src/request/types/permissions/resources/account.ts
+var accountResourceIdBrandName = "AccountResourceId";
+var sha256HexStringRegex = /^[\da-f]{64}$/;
+var accountResourceIdSchema = v16.pipe(
+  v16.string(),
+  v16.check((input) => sha256HexStringRegex.test(input)),
+  v16.brand("AccountResourceId")
+);
+function makeAccountResourceId(accountId) {
+  return v16.parse(accountResourceIdSchema, bytesToHex(sha256(`account-resource-${accountId}`)));
+}
+var accountResourceSchema = v16.object({
+  type: v16.literal("account"),
+  id: accountResourceIdSchema,
+  accountId: accountIdSchema,
+  name: v16.string()
+});
+function makeAccountResource(args) {
+  return {
+    type: "account",
+    id: makeAccountResourceId(args.accountId),
+    accountId: args.accountId,
+    name: `Account ${args.accountId}, ${args.masterPubKey.slice(0, 6)}...(${args.networkType})`
+  };
+}
+var accountActionsSchema = v16.object({
+  read: v16.optional(v16.boolean()),
+  autoSign: v16.optional(v16.boolean()),
+  rename: v16.optional(v16.boolean())
+});
+var accountActionsDescriptionSchema = v16.record(
+  v16.keyof(accountActionsSchema),
+  actionDescriptionSchema
+);
+var accountPermissionSchema = v16.object({
+  type: v16.literal("account"),
+  resourceId: accountResourceIdSchema,
+  clientId: v16.string(),
+  actions: accountActionsSchema
+});
+
+// src/request/types/permissions/resources/wallet.ts
+var v17 = __toESM(require("valibot"));
+var walletResourceSchema = v17.object({
+  type: v17.literal("wallet"),
+  id: v17.literal("wallet"),
+  name: v17.literal("Wallet")
+});
+var walletActionsSchema = v17.object({
+  addPrivateKey: v17.optional(v17.boolean()),
+  openPopup: v17.optional(v17.boolean()),
+  openFullPage: v17.optional(v17.boolean()),
+  readAllAccounts: v17.optional(v17.boolean())
+});
+var walletActionsDescriptionSchema = v17.record(
+  v17.keyof(walletActionsSchema),
+  actionDescriptionSchema
+);
+var walletIdSchema = v17.literal("wallet");
+var walletPermissionSchema = v17.object({
+  type: v17.literal("wallet"),
+  resourceId: walletIdSchema,
+  clientId: v17.string(),
+  actions: walletActionsSchema
+});
+
+// src/request/types/permissions/resources/index.ts
+var account = {
+  accountResourceIdBrandName,
+  accountResourceIdSchema,
+  accountResourceSchema,
+  accountActionsSchema,
+  accountActionsDescriptionSchema,
+  accountPermissionSchema,
+  makeAccountResourceId,
+  makeAccountResource
+};
+var common = {
+  actionDescriptionSchema
+};
+var wallet = {
+  walletResourceSchema,
+  walletActionsSchema,
+  walletIdSchema,
+  walletPermissionSchema,
+  walletActionsDescriptionSchema
+};
+
+// src/request/types/permissions/utils/index.ts
+var account2 = {
+  makeAccountId,
+  accountIdBrandName,
+  accountIdSchema
+};
+
+// src/request/types/permissions/store.ts
+var v18 = __toESM(require("valibot"));
+var clientId = v18.pipe(v18.string(), v18.url(), v18.brand("ClientId"));
+var client = v18.object({
+  id: clientId,
+  origin: v18.string(),
+  name: v18.optional(v18.string()),
+  description: v18.optional(v18.string())
+});
+var clientsTable = v18.array(client);
+var clientMetadata = v18.object({
+  clientId: client.entries.id,
+  lastUsed: v18.optional(v18.number())
+});
+var clientMetadataTable = v18.array(clientMetadata);
+var resource = v18.variant("type", [accountResourceSchema, walletResourceSchema]);
+var resourcesTable = v18.array(resource);
+var permission = v18.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+var permissionsTable = v18.array(permission);
+var permissionsStore = v18.object({
+  version: v18.literal(4),
+  clients: clientsTable,
+  clientMetadata: clientMetadataTable,
+  resources: resourcesTable,
+  permissions: permissionsTable
+});
+
+// src/request/types/permissions/index.ts
+var resources = {
+  account,
+  common,
+  wallet
+};
+var utils = {
+  account: account2
+};
+var store = {
+  clientId,
+  client,
+  clientMetadata,
+  clientMetadataTable,
+  clientsTable,
+  resource,
+  resourcesTable,
+  permission,
+  permissionsTable,
+  permissionsStore
+};
+var permissions = {
+  resources,
+  utils,
+  store
+};
+
+// src/request/types/walletMethods.ts
+var permissionTemplate = v19.variant("type", [
+  v19.object({
+    ...v19.omit(permissions.resources.account.accountPermissionSchema, ["clientId"]).entries
   }),
-  v14.object({
-    ...v14.omit(import_xverse_core.permissions.resources.wallet.walletPermissionSchema, ["clientId"]).entries
+  v19.object({
+    ...v19.omit(permissions.resources.wallet.walletPermissionSchema, ["clientId"]).entries
   })
 ]);
 var requestPermissionsMethodName = "wallet_requestPermissions";
-var requestPermissionsParamsSchema = v14.nullish(v14.array(permissionTemplate));
-var requestPermissionsResultSchema = v14.literal(true);
-var requestPermissionsRequestMessageSchema = v14.object({
+var requestPermissionsParamsSchema = v19.nullish(v19.array(permissionTemplate));
+var requestPermissionsResultSchema = v19.literal(true);
+var requestPermissionsRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(requestPermissionsMethodName),
+  ...v19.object({
+    method: v19.literal(requestPermissionsMethodName),
     params: requestPermissionsParamsSchema,
-    id: v14.string()
+    id: v19.string()
   }).entries
 });
 var renouncePermissionsMethodName = "wallet_renouncePermissions";
-var renouncePermissionsParamsSchema = v14.nullish(v14.null());
-var renouncePermissionsResultSchema = v14.nullish(v14.null());
-var renouncePermissionsRequestMessageSchema = v14.object({
+var renouncePermissionsParamsSchema = v19.nullish(v19.null());
+var renouncePermissionsResultSchema = v19.nullish(v19.null());
+var renouncePermissionsRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(renouncePermissionsMethodName),
+  ...v19.object({
+    method: v19.literal(renouncePermissionsMethodName),
     params: renouncePermissionsParamsSchema,
-    id: v14.string()
+    id: v19.string()
   }).entries
 });
 var disconnectMethodName = "wallet_disconnect";
-var disconnectParamsSchema = v14.nullish(v14.null());
-var disconnectResultSchema = v14.nullish(v14.null());
-var disconnectRequestMessageSchema = v14.object({
+var disconnectParamsSchema = v19.nullish(v19.null());
+var disconnectResultSchema = v19.nullish(v19.null());
+var disconnectRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(disconnectMethodName),
+  ...v19.object({
+    method: v19.literal(disconnectMethodName),
     params: disconnectParamsSchema,
-    id: v14.string()
+    id: v19.string()
   }).entries
 });
 var getWalletTypeMethodName = "wallet_getWalletType";
-var getWalletTypeParamsSchema = v14.nullish(v14.null());
+var getWalletTypeParamsSchema = v19.nullish(v19.null());
 var getWalletTypeResultSchema = walletTypeSchema;
-var getWalletTypeRequestMessageSchema = v14.object({
+var getWalletTypeRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(getWalletTypeMethodName),
+  ...v19.object({
+    method: v19.literal(getWalletTypeMethodName),
     params: getWalletTypeParamsSchema,
-    id: v14.string()
+    id: v19.string()
   }).entries
 });
 var getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
-var getCurrentPermissionsParamsSchema = v14.nullish(v14.null());
-var getCurrentPermissionsResultSchema = v14.array(import_xverse_core.permissions.store.permission);
-var getCurrentPermissionsRequestMessageSchema = v14.object({
+var getCurrentPermissionsParamsSchema = v19.nullish(v19.null());
+var getCurrentPermissionsResultSchema = v19.array(permissions.store.permission);
+var getCurrentPermissionsRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(getCurrentPermissionsMethodName),
+  ...v19.object({
+    method: v19.literal(getCurrentPermissionsMethodName),
     params: getCurrentPermissionsParamsSchema,
-    id: v14.string()
+    id: v19.string()
   }).entries
 });
 var getAccountMethodName = "wallet_getAccount";
-var getAccountParamsSchema = v14.nullish(v14.null());
-var getAccountResultSchema = v14.object({
-  id: import_xverse_core.permissions.utils.account.accountIdSchema,
-  addresses: v14.array(addressSchema),
+var getAccountParamsSchema = v19.nullish(v19.null());
+var getAccountResultSchema = v19.object({
+  id: permissions.utils.account.accountIdSchema,
+  addresses: v19.array(addressSchema),
   walletType: walletTypeSchema
 });
-var getAccountRequestMessageSchema = v14.object({
+var getAccountRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(getAccountMethodName),
+  ...v19.object({
+    method: v19.literal(getAccountMethodName),
     params: getAccountParamsSchema,
-    id: v14.string()
+    id: v19.string()
   }).entries
 });
 var connectMethodName = "wallet_connect";
-var connectParamsSchema = v14.nullish(
-  v14.object({
-    permissions: v14.optional(v14.array(permissionTemplate))
+var connectParamsSchema = v19.nullish(
+  v19.object({
+    permissions: v19.optional(v19.array(permissionTemplate)),
+    addresses: v19.optional(v19.array(v19.enum(AddressPurpose))),
+    message: v19.optional(
+      v19.pipe(v19.string(), v19.maxLength(80, "The message must not exceed 80 characters."))
+    )
   })
 );
 var connectResultSchema = getAccountResultSchema;
-var connectRequestMessageSchema = v14.object({
+var connectRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(connectMethodName),
+  ...v19.object({
+    method: v19.literal(connectMethodName),
     params: connectParamsSchema,
-    id: v14.string()
+    id: v19.string()
   }).entries
 });
 
 // src/request/types/runesMethods/etch.ts
-var v15 = __toESM(require("valibot"));
+var v20 = __toESM(require("valibot"));
 var runesEtchMethodName = "runes_etch";
-var etchTermsSchema = v15.object({
-  amount: v15.string(),
-  cap: v15.string(),
-  heightStart: v15.optional(v15.string()),
-  heightEnd: v15.optional(v15.string()),
-  offsetStart: v15.optional(v15.string()),
-  offsetEnd: v15.optional(v15.string())
-});
-var inscriptionDetailsSchema = v15.object({
-  contentType: v15.string(),
-  contentBase64: v15.string()
-});
-var runesEtchParamsSchema = v15.object({
-  runeName: v15.string(),
-  divisibility: v15.optional(v15.number()),
-  symbol: v15.optional(v15.string()),
-  premine: v15.optional(v15.string()),
-  isMintable: v15.boolean(),
-  delegateInscriptionId: v15.optional(v15.string()),
-  destinationAddress: v15.string(),
-  refundAddress: v15.string(),
-  feeRate: v15.number(),
-  appServiceFee: v15.optional(v15.number()),
-  appServiceFeeAddress: v15.optional(v15.string()),
-  terms: v15.optional(etchTermsSchema),
-  inscriptionDetails: v15.optional(inscriptionDetailsSchema),
-  network: v15.optional(v15.enum(BitcoinNetworkType))
-});
-var runesEtchResultSchema = v15.object({
-  orderId: v15.string(),
-  fundTransactionId: v15.string(),
-  fundingAddress: v15.string()
-});
-var runesEtchRequestMessageSchema = v15.object({
+var etchTermsSchema = v20.object({
+  amount: v20.string(),
+  cap: v20.string(),
+  heightStart: v20.optional(v20.string()),
+  heightEnd: v20.optional(v20.string()),
+  offsetStart: v20.optional(v20.string()),
+  offsetEnd: v20.optional(v20.string())
+});
+var inscriptionDetailsSchema = v20.object({
+  contentType: v20.string(),
+  contentBase64: v20.string()
+});
+var runesEtchParamsSchema = v20.object({
+  runeName: v20.string(),
+  divisibility: v20.optional(v20.number()),
+  symbol: v20.optional(v20.string()),
+  premine: v20.optional(v20.string()),
+  isMintable: v20.boolean(),
+  delegateInscriptionId: v20.optional(v20.string()),
+  destinationAddress: v20.string(),
+  refundAddress: v20.string(),
+  feeRate: v20.number(),
+  appServiceFee: v20.optional(v20.number()),
+  appServiceFeeAddress: v20.optional(v20.string()),
+  terms: v20.optional(etchTermsSchema),
+  inscriptionDetails: v20.optional(inscriptionDetailsSchema),
+  network: v20.optional(v20.enum(BitcoinNetworkType))
+});
+var runesEtchResultSchema = v20.object({
+  orderId: v20.string(),
+  fundTransactionId: v20.string(),
+  fundingAddress: v20.string()
+});
+var runesEtchRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v15.object({
-    method: v15.literal(runesEtchMethodName),
+  ...v20.object({
+    method: v20.literal(runesEtchMethodName),
     params: runesEtchParamsSchema,
-    id: v15.string()
+    id: v20.string()
   }).entries
 });
 
 // src/request/types/runesMethods/getBalance.ts
-var v16 = __toESM(require("valibot"));
+var v21 = __toESM(require("valibot"));
 var runesGetBalanceMethodName = "runes_getBalance";
-var runesGetBalanceParamsSchema = v16.nullish(v16.null());
-var runesGetBalanceResultSchema = v16.object({
-  balances: v16.array(
-    v16.object({
-      runeName: v16.string(),
-      amount: v16.string(),
-      divisibility: v16.number(),
-      symbol: v16.string(),
-      inscriptionId: v16.nullish(v16.string())
+var runesGetBalanceParamsSchema = v21.nullish(v21.null());
+var runesGetBalanceResultSchema = v21.object({
+  balances: v21.array(
+    v21.object({
+      runeName: v21.string(),
+      amount: v21.string(),
+      divisibility: v21.number(),
+      symbol: v21.string(),
+      inscriptionId: v21.nullish(v21.string())
     })
   )
 });
-var runesGetBalanceRequestMessageSchema = v16.object({
+var runesGetBalanceRequestMessageSchema = v21.object({
   ...rpcRequestMessageSchema.entries,
-  ...v16.object({
-    method: v16.literal(runesGetBalanceMethodName),
+  ...v21.object({
+    method: v21.literal(runesGetBalanceMethodName),
     params: runesGetBalanceParamsSchema,
-    id: v16.string()
+    id: v21.string()
   }).entries
 });
 
 // src/request/types/runesMethods/mint.ts
-var v17 = __toESM(require("valibot"));
+var v22 = __toESM(require("valibot"));
 var runesMintMethodName = "runes_mint";
-var runesMintParamsSchema = v17.object({
-  appServiceFee: v17.optional(v17.number()),
-  appServiceFeeAddress: v17.optional(v17.string()),
-  destinationAddress: v17.string(),
-  feeRate: v17.number(),
-  refundAddress: v17.string(),
-  repeats: v17.number(),
-  runeName: v17.string(),
-  network: v17.optional(v17.enum(BitcoinNetworkType))
-});
-var runesMintResultSchema = v17.object({
-  orderId: v17.string(),
-  fundTransactionId: v17.string(),
-  fundingAddress: v17.string()
-});
-var runesMintRequestMessageSchema = v17.object({
+var runesMintParamsSchema = v22.object({
+  appServiceFee: v22.optional(v22.number()),
+  appServiceFeeAddress: v22.optional(v22.string()),
+  destinationAddress: v22.string(),
+  feeRate: v22.number(),
+  refundAddress: v22.string(),
+  repeats: v22.number(),
+  runeName: v22.string(),
+  network: v22.optional(v22.enum(BitcoinNetworkType))
+});
+var runesMintResultSchema = v22.object({
+  orderId: v22.string(),
+  fundTransactionId: v22.string(),
+  fundingAddress: v22.string()
+});
+var runesMintRequestMessageSchema = v22.object({
   ...rpcRequestMessageSchema.entries,
-  ...v17.object({
-    method: v17.literal(runesMintMethodName),
+  ...v22.object({
+    method: v22.literal(runesMintMethodName),
     params: runesMintParamsSchema,
-    id: v17.string()
+    id: v22.string()
   }).entries
 });
 
 // src/request/types/runesMethods/transfer.ts
-var v18 = __toESM(require("valibot"));
+var v23 = __toESM(require("valibot"));
 var runesTransferMethodName = "runes_transfer";
-var runesTransferParamsSchema = v18.object({
-  recipients: v18.array(
-    v18.object({
-      runeName: v18.string(),
-      amount: v18.string(),
-      address: v18.string()
+var runesTransferParamsSchema = v23.object({
+  recipients: v23.array(
+    v23.object({
+      runeName: v23.string(),
+      amount: v23.string(),
+      address: v23.string()
     })
   )
 });
-var runesTransferResultSchema = v18.object({
-  txid: v18.string()
+var runesTransferResultSchema = v23.object({
+  txid: v23.string()
 });
-var runesTransferRequestMessageSchema = v18.object({
+var runesTransferRequestMessageSchema = v23.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(runesTransferMethodName),
+  ...v23.object({
+    method: v23.literal(runesTransferMethodName),
     params: runesTransferParamsSchema,
-    id: v18.string()
+    id: v23.string()
   }).entries
 });
 
 // src/request/types/ordinalsMethods.ts
-var v19 = __toESM(require("valibot"));
+var v24 = __toESM(require("valibot"));
 var getInscriptionsMethodName = "ord_getInscriptions";
-var getInscriptionsParamsSchema = v19.object({
-  offset: v19.number(),
-  limit: v19.number()
-});
-var getInscriptionsResultSchema = v19.object({
-  total: v19.number(),
-  limit: v19.number(),
-  offset: v19.number(),
-  inscriptions: v19.array(
-    v19.object({
-      inscriptionId: v19.string(),
-      inscriptionNumber: v19.string(),
-      address: v19.string(),
-      collectionName: v19.optional(v19.string()),
-      postage: v19.string(),
-      contentLength: v19.string(),
-      contentType: v19.string(),
-      timestamp: v19.number(),
-      offset: v19.number(),
-      genesisTransaction: v19.string(),
-      output: v19.string()
+var getInscriptionsParamsSchema = v24.object({
+  offset: v24.number(),
+  limit: v24.number()
+});
+var getInscriptionsResultSchema = v24.object({
+  total: v24.number(),
+  limit: v24.number(),
+  offset: v24.number(),
+  inscriptions: v24.array(
+    v24.object({
+      inscriptionId: v24.string(),
+      inscriptionNumber: v24.string(),
+      address: v24.string(),
+      collectionName: v24.optional(v24.string()),
+      postage: v24.string(),
+      contentLength: v24.string(),
+      contentType: v24.string(),
+      timestamp: v24.number(),
+      offset: v24.number(),
+      genesisTransaction: v24.string(),
+      output: v24.string()
     })
   )
 });
-var getInscriptionsRequestMessageSchema = v19.object({
+var getInscriptionsRequestMessageSchema = v24.object({
   ...rpcRequestMessageSchema.entries,
-  ...v19.object({
-    method: v19.literal(getInscriptionsMethodName),
+  ...v24.object({
+    method: v24.literal(getInscriptionsMethodName),
     params: getInscriptionsParamsSchema,
-    id: v19.string()
+    id: v24.string()
   }).entries
 });
 var sendInscriptionsMethodName = "ord_sendInscriptions";
-var sendInscriptionsParamsSchema = v19.object({
-  transfers: v19.array(
-    v19.object({
-      address: v19.string(),
-      inscriptionId: v19.string()
+var sendInscriptionsParamsSchema = v24.object({
+  transfers: v24.array(
+    v24.object({
+      address: v24.string(),
+      inscriptionId: v24.string()
     })
   )
 });
-var sendInscriptionsResultSchema = v19.object({
-  txid: v19.string()
+var sendInscriptionsResultSchema = v24.object({
+  txid: v24.string()
 });
-var sendInscriptionsRequestMessageSchema = v19.object({
+var sendInscriptionsRequestMessageSchema = v24.object({
   ...rpcRequestMessageSchema.entries,
-  ...v19.object({
-    method: v19.literal(sendInscriptionsMethodName),
+  ...v24.object({
+    method: v24.literal(sendInscriptionsMethodName),
     params: sendInscriptionsParamsSchema,
-    id: v19.string()
+    id: v24.string()
   }).entries
 });
 
@@ -1178,13 +1675,13 @@ var request = async (method, params, providerId) => {
     throw new Error("A wallet method is required");
   }
   const response = await provider.request(method, params);
-  if (v20.is(rpcErrorResponseMessageSchema, response)) {
+  if (v25.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v20.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v25.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -1940,8 +2437,7 @@ var extractOrValidateCapabilities = (provider, reportedCapabilities) => {
     addListener: validateCapability("addListener")
   };
   return Object.entries(capabilityMap).reduce((acc, [capability, value]) => {
-    if (value)
-      return [...acc, capability];
+    if (value) return [...acc, capability];
     return acc;
   }, []);
 };
@@ -2283,3 +2779,8 @@ var signMultipleTransactions = async (options) => {
   walletTypeSchema,
   walletTypes
 });
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/