@secondlayer/stacks 6.0.0 → 6.1.1

package/dist/shared/stacks-rryme9bv.cjs

@@ -1,569 +0,0 @@
-// src/transactions/authorization.ts
-var import_hmac = require("@noble/hashes/hmac.js");
-var import_sha2 = require("@noble/hashes/sha2.js");
-var import_secp256k1 = require("@noble/secp256k1");
-import_secp256k1.etc.hmacSha256Sync = (key, ...msgs) => {
-  const h = import_hmac.hmac.create(import_sha2.sha256, key);
-  for (const msg of msgs)
-    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 sponsorSigningSentinel() {
-  return {
-    hashMode: AddressHashMode.P2PKH,
-    signer: "00".repeat(20),
-    nonce: 0n,
-    fee: 0n,
-    keyEncoding: PubKeyEncoding.Compressed,
-    signature: EMPTY_SIG
-  };
-}
-function intoInitialSighashAuth(auth) {
-  if (auth.authType === AuthType.Standard) {
-    return createStandardAuth(clearCondition(auth.spendingCondition));
-  }
-  return createSponsoredAuth(clearCondition(auth.spendingCondition), sponsorSigningSentinel());
-}
-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 = import_secp256k1.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 = import_secp256k1.getPublicKey(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/multisig.ts
-var import_secp256k12 = require("@noble/secp256k1");
-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(import_secp256k12.getPublicKey(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 = import_secp256k12.sign(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 }
-  };
-}
-
-// src/transactions/build.ts
-function resolvePcMode(mode) {
-  if (mode === "allow")
-    return PostConditionModeWire.Allow;
-  if (mode === "originator")
-    return PostConditionModeWire.Originator;
-  return PostConditionModeWire.Deny;
-}
-function convertPostConditions(pcs) {
-  if (!pcs || pcs.length === 0)
-    return [];
-  return pcs.map((pc) => convertPostCondition(typeof pc === "string" ? fromHex(pc) : pc));
-}
-function resolveSpendingCondition(opts, nonce, fee) {
-  if (opts.publicKeys) {
-    return createMultiSigSpendingCondition(opts.publicKeys, opts.signaturesRequired, nonce, fee, opts.hashMode);
-  }
-  return createSingleSigSpendingCondition(opts.publicKey, nonce, fee);
-}
-function resolveAuth(spendingCondition, sponsored) {
-  return sponsored ? createSponsoredAuth(spendingCondition) : createStandardAuth(spendingCondition);
-}
-function resolveVersionAndChainId(chain) {
-  if (!chain)
-    return { version: 0, chainId: 1 };
-  return { version: chain.transactionVersion, chainId: chain.id };
-}
-function buildTokenTransfer(options) {
-  const { version, chainId } = resolveVersionAndChainId(options.chain);
-  const fee = intToBigInt(options.fee);
-  const nonce = intToBigInt(options.nonce);
-  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
-  const recipient = Cl.principal(options.recipient);
-  const tx = {
-    version,
-    chainId,
-    auth: resolveAuth(spendingCondition, options.sponsored),
-    anchorMode: AnchorMode.Any,
-    postConditionMode: resolvePcMode(options.postConditionMode),
-    postConditions: convertPostConditions(options.postConditions),
-    payload: {
-      payloadType: PayloadType.TokenTransfer,
-      recipient,
-      amount: intToBigInt(options.amount),
-      memo: options.memo ?? ""
-    }
-  };
-  if (options.publicKeys) {
-    tx._multisig = { publicKeys: options.publicKeys };
-  }
-  return tx;
-}
-function buildContractCall(options) {
-  const { version, chainId } = resolveVersionAndChainId(options.chain);
-  const fee = intToBigInt(options.fee);
-  const nonce = intToBigInt(options.nonce);
-  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
-  const tx = {
-    version,
-    chainId,
-    auth: resolveAuth(spendingCondition, options.sponsored),
-    anchorMode: AnchorMode.Any,
-    postConditionMode: resolvePcMode(options.postConditionMode),
-    postConditions: convertPostConditions(options.postConditions),
-    payload: {
-      payloadType: PayloadType.ContractCall,
-      contractAddress: options.contractAddress,
-      contractName: options.contractName,
-      functionName: options.functionName,
-      functionArgs: options.functionArgs
-    }
-  };
-  if (options.publicKeys) {
-    tx._multisig = { publicKeys: options.publicKeys };
-  }
-  return tx;
-}
-function buildContractDeploy(options) {
-  const { version, chainId } = resolveVersionAndChainId(options.chain);
-  const fee = intToBigInt(options.fee);
-  const nonce = intToBigInt(options.nonce);
-  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
-  const clarityVersion = options.clarityVersion ?? ClarityVersion.Clarity4;
-  const tx = {
-    version,
-    chainId,
-    auth: resolveAuth(spendingCondition, options.sponsored),
-    anchorMode: AnchorMode.Any,
-    postConditionMode: resolvePcMode(options.postConditionMode),
-    postConditions: convertPostConditions(options.postConditions),
-    payload: {
-      payloadType: PayloadType.VersionedSmartContract,
-      clarityVersion,
-      contractName: options.contractName,
-      codeBody: options.codeBody
-    }
-  };
-  if (options.publicKeys) {
-    tx._multisig = { publicKeys: options.publicKeys };
-  }
-  return tx;
-}
-
-// src/transactions/signer.ts
-function txid(tx) {
-  return txidFromBytes(serializeTransaction(tx));
-}
-function signBegin(tx) {
-  const cleared = {
-    ...tx,
-    auth: intoInitialSighashAuth(tx.auth)
-  };
-  return txid(cleared);
-}
-function signTransaction(tx, privateKey) {
-  const sigHash = signBegin(tx);
-  const condition = tx.auth.spendingCondition;
-  const { nextSig } = nextSignature(sigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
-  return {
-    ...tx,
-    auth: {
-      ...tx.auth,
-      spendingCondition: {
-        ...condition,
-        signature: nextSig
-      }
-    }
-  };
-}
-async function signTransactionWithAccount(tx, account) {
-  const sigHash = signBegin(tx);
-  const condition = tx.auth.spendingCondition;
-  const sigHashPre = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
-  const sigBytes = await account.sign(hexToBytes(sigHashPre));
-  const nextSig = bytesToHex(sigBytes);
-  return {
-    ...tx,
-    auth: {
-      ...tx.auth,
-      spendingCondition: {
-        ...condition,
-        signature: nextSig
-      }
-    }
-  };
-}
-function getTransactionId(tx) {
-  return txid(tx);
-}
-function getOriginSigHash(tx) {
-  const condition = tx.auth.spendingCondition;
-  if ("fields" in condition) {
-    return replayMultiSigSigHash(tx);
-  }
-  const initialSigHash2 = signBegin(tx);
-  const sc = condition;
-  const preSign = sigHashPreSign(initialSigHash2, AuthType.Standard, sc.fee, sc.nonce);
-  return sigHashPostSign(preSign, sc.keyEncoding, sc.signature);
-}
-function signSponsor(tx, privateKey) {
-  if (tx.auth.authType !== AuthType.Sponsored) {
-    throw new Error("Transaction must be sponsored");
-  }
-  const auth = tx.auth;
-  const sponsorCondition = auth.sponsorSpendingCondition;
-  const originSigHash = getOriginSigHash(tx);
-  const { nextSig } = nextSignature(originSigHash, AuthType.Sponsored, sponsorCondition.fee, sponsorCondition.nonce, privateKey);
-  return {
-    ...tx,
-    auth: {
-      ...auth,
-      sponsorSpendingCondition: {
-        ...sponsorCondition,
-        signature: nextSig
-      }
-    }
-  };
-}
-async function signSponsorWithAccount(tx, account) {
-  if (tx.auth.authType !== AuthType.Sponsored) {
-    throw new Error("Transaction must be sponsored");
-  }
-  const auth = tx.auth;
-  const sponsorCondition = auth.sponsorSpendingCondition;
-  const originSigHash = getOriginSigHash(tx);
-  const sigHashPre = sigHashPreSign(originSigHash, AuthType.Sponsored, sponsorCondition.fee, sponsorCondition.nonce);
-  const sigBytes = await account.sign(hexToBytes(sigHashPre));
-  const nextSig = bytesToHex(sigBytes);
-  return {
-    ...tx,
-    auth: {
-      ...auth,
-      sponsorSpendingCondition: {
-        ...sponsorCondition,
-        signature: nextSig
-      }
-    }
-  };
-}
-
-//# debugId=4803818E842AF84364756E2164756E21
-//# sourceMappingURL=stacks-rryme9bv.cjs.map