@secondlayer/stacks 0.2.0 → 0.2.1

package/dist/shared/{stacks-hfem9dck.cjs → stacks-vbke9mqw.cjs}

@@ -1,11 +1,3 @@
-// src/transactions/multisig.ts
-var import_secp256k12 = require("@noble/secp256k1");
-
-// src/transactions/authorization.ts
-var import_secp256k1 = require("@noble/secp256k1");
-var import_hmac = require("@noble/hashes/hmac.js");
-var import_sha2 = require("@noble/hashes/sha2.js");
-
 // src/transactions/types.ts
 var AuthType = {
   Standard: 4,
@@ -86,83 +78,6 @@ var TenureChangeCause = {
   Extended: 1
 };
 
-// src/transactions/authorization.ts
-import_secp256k1.etc.hmacSha256Sync = (key, ...msgs) => {
-  const h = import_hmac.hmac.create(import_sha2.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 = 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/wire/serialize.ts
 function serializeAddress(c32Address) {
   const [version, hash1602] = c32addressDecode(c32Address);
@@ -336,7 +251,88 @@ function serializeTransactionHex(tx) {
   return bytesToHex(serializeTransaction(tx));
 }
 
+// src/transactions/authorization.ts
+var import_secp256k1 = require("@noble/secp256k1");
+var import_hmac = require("@noble/hashes/hmac.js");
+var import_sha2 = require("@noble/hashes/sha2.js");
+import_secp256k1.etc.hmacSha256Sync = (key, ...msgs) => {
+  const h = import_hmac.hmac.create(import_sha2.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 = 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;
@@ -607,5 +603,250 @@ function combineMultiSigSignatures(baseTx, signedTxs) {
   };
 }
 
-//# debugId=5A8F9D28AE3FE53E64756E2164756E21
-//# sourceMappingURL=stacks-hfem9dck.cjs.map
+// 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
+      }
+    }
+  };
+}
+
+// src/transactions/build.ts
+function resolvePcMode(mode) {
+  return mode === "allow" ? PostConditionModeWire.Allow : PostConditionModeWire.Deny;
+}
+function convertPostConditions(pcs) {
+  if (!pcs || pcs.length === 0)
+    return [];
+  return pcs.map(convertPostCondition);
+}
+function resolvePrincipal(address) {
+  if (address === "origin")
+    return { type: "origin" };
+  const [addr, name] = address.split(".");
+  if (name) {
+    return { type: "contract", address: addr, contractName: name };
+  }
+  return { type: "standard", address: addr };
+}
+var FUNGIBLE_CODE_MAP = {
+  eq: FungibleConditionCode.Equal,
+  gt: FungibleConditionCode.Greater,
+  gte: FungibleConditionCode.GreaterEqual,
+  lt: FungibleConditionCode.Less,
+  lte: FungibleConditionCode.LessEqual
+};
+function convertPostCondition(pc) {
+  switch (pc.type) {
+    case "stx-postcondition":
+      return {
+        type: "stx",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: intToBigInt(pc.amount)
+      };
+    case "ft-postcondition": {
+      const [contractId, tokenName] = pc.asset.split("::");
+      const [addr, name] = parseContractId(contractId);
+      return {
+        type: "ft",
+        principal: resolvePrincipal(pc.address),
+        asset: { address: addr, contractName: name, assetName: tokenName },
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: intToBigInt(pc.amount)
+      };
+    }
+    case "nft-postcondition": {
+      const [contractId, tokenName] = pc.asset.split("::");
+      const [addr, name] = parseContractId(contractId);
+      return {
+        type: "nft",
+        principal: resolvePrincipal(pc.address),
+        asset: { address: addr, contractName: name, assetName: tokenName },
+        conditionCode: pc.condition === "sent" ? NonFungibleConditionCode.Sends : NonFungibleConditionCode.DoesNotSend,
+        assetId: pc.assetId
+      };
+    }
+  }
+}
+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 useVersioned = options.clarityVersion !== undefined;
+  const tx = {
+    version,
+    chainId,
+    auth: resolveAuth(spendingCondition, options.sponsored),
+    anchorMode: AnchorMode.Any,
+    postConditionMode: resolvePcMode(options.postConditionMode),
+    postConditions: convertPostConditions(options.postConditions),
+    payload: {
+      payloadType: useVersioned ? PayloadType.VersionedSmartContract : PayloadType.SmartContract,
+      clarityVersion: options.clarityVersion,
+      contractName: options.contractName,
+      codeBody: options.codeBody
+    }
+  };
+  if (options.publicKeys) {
+    tx._multisig = { publicKeys: options.publicKeys };
+  }
+  return tx;
+}
+
+//# debugId=F9AB0B29B396E33564756E2164756E21
+//# sourceMappingURL=stacks-vbke9mqw.cjs.map