@secondlayer/stacks 0.0.1

package/dist/shared/stacks-yfgsm6ap.js

@@ -0,0 +1,599 @@
+import {
+  serializeCVBytes
+} from "./stacks-8yykgdww.js";
+import {
+  hash160,
+  hashP2PKH,
+  txidFromBytes
+} from "./stacks-bycy6t9k.js";
+import {
+  asciiToBytes,
+  bytesToHex,
+  c32address,
+  c32addressDecode,
+  concatBytes,
+  hexToBytes,
+  intToBytes,
+  intToHex,
+  utf8ToBytes,
+  writeUInt16BE,
+  writeUInt32BE,
+  writeUInt8
+} from "./stacks-nqytwfcc.js";
+
+// src/transactions/multisig.ts
+import {
+  getPublicKey as nobleGetPublicKey2,
+  sign as nobleSign
+} from "@noble/secp256k1";
+
+// src/transactions/authorization.ts
+import {
+  getPublicKey as nobleGetPublicKey,
+  sign,
+  etc
+} from "@noble/secp256k1";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+
+// src/transactions/types.ts
+var AuthType = {
+  Standard: 4,
+  Sponsored: 5
+};
+var PayloadType = {
+  TokenTransfer: 0,
+  SmartContract: 1,
+  ContractCall: 2,
+  PoisonMicroblock: 3,
+  Coinbase: 4,
+  CoinbaseToAltRecipient: 5,
+  VersionedSmartContract: 6,
+  TenureChange: 7,
+  NakamotoCoinbase: 8
+};
+var ClarityVersion = {
+  Clarity1: 1,
+  Clarity2: 2,
+  Clarity3: 3
+};
+var AnchorMode = {
+  OnChainOnly: 1,
+  OffChainOnly: 2,
+  Any: 3
+};
+var PostConditionModeWire = {
+  Allow: 1,
+  Deny: 2
+};
+var AddressHashMode = {
+  P2PKH: 0,
+  P2SH: 1,
+  P2WPKH: 2,
+  P2WSH: 3,
+  P2SH_NonSequential: 5,
+  P2WSH_P2SH_NonSequential: 7
+};
+var PubKeyEncoding = {
+  Compressed: 0,
+  Uncompressed: 1
+};
+var FungibleConditionCode = {
+  Equal: 1,
+  Greater: 2,
+  GreaterEqual: 3,
+  Less: 4,
+  LessEqual: 5
+};
+var NonFungibleConditionCode = {
+  Sends: 16,
+  DoesNotSend: 17
+};
+var PostConditionPrincipalId = {
+  Origin: 1,
+  Standard: 2,
+  Contract: 3
+};
+var AssetType = {
+  STX: 0,
+  Fungible: 1,
+  NonFungible: 2
+};
+var AuthFieldType = {
+  PublicKeyCompressed: 0,
+  PublicKeyUncompressed: 1,
+  SignatureCompressed: 2,
+  SignatureUncompressed: 3
+};
+var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
+var MEMO_MAX_LENGTH_BYTES = 34;
+var MAX_STRING_LENGTH_BYTES = 128;
+
+// src/transactions/authorization.ts
+etc.hmacSha256Sync = (key, ...msgs) => {
+  const h = hmac.create(sha256, key);
+  msgs.forEach((msg) => h.update(msg));
+  return h.digest();
+};
+var EMPTY_SIG = bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
+function createSingleSigSpendingCondition(publicKey, nonce, fee) {
+  const pubKeyBytes = hexToBytes(publicKey);
+  const signer = hashP2PKH(pubKeyBytes);
+  const isCompressed = pubKeyBytes.length === 33;
+  return {
+    hashMode: AddressHashMode.P2PKH,
+    signer,
+    nonce,
+    fee,
+    keyEncoding: isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed,
+    signature: EMPTY_SIG
+  };
+}
+function createStandardAuth(spendingCondition) {
+  return { authType: AuthType.Standard, spendingCondition };
+}
+function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {
+  return {
+    authType: AuthType.Sponsored,
+    spendingCondition,
+    sponsorSpendingCondition: sponsorSpendingCondition ?? createSingleSigSpendingCondition("0".repeat(66), 0n, 0n)
+  };
+}
+function clearCondition(condition) {
+  if ("signature" in condition) {
+    return {
+      ...condition,
+      nonce: 0n,
+      fee: 0n,
+      signature: EMPTY_SIG
+    };
+  }
+  return {
+    ...condition,
+    nonce: 0n,
+    fee: 0n,
+    fields: []
+  };
+}
+function intoInitialSighashAuth(auth) {
+  if (auth.authType === AuthType.Standard) {
+    return createStandardAuth(clearCondition(auth.spendingCondition));
+  }
+  return createSponsoredAuth(clearCondition(auth.spendingCondition), clearCondition(createSingleSigSpendingCondition("0".repeat(66), 0n, 0n)));
+}
+function sigHashPreSign(curSigHash, authType, fee, nonce) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([authType]), intToBytes(fee, 8), intToBytes(nonce, 8));
+  return txidFromBytes(data);
+}
+function sigHashPostSign(curSigHash, pubKeyEncoding, signature) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([pubKeyEncoding]), hexToBytes(signature));
+  return txidFromBytes(data);
+}
+function signWithKey(privateKey, messageHash) {
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const sig = sign(messageHash, keyBytes, { lowS: true });
+  const recoveryIdHex = intToHex(sig.recovery, 1);
+  return recoveryIdHex + sig.toCompactHex();
+}
+function nextSignature(curSigHash, authType, fee, nonce, privateKey) {
+  const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const pubKey = nobleGetPublicKey(keyBytes, true);
+  const isCompressed = pubKey.length === 33;
+  const pubKeyEncoding = isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed;
+  const nextSig = signWithKey(privateKey, sigHashPre);
+  const nextSigHash = sigHashPostSign(sigHashPre, pubKeyEncoding, nextSig);
+  return { nextSig, nextSigHash };
+}
+
+// src/transactions/wire/serialize.ts
+function serializeAddress(c32Address) {
+  const [version, hash1602] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+}
+function serializeLPString(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const prefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(prefix, content);
+}
+function serializeLPStringLong(str) {
+  return serializeLPString(str, 4);
+}
+function serializeMemo(memo) {
+  const content = asciiToBytes(memo);
+  const padded = new Uint8Array(MEMO_MAX_LENGTH_BYTES);
+  padded.set(content.slice(0, MEMO_MAX_LENGTH_BYTES));
+  return concatBytes(writeUInt8(content.length), padded);
+}
+function serializeSpendingCondition(condition) {
+  const parts = [
+    writeUInt8(condition.hashMode),
+    hexToBytes(condition.signer),
+    intToBytes(condition.nonce, 8),
+    intToBytes(condition.fee, 8)
+  ];
+  if ("signature" in condition) {
+    const sc = condition;
+    parts.push(writeUInt8(sc.keyEncoding));
+    parts.push(hexToBytes(sc.signature));
+  } else {
+    const mc = condition;
+    parts.push(writeUInt32BE(mc.fields.length));
+    for (const field of mc.fields) {
+      parts.push(serializeAuthField(field));
+    }
+    parts.push(writeUInt16BE(mc.signaturesRequired));
+  }
+  return concatBytes(...parts);
+}
+function serializeAuthField(field) {
+  if (field.type === "publicKey") {
+    const typeId = field.pubKeyEncoding === 0 ? 0 : 1;
+    return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
+  } else {
+    const typeId = field.pubKeyEncoding === 0 ? 2 : 3;
+    return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
+  }
+}
+function serializeAuthorization(auth) {
+  const parts = [writeUInt8(auth.authType)];
+  parts.push(serializeSpendingCondition(auth.spendingCondition));
+  if (auth.authType === AuthType.Sponsored) {
+    parts.push(serializeSpendingCondition(auth.sponsorSpendingCondition));
+  }
+  return concatBytes(...parts);
+}
+function serializePrincipal(principal) {
+  switch (principal.type) {
+    case "origin":
+      return writeUInt8(PostConditionPrincipalId.Origin);
+    case "standard":
+      return concatBytes(writeUInt8(PostConditionPrincipalId.Standard), serializeAddress(principal.address));
+    case "contract":
+      return concatBytes(writeUInt8(PostConditionPrincipalId.Contract), serializeAddress(principal.address), serializeLPString(principal.contractName));
+  }
+}
+function serializeAssetInfo(asset) {
+  return concatBytes(serializeAddress(asset.address), serializeLPString(asset.contractName), serializeLPString(asset.assetName));
+}
+function serializePostCondition(pc) {
+  const parts = [serializePrincipal(pc.principal)];
+  switch (pc.type) {
+    case "stx":
+      parts.push(writeUInt8(AssetType.STX));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "ft":
+      parts.push(writeUInt8(AssetType.Fungible));
+      parts.push(serializeAssetInfo(pc.asset));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "nft":
+      parts.push(writeUInt8(AssetType.NonFungible));
+      parts.push(serializeAssetInfo(pc.asset));
+      parts.push(serializeCVBytes(pc.assetId));
+      parts.push(writeUInt8(pc.conditionCode));
+      break;
+  }
+  return concatBytes(...parts);
+}
+function serializePostConditions(pcs) {
+  const parts = [writeUInt32BE(pcs.length)];
+  for (const pc of pcs) {
+    parts.push(serializePostCondition(pc));
+  }
+  return concatBytes(...parts);
+}
+function serializePayload(payload) {
+  const parts = [writeUInt8(payload.payloadType)];
+  switch (payload.payloadType) {
+    case PayloadType.TokenTransfer:
+      parts.push(serializeCVBytes(payload.recipient));
+      parts.push(intToBytes(payload.amount, 8));
+      parts.push(serializeMemo(payload.memo));
+      break;
+    case PayloadType.ContractCall:
+      parts.push(serializeAddress(payload.contractAddress));
+      parts.push(serializeLPString(payload.contractName));
+      parts.push(serializeLPString(payload.functionName));
+      parts.push(writeUInt32BE(payload.functionArgs.length));
+      for (const arg of payload.functionArgs) {
+        parts.push(serializeCVBytes(arg));
+      }
+      break;
+    case PayloadType.SmartContract:
+      parts.push(serializeLPString(payload.contractName));
+      parts.push(serializeLPStringLong(payload.codeBody));
+      break;
+    case PayloadType.VersionedSmartContract:
+      parts.push(writeUInt8(payload.clarityVersion ?? 2));
+      parts.push(serializeLPString(payload.contractName));
+      parts.push(serializeLPStringLong(payload.codeBody));
+      break;
+  }
+  return concatBytes(...parts);
+}
+function serializeTransaction(tx) {
+  return concatBytes(writeUInt8(tx.version), writeUInt32BE(tx.chainId), serializeAuthorization(tx.auth), writeUInt8(tx.anchorMode), writeUInt8(tx.postConditionMode), serializePostConditions(tx.postConditions), serializePayload(tx.payload));
+}
+function serializeTransactionHex(tx) {
+  return bytesToHex(serializeTransaction(tx));
+}
+
+// src/transactions/multisig.ts
+var OP_CHECKMULTISIG = 174;
+function isNonSequential(hashMode) {
+  return (hashMode & 4) !== 0;
+}
+function makeRedeemScript(publicKeys, signaturesRequired) {
+  const parts = [];
+  parts.push(new Uint8Array([80 + signaturesRequired]));
+  for (const pk of publicKeys) {
+    const pkBytes = hexToBytes(pk);
+    parts.push(new Uint8Array([pkBytes.length]));
+    parts.push(pkBytes);
+  }
+  parts.push(new Uint8Array([80 + publicKeys.length]));
+  parts.push(new Uint8Array([OP_CHECKMULTISIG]));
+  return concatBytes(...parts);
+}
+function makeMultiSigAddress(publicKeys, signaturesRequired, chain) {
+  if (signaturesRequired < 1 || signaturesRequired > publicKeys.length) {
+    throw new Error(`signaturesRequired must be between 1 and ${publicKeys.length}`);
+  }
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = hash160(redeemScript);
+  const version = chain?.addressVersion?.multiSig ?? 20;
+  return c32address(version, bytesToHex(signer));
+}
+function createMultiSigSpendingCondition(publicKeys, signaturesRequired, nonce, fee, hashMode = AddressHashMode.P2SH) {
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = bytesToHex(hash160(redeemScript));
+  return {
+    hashMode,
+    signer,
+    nonce,
+    fee,
+    fields: [],
+    signaturesRequired
+  };
+}
+function initialSigHash(tx) {
+  const cleared = {
+    ...tx,
+    auth: intoInitialSighashAuth(tx.auth)
+  };
+  return txidFromBytes(serializeTransaction(cleared));
+}
+function nonSequentialPreSignHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  const initHash = initialSigHash(tx);
+  return sigHashPreSign(initHash, AuthType.Standard, condition.fee, condition.nonce);
+}
+function replayMultiSigSigHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  if (isNonSequential(condition.hashMode)) {
+    const preSign = nonSequentialPreSignHash(tx);
+    let curSigHash2 = preSign;
+    for (const field of condition.fields) {
+      curSigHash2 = sigHashPostSign(curSigHash2, field.pubKeyEncoding, field.data);
+    }
+    return curSigHash2;
+  }
+  let curSigHash = initialSigHash(tx);
+  for (const field of condition.fields) {
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+  }
+  return curSigHash;
+}
+function signMultiSig(tx, privateKey, publicKeys) {
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const signerPubKey = bytesToHex(nobleGetPublicKey2(keyBytes, true));
+  const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
+  if (signerIndex === -1) {
+    throw new Error("Private key does not correspond to any signer in the multi-sig");
+  }
+  const condition = { ...tx.auth.spendingCondition };
+  if (isNonSequential(condition.hashMode)) {
+    return signNonSequential(tx, condition, privateKey);
+  }
+  return signSequential(tx, condition, privateKey, publicKeys, signerIndex);
+}
+function signNonSequential(tx, condition, privateKey) {
+  const fields = [...condition.fields];
+  const preSignHash = nonSequentialPreSignHash(tx);
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const sig = nobleSign(preSignHash, keyBytes, { lowS: true });
+  const recoveryIdHex = intToHex(sig.recovery, 1);
+  const nextSig = recoveryIdHex + sig.toCompactHex();
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  if (sigCount >= condition.signaturesRequired) {
+    return {
+      ...tx,
+      auth: { ...tx.auth, spendingCondition: newCondition }
+    };
+  }
+  return {
+    ...tx,
+    auth: { ...tx.auth, spendingCondition: newCondition }
+  };
+}
+function signSequential(tx, condition, privateKey, publicKeys, signerIndex) {
+  const fields = [...condition.fields];
+  let curSigHash = initialSigHash(tx);
+  for (const field of fields) {
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+  }
+  for (let i = fields.length;i < signerIndex; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  const { nextSig, nextSigHash } = nextSignature(curSigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  curSigHash = nextSigHash;
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  let finalCondition = newCondition;
+  if (sigCount >= condition.signaturesRequired) {
+    finalCondition = finalizeMultiSigCondition(newCondition, publicKeys, curSigHash);
+  }
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+async function signMultiSigWithAccount(tx, account, publicKeys) {
+  const signerPubKey = account.publicKey;
+  const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
+  if (signerIndex === -1) {
+    throw new Error("Account does not correspond to any signer in the multi-sig");
+  }
+  const condition = { ...tx.auth.spendingCondition };
+  if (isNonSequential(condition.hashMode)) {
+    return signNonSequentialWithAccount(tx, condition, account);
+  }
+  return signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex);
+}
+async function signNonSequentialWithAccount(tx, condition, account) {
+  const fields = [...condition.fields];
+  const preSignHash = nonSequentialPreSignHash(tx);
+  const sigBytes = await account.sign(hexToBytes(preSignHash));
+  const nextSig = bytesToHex(sigBytes);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  const newCondition = { ...condition, fields };
+  return {
+    ...tx,
+    auth: { ...tx.auth, spendingCondition: newCondition }
+  };
+}
+async function signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex) {
+  const fields = [...condition.fields];
+  let curSigHash = initialSigHash(tx);
+  for (const field of fields) {
+    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign2, field.pubKeyEncoding, field.data);
+  }
+  for (let i = fields.length;i < signerIndex; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign2, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+  const sigBytes = await account.sign(hexToBytes(preSign));
+  const nextSig = bytesToHex(sigBytes);
+  const nextSigHash = sigHashPostSign(preSign, PubKeyEncoding.Compressed, nextSig);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  curSigHash = nextSigHash;
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  let finalCondition = newCondition;
+  if (sigCount >= condition.signaturesRequired) {
+    finalCondition = finalizeMultiSigCondition(newCondition, publicKeys, curSigHash);
+  }
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+function finalizeMultiSig(tx, publicKeys) {
+  const condition = tx.auth.spendingCondition;
+  if (isNonSequential(condition.hashMode)) {
+    return tx;
+  }
+  const curSigHash = replayMultiSigSigHash(tx);
+  const finalCondition = finalizeMultiSigCondition(condition, publicKeys, curSigHash);
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+function finalizeMultiSigCondition(condition, publicKeys, curSigHash) {
+  const fields = [...condition.fields];
+  let sigHash = curSigHash;
+  for (let i = fields.length;i < publicKeys.length; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
+    sigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  return { ...condition, fields };
+}
+function combineMultiSigSignatures(baseTx, signedTxs) {
+  const condition = baseTx.auth.spendingCondition;
+  if (!isNonSequential(condition.hashMode)) {
+    throw new Error("combineMultiSigSignatures only works with non-sequential hash modes (SIP-027)");
+  }
+  const seenSigs = new Set;
+  const signatures = [];
+  for (const stx of signedTxs) {
+    const stxCondition = stx.auth.spendingCondition;
+    for (const field of stxCondition.fields) {
+      if (field.type === "signature" && !seenSigs.has(field.data)) {
+        seenSigs.add(field.data);
+        signatures.push(field);
+      }
+    }
+  }
+  if (signatures.length === 0) {
+    throw new Error("No signatures found in the provided transactions");
+  }
+  const newCondition = {
+    ...condition,
+    fields: signatures
+  };
+  return {
+    ...baseTx,
+    auth: { ...baseTx.auth, spendingCondition: newCondition }
+  };
+}
+
+export { AuthType, PayloadType, ClarityVersion, AnchorMode, PostConditionModeWire, AddressHashMode, PubKeyEncoding, FungibleConditionCode, NonFungibleConditionCode, PostConditionPrincipalId, AssetType, AuthFieldType, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, MEMO_MAX_LENGTH_BYTES, MAX_STRING_LENGTH_BYTES, serializePayload, serializeTransaction, serializeTransactionHex, createSingleSigSpendingCondition, createStandardAuth, createSponsoredAuth, intoInitialSighashAuth, sigHashPreSign, sigHashPostSign, nextSignature, isNonSequential, makeMultiSigAddress, createMultiSigSpendingCondition, replayMultiSigSigHash, signMultiSig, signMultiSigWithAccount, finalizeMultiSig, combineMultiSigSignatures };
+
+//# debugId=99F694C3EE6B35BA64756E2164756E21
+//# sourceMappingURL=stacks-yfgsm6ap.js.map