@secondlayer/stacks 6.0.0 → 6.1.0

package/dist/src/accounts/index.cjs

@@ -1,3 +1,66 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
 // src/accounts/index.ts
 var exports_accounts = {};
 __export(exports_accounts, {
@@ -12,12 +75,275 @@ module.exports = __toCommonJS(exports_accounts);
 
 // src/accounts/privateKeyToAccount.ts
 var import_hmac = require("@noble/hashes/hmac.js");
-var import_sha2 = require("@noble/hashes/sha2.js");
+var import_sha24 = require("@noble/hashes/sha2.js");
 var import_secp256k1 = require("@noble/secp256k1");
+
+// src/utils/c32.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const b of bytes) {
+    hex += hexes[b];
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  let h = without0x(hex);
+  if (h.length % 2)
+    h = `0${h}`;
+  const array = new Uint8Array(h.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(h.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function with0x(value) {
+  return /^0x/i.test(value) ? value : `0x${value}`;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+function utf8ToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function bytesToUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function asciiToBytes(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0;i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function bytesToAscii(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function concatBytes(...arrays) {
+  if (arrays.length === 1)
+    return arrays[0];
+  const length = arrays.reduce((a, arr) => a + arr.length, 0);
+  const result = new Uint8Array(length);
+  let pad = 0;
+  for (const arr of arrays) {
+    result.set(arr, pad);
+    pad += arr.length;
+  }
+  return result;
+}
+function intToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string")
+    return BigInt(value);
+  if (typeof value === "number") {
+    if (!Number.isInteger(value))
+      throw new RangeError("Values of type 'number' must be an integer.");
+    if (value > Number.MAX_SAFE_INTEGER)
+      throw new RangeError(`Values of type 'number' must be <= ${Number.MAX_SAFE_INTEGER}. Use BigInt instead.`);
+    return BigInt(value);
+  }
+  if (value instanceof Uint8Array)
+    return BigInt(`0x${bytesToHex(value)}`);
+  throw new TypeError("Must be a number, bigint, string, or Uint8Array.");
+}
+function intToBytes(value, byteLength) {
+  return bigIntToBytes(intToBigInt(value), byteLength);
+}
+function bigIntToBytes(value, length = 16) {
+  const hex = value.toString(16).padStart(length * 2, "0");
+  return hexToBytes(hex);
+}
+function intToHex(integer, byteLength = 8) {
+  const value = typeof integer === "bigint" ? integer : intToBigInt(integer);
+  return value.toString(16).padStart(byteLength * 2, "0");
+}
+function toTwos(value, width) {
+  const limit = BigInt(1) << width - BigInt(1);
+  if (value < -limit || value > limit - BigInt(1)) {
+    throw new Error(`Unable to represent integer in width: ${width}`);
+  }
+  if (value >= BigInt(0))
+    return value;
+  return value + (BigInt(1) << width);
+}
+function fromTwos(value, width) {
+  if (value & BigInt(1) << width - BigInt(1)) {
+    return value - (BigInt(1) << width);
+  }
+  return value;
+}
+function bytesToTwosBigInt(bytes) {
+  if (bytes.length === 0)
+    return 0n;
+  const hex = bytesToHex(bytes);
+  if (hex.length === 0)
+    return 0n;
+  return fromTwos(BigInt(`0x${hex}`), BigInt(bytes.byteLength * 8));
+}
+function writeUInt32BE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value >>> 24 & 255;
+  buf[1] = value >>> 16 & 255;
+  buf[2] = value >>> 8 & 255;
+  buf[3] = value & 255;
+  return buf;
+}
+function readUInt32BE(bytes, offset = 0) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function writeUInt16BE(value) {
+  const buf = new Uint8Array(2);
+  buf[0] = value >>> 8 & 255;
+  buf[1] = value & 255;
+  return buf;
+}
+function readUInt16BE(bytes, offset = 0) {
+  return (bytes[offset] << 8 | bytes[offset + 1]) >>> 0;
+}
+function writeUInt8(value) {
+  return new Uint8Array([value & 255]);
+}
+
+// src/utils/c32.ts
+var C32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var HEX = "0123456789abcdef";
+function c32normalize(input) {
+  return input.toUpperCase().replace(/O/g, "0").replace(/L|I/g, "1");
+}
+function c32encode(inputHex) {
+  let hex = inputHex;
+  if (hex.length % 2 !== 0)
+    hex = `0${hex}`;
+  hex = hex.toLowerCase();
+  const res = [];
+  let carry = 0;
+  for (let i = hex.length - 1;i >= 0; i--) {
+    if (carry < 4) {
+      const currentCode = HEX.indexOf(hex[i]) >> carry;
+      const nextCode = i !== 0 ? HEX.indexOf(hex[i - 1]) : 0;
+      const nextBits = 1 + carry;
+      const nextLowBits = nextCode % (1 << nextBits) << 5 - nextBits;
+      res.unshift(C32[currentCode + nextLowBits]);
+      carry = nextBits;
+    } else {
+      carry = 0;
+    }
+  }
+  let leadingZeros = 0;
+  while (leadingZeros < res.length && res[leadingZeros] === "0")
+    leadingZeros++;
+  const stripped = res.slice(leadingZeros);
+  const bytes = hexToBytes(hex);
+  let zeroBytesCount = 0;
+  while (zeroBytesCount < bytes.length && bytes[zeroBytesCount] === 0)
+    zeroBytesCount++;
+  const prefix = Array(zeroBytesCount).fill(C32[0]);
+  return [...prefix, ...stripped].join("");
+}
+function c32decode(c32input) {
+  const input = c32normalize(c32input);
+  if (!input.match(`^[${C32}]*$`))
+    throw new Error("Not a c32-encoded string");
+  const zeroPrefix = input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0]?.length : 0;
+  const res = [];
+  let carry = 0;
+  let carryBits = 0;
+  for (let i = input.length - 1;i >= 0; i--) {
+    if (carryBits === 4) {
+      res.unshift(HEX[carry]);
+      carryBits = 0;
+      carry = 0;
+    }
+    const currentValue = (C32.indexOf(input[i]) << carryBits) + carry;
+    res.unshift(HEX[currentValue % 16]);
+    carryBits += 1;
+    carry = currentValue >> 4;
+    if (carry > 1 << carryBits)
+      throw new Error("Panic error in c32 decoding");
+  }
+  res.unshift(HEX[carry]);
+  if (res.length % 2 === 1)
+    res.unshift("0");
+  let hexLeadingZeros = 0;
+  while (hexLeadingZeros < res.length && res[hexLeadingZeros] === "0")
+    hexLeadingZeros++;
+  let hexStr = res.slice(hexLeadingZeros - hexLeadingZeros % 2).join("");
+  for (let i = 0;i < numLeadingZeroBytes; i++)
+    hexStr = `00${hexStr}`;
+  return hexStr;
+}
+function c32checksum(dataHex) {
+  return bytesToHex(import_sha2.sha256(import_sha2.sha256(hexToBytes(dataHex))).slice(0, 4));
+}
+function c32checkEncode(version, data) {
+  if (version < 0 || version >= 32)
+    throw new Error("Invalid version (must be between 0 and 31)");
+  if (!data.match(/^[0-9a-fA-F]*$/))
+    throw new Error("Invalid data (not a hex string)");
+  let d = data.toLowerCase();
+  if (d.length % 2 !== 0)
+    d = `0${d}`;
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  const checksumHex = c32checksum(`${versionHex}${d}`);
+  return `${C32[version]}${c32encode(`${d}${checksumHex}`)}`;
+}
+function c32checkDecode(c32data) {
+  const normalized = c32normalize(c32data);
+  const dataHex = c32decode(normalized.slice(1));
+  const version = C32.indexOf(normalized[0]);
+  const checksum = dataHex.slice(-8);
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {
+    throw new Error("Invalid c32check string: checksum mismatch");
+  }
+  return [version, dataHex.substring(0, dataHex.length - 8)];
+}
+function c32address(version, hash160hex) {
+  if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {
+    throw new Error("Invalid argument: not a hash160 hex string");
+  }
+  return `S${c32checkEncode(version, hash160hex)}`;
+}
+function c32addressDecode(c32addr) {
+  if (c32addr.length <= 5)
+    throw new Error("Invalid c32 address: invalid length");
+  if (c32addr[0] !== "S")
+    throw new Error('Invalid c32 address: must start with "S"');
+  return c32checkDecode(c32addr.slice(1));
+}
+
+// src/utils/hash.ts
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
+function hash160(input) {
+  return import_legacy.ripemd160(import_sha22.sha256(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(import_sha23.sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+
+// src/accounts/privateKeyToAccount.ts
 function ensureSyncSigning() {
   if (!import_secp256k1.etc.hmacSha256Sync) {
     import_secp256k1.etc.hmacSha256Sync = (key, ...msgs) => {
-      const h = import_hmac.hmac.create(import_sha2.sha256, key);
+      const h = import_hmac.hmac.create(import_sha24.sha256, key);
       for (const msg of msgs)
         h.update(msg);
       return h.digest();
@@ -46,7 +372,7 @@ function privateKeyToAccount(privateKey, options) {
     },
     signMessage(message) {
       const msgBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
-      const msgHash = import_sha2.sha256(msgBytes);
+      const msgHash = import_sha24.sha256(msgBytes);
       const sigBytes = this.sign(msgHash);
       return bytesToHex(sigBytes);
     }
@@ -81,6 +407,220 @@ function mnemonicToAccount(mnemonic, options) {
 // src/accounts/mnemonicToBitcoinKeys.ts
 var import_bip322 = require("@scure/bip32");
 var import_bip392 = require("@scure/bip39");
+
+// src/bitcoin/address.ts
+var import_secp256k12 = require("@noble/curves/secp256k1.js");
+var import_base = require("@scure/base");
+
+// src/bitcoin/serialize.ts
+function doubleSha256(bytes) {
+  return import_sha22.sha256(import_sha22.sha256(bytes));
+}
+function reverseBytes(bytes) {
+  const out = new Uint8Array(bytes.length);
+  for (let i = 0;i < bytes.length; i++) {
+    out[i] = bytes[bytes.length - 1 - i];
+  }
+  return out;
+}
+
+class BtcReader {
+  data;
+  view;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  get length() {
+    return this.data.length;
+  }
+  readUInt8() {
+    const v = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return v;
+  }
+  peekUInt8() {
+    return this.view.getUint8(this.offset);
+  }
+  readUInt32LE() {
+    const v = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return v;
+  }
+  readUInt64LE() {
+    const v = this.view.getBigUint64(this.offset, true);
+    this.offset += 8;
+    return v;
+  }
+  readBytes(n) {
+    if (this.offset + n > this.data.length) {
+      throw new Error(`Bitcoin tx underflow: need ${n} bytes at offset ${this.offset}, have ${this.data.length}`);
+    }
+    const slice = this.data.slice(this.offset, this.offset + n);
+    this.offset += n;
+    return slice;
+  }
+  readVarInt() {
+    const first = this.readUInt8();
+    if (first < 253)
+      return first;
+    if (first === 253) {
+      const v = this.view.getUint16(this.offset, true);
+      this.offset += 2;
+      return v;
+    }
+    if (first === 254) {
+      return this.readUInt32LE();
+    }
+    const big = this.readUInt64LE();
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Bitcoin varint exceeds safe integer range");
+    }
+    return Number(big);
+  }
+}
+function scanTx(rawTx) {
+  const r = new BtcReader(rawTx);
+  const version = r.readUInt32LE();
+  let hasWitness = false;
+  if (r.peekUInt8() === 0) {
+    r.readUInt8();
+    const flag = r.readUInt8();
+    if (flag !== 1) {
+      throw new Error(`Unexpected SegWit flag 0x${flag.toString(16)}`);
+    }
+    hasWitness = true;
+  }
+  const bodyStart = r.offset;
+  const inputCount = r.readVarInt();
+  const inputs = [];
+  for (let i = 0;i < inputCount; i++) {
+    const prevTxid = r.readBytes(32);
+    const vout = r.readUInt32LE();
+    const scriptSig = r.readBytes(r.readVarInt());
+    const sequence = r.readUInt32LE();
+    inputs.push({ prevTxid, vout, scriptSig, sequence });
+  }
+  const outputCount = r.readVarInt();
+  const outputs = [];
+  for (let i = 0;i < outputCount; i++) {
+    const value = r.readUInt64LE();
+    const scriptPubKey = r.readBytes(r.readVarInt());
+    outputs.push({ value, scriptPubKey });
+  }
+  const bodyEnd = r.offset;
+  if (hasWitness) {
+    for (let i = 0;i < inputCount; i++) {
+      const itemCount = r.readVarInt();
+      for (let j = 0;j < itemCount; j++) {
+        r.readBytes(r.readVarInt());
+      }
+    }
+  }
+  const locktime = r.readUInt32LE();
+  const legacy = concatBytes(rawTx.slice(0, 4), rawTx.slice(bodyStart, bodyEnd), rawTx.slice(r.offset - 4, r.offset));
+  return { version, hasWitness, inputs, outputs, locktime, legacy };
+}
+function parseBitcoinTx(rawTx) {
+  const s = scanTx(rawTx);
+  return {
+    version: s.version,
+    hasWitness: s.hasWitness,
+    inputs: s.inputs,
+    outputs: s.outputs,
+    locktime: s.locktime,
+    txidInternal: doubleSha256(s.legacy)
+  };
+}
+function stripWitness(rawTx) {
+  return scanTx(rawTx).legacy;
+}
+function bitcoinTxid(rawTx, { display = false } = {}) {
+  const txid = doubleSha256(scanTx(rawTx).legacy);
+  return display ? reverseBytes(txid) : txid;
+}
+function parseBlockHeader(header) {
+  if (header.length !== 80) {
+    throw new Error(`Bitcoin block header must be 80 bytes, got ${header.length}`);
+  }
+  const r = new BtcReader(header);
+  const version = r.readUInt32LE();
+  const prevBlock = r.readBytes(32);
+  const merkleRoot = r.readBytes(32);
+  const timestamp = r.readUInt32LE();
+  const bits = r.readUInt32LE();
+  const nonce = r.readUInt32LE();
+  return { version, prevBlock, merkleRoot, timestamp, bits, nonce };
+}
+function blockHash(header, { display = false } = {}) {
+  const hash = doubleSha256(header);
+  return display ? reverseBytes(hash) : hash;
+}
+
+// src/bitcoin/address.ts
+var BITCOIN_NETWORK_PARAMS = {
+  mainnet: { p2pkh: 0, p2sh: 5, hrp: "bc" },
+  testnet: { p2pkh: 111, p2sh: 196, hrp: "tb" },
+  regtest: { p2pkh: 111, p2sh: 196, hrp: "bcrt" }
+};
+var NETWORK_PARAMS = BITCOIN_NETWORK_PARAMS;
+function base58CheckEncode(version, payload) {
+  const data = concatBytes(Uint8Array.of(version), payload);
+  const checksum = doubleSha256(data).slice(0, 4);
+  return import_base.base58.encode(concatBytes(data, checksum));
+}
+function formatBitcoinAddress(parsed, network = "mainnet") {
+  const params = NETWORK_PARAMS[network];
+  const hash = parsed.hash;
+  if (!hash)
+    return;
+  switch (parsed.type) {
+    case "p2pkh":
+      return base58CheckEncode(params.p2pkh, hash);
+    case "p2sh":
+      return base58CheckEncode(params.p2sh, hash);
+    case "p2wpkh":
+    case "p2wsh":
+      return import_base.bech32.encode(params.hrp, [0, ...import_base.bech32.toWords(hash)]);
+    case "p2tr":
+      return import_base.bech32m.encode(params.hrp, [1, ...import_base.bech32m.toWords(hash)]);
+    default:
+      return;
+  }
+}
+function toPubkeyBytes(publicKey) {
+  return typeof publicKey === "string" ? hexToBytes(publicKey) : publicKey;
+}
+function taprootTweakPubkey(xonly) {
+  if (xonly.length !== 32)
+    throw new Error(`Expected 32-byte x-only pubkey, got ${xonly.length}`);
+  const tweak = import_secp256k12.schnorr.utils.taggedHash("TapTweak", xonly);
+  const t = BigInt(`0x${Array.from(tweak, (b) => b.toString(16).padStart(2, "0")).join("")}`);
+  if (t >= import_secp256k12.secp256k1.Point.Fn.ORDER)
+    throw new Error("Invalid tap tweak (exceeds curve order)");
+  const internal = import_secp256k12.secp256k1.Point.fromBytes(concatBytes(Uint8Array.of(2), xonly));
+  const output = internal.add(import_secp256k12.secp256k1.Point.BASE.multiply(t));
+  return output.toBytes(true).slice(1);
+}
+function publicKeyToP2wpkhAddress(publicKey, network = "mainnet") {
+  const pubkey = toPubkeyBytes(publicKey);
+  if (pubkey.length !== 33)
+    throw new Error(`Expected 33-byte compressed pubkey, got ${pubkey.length}`);
+  const params = NETWORK_PARAMS[network];
+  return import_base.bech32.encode(params.hrp, [0, ...import_base.bech32.toWords(hash160(pubkey))]);
+}
+function publicKeyToP2trAddress(publicKey, network = "mainnet") {
+  const pubkey = toPubkeyBytes(publicKey);
+  const xonly = pubkey.length === 33 ? pubkey.slice(1) : pubkey.length === 32 ? pubkey : undefined;
+  if (!xonly)
+    throw new Error(`Expected 33-byte compressed or 32-byte x-only pubkey, got ${pubkey.length}`);
+  const params = NETWORK_PARAMS[network];
+  const outputKey = taprootTweakPubkey(xonly);
+  return import_base.bech32m.encode(params.hrp, [1, ...import_base.bech32m.toWords(outputKey)]);
+}
+
+// src/accounts/mnemonicToBitcoinKeys.ts
 var PURPOSE = { p2wpkh: 84, p2tr: 86 };
 function mnemonicToBitcoinKeys(mnemonic, options) {
   const {
@@ -113,6 +653,20 @@ function toAccount(source) {
     sign: source.sign
   };
 }
+// src/accounts/providerToAccount.ts
+async function providerToAccount(provider) {
+  const result = await provider.request("stx_getAddresses");
+  const entry = result?.addresses?.[0];
+  if (!entry?.address || !entry?.publicKey) {
+    throw new Error("Provider did not return a valid address");
+  }
+  return {
+    type: "provider",
+    address: entry.address,
+    publicKey: entry.publicKey,
+    provider
+  };
+}
 
-//# debugId=D2C5E3F81BCB428564756E2164756E21
+//# debugId=078576ECB761A90064756E2164756E21
 //# sourceMappingURL=index.cjs.map