@secondlayer/stacks 2.15.0 → 2.15.1

package/dist/src/tools/index.js

@@ -1,10 +1,38 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
 // src/tools/index.ts
 import { tool } from "ai";
 import { z } from "zod";
 
+// src/errors/base.ts
+class BaseError extends Error {
+  name = "StacksError";
+  shortMessage;
+  details;
+  constructor(shortMessage, options) {
+    const message = [
+      shortMessage,
+      options?.details ? `
+${options.details}` : ""
+    ].join("");
+    super(message, { cause: options?.cause });
+    this.shortMessage = shortMessage;
+    this.details = options?.details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      shortMessage: this.shortMessage,
+      details: this.details,
+      cause: this.cause instanceof Error ? this.cause.message : undefined
+    };
+  }
+}
+
+// src/errors/response.ts
+class MalformedResponseError extends BaseError {
+  name = "MalformedResponseError";
+}
+
 // src/utils/c32.ts
 import { sha256 } from "@noble/hashes/sha2.js";
 
@@ -418,6 +446,9 @@ var AssetType = {
 };
 var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
 var MEMO_MAX_LENGTH_BYTES = 34;
+var COINBASE_BYTES_LENGTH = 32;
+var VRF_PROOF_BYTES_LENGTH = 80;
+var MICROBLOCK_HEADER_BYTES_LENGTH = 132;
 
 // src/transactions/wire/serialize.ts
 function serializeAddress2(c32Address) {
@@ -603,6 +634,9 @@ function serializeTransaction(tx) {
 }
 
 // src/actions/public/estimateFee.ts
+function isValidEstimation(e) {
+  return typeof e === "object" && e !== null && "fee_rate" in e && "fee" in e && (typeof e.fee_rate === "number" || typeof e.fee_rate === "string") && (typeof e.fee === "number" || typeof e.fee === "string");
+}
 async function estimateFee(client, params) {
   const payloadHex = bytesToHex(serializePayload(params.transaction.payload));
   const txHex = bytesToHex(serializeTransaction(params.transaction));
@@ -613,10 +647,16 @@ async function estimateFee(client, params) {
       transaction_payload: `0x${payloadHex}`
     }
   });
-  return (data.estimations ?? []).map((e) => ({
-    feeRate: e.fee_rate,
-    fee: e.fee
-  }));
+  const raw = data?.estimations ?? [];
+  return raw.map((e) => {
+    if (!isValidEstimation(e)) {
+      throw new MalformedResponseError("estimateFee: node response contains invalid fee estimation entry");
+    }
+    return {
+      feeRate: Number(e.fee_rate),
+      fee: Number(e.fee)
+    };
+  });
 }
 
 // src/actions/public/getAccountHistory.ts
@@ -625,48 +665,19 @@ async function getAccountHistory(client, params) {
   return client.request(`/extended/v2/addresses/${params.address}/transactions?limit=${limit}`, { method: "GET" });
 }
 
-// src/errors/base.ts
-class BaseError extends Error {
-  name = "StacksError";
-  shortMessage;
-  details;
-  constructor(shortMessage, options) {
-    const message = [
-      shortMessage,
-      options?.details ? `
-${options.details}` : ""
-    ].join("");
-    super(message, { cause: options?.cause });
-    this.shortMessage = shortMessage;
-    this.details = options?.details;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      shortMessage: this.shortMessage,
-      details: this.details,
-      cause: this.cause instanceof Error ? this.cause.message : undefined
-    };
-  }
-}
-
-// src/errors/response.ts
-class MalformedResponseError extends BaseError {
-  name = "MalformedResponseError";
-}
-
 // src/actions/public/getAccountInfo.ts
 async function getAccountInfo(client, params) {
   const data = await client.request(`/v2/accounts/${params.address}?proof=1`, {
     method: "GET"
   });
-  if (data?.balance === undefined || data?.nonce === undefined) {
+  const balance = data?.balance;
+  const nonce = data?.nonce;
+  if (typeof balance !== "string" && typeof balance !== "number" || typeof nonce !== "string" && typeof nonce !== "number") {
     throw new MalformedResponseError(`getAccountInfo: /v2/accounts/${params.address} response is missing "balance" or "nonce"`);
   }
   return {
-    balance: BigInt(data.balance),
-    nonce: BigInt(data.nonce),
+    balance: BigInt(balance),
+    nonce: BigInt(nonce),
     balanceProof: data.balance_proof ?? "",
     nonceProof: data.nonce_proof ?? ""
   };
@@ -677,10 +688,11 @@ async function getBalance(client, params) {
   const data = await client.request(`/v2/accounts/${params.address}`, {
     method: "GET"
   });
-  if (data?.balance === undefined) {
+  const balance = data?.balance;
+  if (typeof balance !== "string" && typeof balance !== "number") {
     throw new MalformedResponseError(`getBalance: /v2/accounts/${params.address} response is missing "balance"`);
   }
-  return BigInt(data.balance);
+  return BigInt(balance);
 }
 
 // src/actions/public/getBlock.ts
@@ -2493,6 +2505,258 @@ async function getPrimaryName(client, address) {
   }
 }
 
+// src/transactions/wire/deserialize.ts
+function readSpendingCondition(r) {
+  const hashMode = r.readUInt8();
+  const signer = bytesToHex(r.readBytes(20));
+  const nonce = r.readBigUInt64BE();
+  const fee = r.readBigUInt64BE();
+  if (hashMode === AddressHashMode.P2PKH || hashMode === AddressHashMode.P2WPKH) {
+    const keyEncoding = r.readUInt8();
+    const signature = bytesToHex(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
+    return {
+      hashMode,
+      signer,
+      nonce,
+      fee,
+      keyEncoding,
+      signature
+    };
+  }
+  const fieldCount = r.readUInt32BE();
+  const fields = [];
+  for (let i = 0;i < fieldCount; i++) {
+    const fieldType = r.readUInt8();
+    if (fieldType <= 1) {
+      const keyLen = fieldType === 0 ? 33 : 65;
+      fields.push({
+        type: "publicKey",
+        pubKeyEncoding: fieldType,
+        data: bytesToHex(r.readBytes(keyLen))
+      });
+    } else {
+      fields.push({
+        type: "signature",
+        pubKeyEncoding: fieldType === 2 ? 0 : 1,
+        data: bytesToHex(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES))
+      });
+    }
+  }
+  const signaturesRequired = r.readUInt16BE();
+  return {
+    hashMode,
+    signer,
+    nonce,
+    fee,
+    fields,
+    signaturesRequired
+  };
+}
+function readAuthorization(r) {
+  const authType = r.readUInt8();
+  const spendingCondition = readSpendingCondition(r);
+  if (authType === AuthType.Standard) {
+    return { authType: AuthType.Standard, spendingCondition };
+  }
+  const sponsorSpendingCondition = readSpendingCondition(r);
+  return {
+    authType: AuthType.Sponsored,
+    spendingCondition,
+    sponsorSpendingCondition
+  };
+}
+function readAssetInfo(r) {
+  return {
+    address: readAddress(r),
+    contractName: readLPString(r),
+    assetName: readLPString(r)
+  };
+}
+function readPostConditionPrincipal(r) {
+  const type = r.readUInt8();
+  switch (type) {
+    case PostConditionPrincipalId.Origin:
+      return { type: "origin" };
+    case PostConditionPrincipalId.Standard:
+      return { type: "standard", address: readAddress(r) };
+    case PostConditionPrincipalId.Contract:
+      return {
+        type: "contract",
+        address: readAddress(r),
+        contractName: readLPString(r)
+      };
+    default:
+      return { type: "origin" };
+  }
+}
+function readPostConditions(r) {
+  const count = r.readUInt32BE();
+  const pcs = [];
+  for (let i = 0;i < count; i++) {
+    const assetType = r.readUInt8();
+    const principal = readPostConditionPrincipal(r);
+    switch (assetType) {
+      case AssetType.STX:
+        pcs.push({
+          type: "stx",
+          principal,
+          conditionCode: r.readUInt8(),
+          amount: r.readBigUInt64BE()
+        });
+        break;
+      case AssetType.Fungible:
+        pcs.push({
+          type: "ft",
+          principal,
+          asset: readAssetInfo(r),
+          conditionCode: r.readUInt8(),
+          amount: r.readBigUInt64BE()
+        });
+        break;
+      case AssetType.NonFungible:
+        pcs.push({
+          type: "nft",
+          principal,
+          asset: readAssetInfo(r),
+          assetId: readCV(r),
+          conditionCode: r.readUInt8()
+        });
+        break;
+      case AssetType.Staking:
+        pcs.push({
+          type: "staking",
+          principal,
+          conditionCode: r.readUInt8(),
+          amount: r.readBigUInt64BE()
+        });
+        break;
+      case AssetType.Pox:
+        pcs.push({
+          type: "pox",
+          principal,
+          conditionCode: r.readUInt8()
+        });
+        break;
+      default:
+        throw new Error(`Unknown post-condition asset type: 0x${assetType.toString(16).padStart(2, "0")} (post-condition ${i + 1}/${count})`);
+    }
+  }
+  return pcs;
+}
+function readPayload(r) {
+  const payloadType = r.readUInt8();
+  switch (payloadType) {
+    case PayloadType.TokenTransfer: {
+      const recipient = readCV(r);
+      const amount = r.readBigUInt64BE();
+      const memoBytes = r.readBytes(MEMO_MAX_LENGTH_BYTES);
+      const memo = bytesToAscii(memoBytes).replace(/\0+$/, "");
+      return {
+        payloadType: PayloadType.TokenTransfer,
+        recipient,
+        amount,
+        memo
+      };
+    }
+    case PayloadType.ContractCall: {
+      const contractAddress = readAddress(r);
+      const contractName = readLPString(r);
+      const functionName = readLPString(r);
+      const numArgs = r.readUInt32BE();
+      const functionArgs = [];
+      for (let i = 0;i < numArgs; i++)
+        functionArgs.push(readCV(r));
+      return {
+        payloadType: PayloadType.ContractCall,
+        contractAddress,
+        contractName,
+        functionName,
+        functionArgs
+      };
+    }
+    case PayloadType.SmartContract: {
+      const contractName = readLPString(r);
+      const codeBody = readLPString(r, 4);
+      return { payloadType: PayloadType.SmartContract, contractName, codeBody };
+    }
+    case PayloadType.VersionedSmartContract: {
+      const clarityVersion = r.readUInt8();
+      const contractName = readLPString(r);
+      const codeBody = readLPString(r, 4);
+      return {
+        payloadType: PayloadType.VersionedSmartContract,
+        clarityVersion,
+        contractName,
+        codeBody
+      };
+    }
+    case PayloadType.Coinbase: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      return { payloadType: PayloadType.Coinbase, coinbaseBuffer };
+    }
+    case PayloadType.CoinbaseToAltRecipient: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      const recipient = readCV(r);
+      return {
+        payloadType: PayloadType.CoinbaseToAltRecipient,
+        coinbaseBuffer,
+        recipient
+      };
+    }
+    case PayloadType.PoisonMicroblock: {
+      const header1 = bytesToHex(r.readBytes(MICROBLOCK_HEADER_BYTES_LENGTH));
+      const header2 = bytesToHex(r.readBytes(MICROBLOCK_HEADER_BYTES_LENGTH));
+      return { payloadType: PayloadType.PoisonMicroblock, header1, header2 };
+    }
+    case PayloadType.TenureChange: {
+      const tenureConsensusHash = bytesToHex(r.readBytes(20));
+      const prevTenureConsensusHash = bytesToHex(r.readBytes(20));
+      const burnViewConsensusHash = bytesToHex(r.readBytes(20));
+      const previousTenureEnd = bytesToHex(r.readBytes(32));
+      const previousTenureBlocks = r.readUInt32BE();
+      const cause = r.readUInt8();
+      const pubkeyHash = bytesToHex(r.readBytes(20));
+      return {
+        payloadType: PayloadType.TenureChange,
+        tenureConsensusHash,
+        prevTenureConsensusHash,
+        burnViewConsensusHash,
+        previousTenureEnd,
+        previousTenureBlocks,
+        cause,
+        pubkeyHash
+      };
+    }
+    case PayloadType.NakamotoCoinbase: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      const optionalCV = readCV(r);
+      const recipient = optionalCV.type === "none" ? null : optionalCV.type === "some" ? optionalCV.value : optionalCV;
+      const vrfProof = bytesToHex(r.readBytes(VRF_PROOF_BYTES_LENGTH));
+      return {
+        payloadType: PayloadType.NakamotoCoinbase,
+        coinbaseBuffer,
+        recipient,
+        vrfProof
+      };
+    }
+    default:
+      throw new Error(`Unknown payload type: ${payloadType}`);
+  }
+}
+function deserializeTransaction(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  const r = new BytesReader(bytes);
+  return {
+    version: r.readUInt8(),
+    chainId: r.readUInt32BE(),
+    auth: readAuthorization(r),
+    anchorMode: r.readUInt8(),
+    postConditionMode: r.readUInt8(),
+    postConditions: readPostConditions(r),
+    payload: readPayload(r)
+  };
+}
+
 // src/chains/definitions.ts
 var mainnet = {
   id: 1,
@@ -2935,11 +3199,24 @@ async function contractRead(client, args) {
   const result = await readContract(client, args);
   return { result: JSON.stringify(result) };
 }
+function assertValidHex(raw) {
+  if (raw.length % 2 !== 0) {
+    throw new Error("serializedTxHex: odd-length hex string");
+  }
+  if (!/^[0-9a-fA-F]+$/.test(raw)) {
+    throw new Error("serializedTxHex: contains non-hex characters");
+  }
+}
 async function fee(client, serializedTxHex) {
   const raw = serializedTxHex.startsWith("0x") ? serializedTxHex.slice(2) : serializedTxHex;
+  assertValidHex(raw);
   const txBytes = new Uint8Array(Buffer.from(raw, "hex"));
-  const { deserializeTransaction } = await import("@stacks/transactions");
-  const transaction = deserializeTransaction(txBytes);
+  let transaction;
+  try {
+    transaction = deserializeTransaction(txBytes);
+  } catch (e) {
+    throw new Error(`serializedTxHex: deserialization failed — ${e instanceof Error ? e.message : String(e)}`);
+  }
   const fees = await estimateFee(client, {
     transaction
   });
@@ -3139,5 +3416,5 @@ export {
   bnsResolve
 };
 
-//# debugId=8FE40CC86F96048464756E2164756E21
+//# debugId=21FD1F399CA68BB164756E2164756E21
 //# sourceMappingURL=index.js.map