@haven_ai/sdk 0.0.0-dev.202609291912.efd0772 → 0.0.0-dev.202609291949.4e52d4b

package/dist/{chunk-6JQT7HNR.js → chunk-S35ZUPXQ.js}

@@ -1,6 +1,8 @@
-import { HavenSigningError, deriveDelegateAccountAddress, DELEGATION_MANAGER, assertRedeemsOwnBudgetDelegation, verifySettlementChild, REDEEM_DELEGATIONS_ABI, ROOT_AUTHORITY, CAVEAT_ENFORCERS, DELEGATION_TUPLE_COMPONENTS } from './chunk-5I6LGPWZ.js';
-import { decodeFunctionData, encodeFunctionData, encodePacked, recoverTypedDataAddress, encodeAbiParameters, keccak256 } from 'viem';
+import { HavenSigningError, deriveDelegateAccountAddress, DELEGATION_MANAGER, assertRedeemsOwnBudgetDelegation, verifySettlementChild, REDEEM_DELEGATIONS_ABI, chainIdForNetwork, ROOT_AUTHORITY, CAVEAT_ENFORCERS, DELEGATION_TUPLE_COMPONENTS } from './chunk-5I6LGPWZ.js';
+import { decodeFunctionData, encodeFunctionData, encodePacked, recoverTypedDataAddress, serializeSignature, hashTypedData, encodeAbiParameters, keccak256 } from 'viem';
 import { createHash } from 'crypto';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { privateKeyToAddress, publicKeyToAddress } from 'viem/accounts';
 
 var TYPED_DATA_NOT_ALLOWED = "TYPED_DATA_NOT_ALLOWED";
 var HavenTypedDataRefusedError = class extends HavenSigningError {
@@ -783,7 +785,7 @@ function stableStringify2(value) {
 }
 
 // src/client-identity.ts
-var SDK_VERSION = "0.0.0-dev.202609291912.efd0772";
+var SDK_VERSION = "0.0.0-dev.202609291949.4e52d4b";
 var HAVEN_CLIENT_HEADER = "X-Haven-Client";
 function havenClientIdentity(pkg, version) {
   return `${pkg}/${version}`;
@@ -805,6 +807,177 @@ function readClientUpdate(value) {
     notes_url: typeof v.notes_url === "string" ? v.notes_url : null
   };
 }
+var HALF_N = BigInt("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0");
+function hexBytes(value, bytes, what) {
+  if (!/^0x[0-9a-fA-F]+$/.test(value) || value.length !== 2 + bytes * 2) {
+    throw new Error(`${what} must be a 0x-prefixed ${bytes}-byte hex string`);
+  }
+  return value.slice(2);
+}
+function addressFromKey(privateKey) {
+  try {
+    return privateKeyToAddress(`0x${hexBytes(privateKey, 32, "private key")}`);
+  } catch (err) {
+    throw new HavenSigningError(
+      `Invalid private key: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function signHash(privateKey, hash) {
+  try {
+    const { r, s, recovery } = secp256k1.sign(hexBytes(hash, 32, "hash"), hexBytes(privateKey, 32, "private key"), { lowS: true });
+    return serializeSignature({
+      r: `0x${r.toString(16).padStart(64, "0")}`,
+      s: `0x${s.toString(16).padStart(64, "0")}`,
+      yParity: recovery
+    });
+  } catch (err) {
+    throw new HavenSigningError(
+      `Failed to sign hash: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function verifySignature(hash, signature, expectedAddress) {
+  try {
+    const sig = hexBytes(signature, 65, "signature");
+    const hashHex = hexBytes(hash, 32, "hash");
+    if (BigInt(`0x${sig.slice(64, 128)}`) > HALF_N) return false;
+    const yParityOrV = Number.parseInt(sig.slice(128), 16);
+    const recoveryBit = yParityOrV === 0 || yParityOrV === 27 ? 0 : yParityOrV === 1 || yParityOrV === 28 ? 1 : -1;
+    if (recoveryBit < 0) return false;
+    const publicKey = secp256k1.Signature.fromCompact(sig.slice(0, 128)).addRecoveryBit(recoveryBit).recoverPublicKey(hashHex).toHex(false);
+    const recovered = publicKeyToAddress(`0x${publicKey}`);
+    return recovered.toLowerCase() === expectedAddress.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+var TAX_DECLARATION_DOMAIN = { name: "x402 Tax Declaration", version: "1" };
+var TAX_DECLARATION_PRIMARY_TYPE = "TaxDeclaration";
+var TAX_DECLARATION_TYPES = {
+  TaxDeclaration: [
+    { name: "version", type: "string" },
+    { name: "jurisdiction", type: "string" },
+    { name: "taxableStatus", type: "string" },
+    { name: "taxId", type: "string" },
+    { name: "validUntil", type: "uint256" },
+    { name: "principalId", type: "string" },
+    { name: "principalAttributionHash", type: "string" }
+  ]
+};
+var X_TAX_DECLARATION_HEADER = "X-Tax-Declaration";
+function validateContent(content) {
+  if (typeof content !== "object" || content === null || Array.isArray(content)) {
+    throw new HavenSigningError("Tax declaration content must be an object.");
+  }
+  const record = content;
+  for (const field of ["principalId", "principalAttributionHash"]) {
+    if (record[field] !== void 0) {
+      throw new TaxDeclarationRefusedError(
+        `Tax declaration content arrives with ${field} already set; that field is computed locally from the delegate key and the accepted payment option, never accepted from Haven.`
+      );
+    }
+  }
+  const allowed = /* @__PURE__ */ new Set(["version", "jurisdiction", "taxableStatus", "taxId", "validUntil"]);
+  for (const key of Object.keys(record)) {
+    if (!allowed.has(key)) {
+      throw new TaxDeclarationRefusedError(
+        `Tax declaration content carries an unknown field '${key}'; the signed shape is built locally from the \xA72.1 fields only.`
+      );
+    }
+  }
+  const strings = ["version", "jurisdiction", "taxableStatus", "taxId"];
+  for (const key of strings) {
+    if (typeof record[key] !== "string" || record[key].length === 0) {
+      throw new TaxDeclarationRefusedError(
+        `Tax declaration content field '${key}' must be a non-empty string.`
+      );
+    }
+  }
+  if (typeof record.validUntil !== "number" || !Number.isInteger(record.validUntil) || record.validUntil <= 0) {
+    throw new TaxDeclarationRefusedError(
+      "Tax declaration content field 'validUntil' must be a positive integer (milliseconds)."
+    );
+  }
+  return {
+    version: record.version,
+    jurisdiction: record.jurisdiction,
+    taxableStatus: record.taxableStatus,
+    taxId: record.taxId,
+    validUntil: record.validUntil
+  };
+}
+function jcsCanonicalBytes(value) {
+  const keys = Object.keys(value).sort();
+  const members = keys.map((key) => `${JSON.stringify(key)}:${JSON.stringify(value[key])}`);
+  return `{${members.join(",")}}`;
+}
+function principalAttributionHash(principalId) {
+  const canonical = jcsCanonicalBytes({ principalId });
+  const hex2 = createHash("sha256").update(canonical, "utf8").digest("hex");
+  return `sha-256:${hex2}`;
+}
+function taxPrincipalId(network, delegateAddress) {
+  if (network.startsWith("eip155:")) {
+    return `did:pkh:${network}:${delegateAddress}`;
+  }
+  const chainId = chainIdForNetwork(network);
+  if (chainId === void 0) {
+    throw new TaxDeclarationRefusedError(
+      `The accepted payment option's network '${network}' is not a CAIP-2 eip155 chain this SDK can name; refusing to build a tax principal without the settlement network.`
+    );
+  }
+  return `did:pkh:eip155:${chainId}:${delegateAddress}`;
+}
+function buildSignedTaxDeclaration(input) {
+  const content = validateContent(input.content);
+  const principalId = taxPrincipalId(input.network, addressFromKeyForTax(input.delegateKey));
+  const attributionHash = principalAttributionHash(principalId);
+  const declaration = { ...content, principalId, principalAttributionHash: attributionHash };
+  const message = { ...declaration, validUntil: BigInt(declaration.validUntil) };
+  const digest = hashTypedData({
+    domain: TAX_DECLARATION_DOMAIN,
+    types: TAX_DECLARATION_TYPES,
+    primaryType: TAX_DECLARATION_PRIMARY_TYPE,
+    message
+  });
+  const signature = signHash(input.delegateKey, digest);
+  return { declaration, signature };
+}
+function verifyTaxDeclarationSignature(declaration, signature, expectedAddress) {
+  const message = { ...declaration, validUntil: BigInt(declaration.validUntil) };
+  const digest = hashTypedData({
+    domain: TAX_DECLARATION_DOMAIN,
+    types: TAX_DECLARATION_TYPES,
+    primaryType: TAX_DECLARATION_PRIMARY_TYPE,
+    message
+  });
+  return verifySignature(digest, signature, expectedAddress);
+}
+function encodeTaxDeclarationHeader(result) {
+  const json = JSON.stringify({ ...result.declaration, signature: result.signature });
+  return base64Url(json);
+}
+function base64Url(value) {
+  const standard = typeof Buffer !== "undefined" ? Buffer.from(value, "utf8").toString("base64") : btoa(String.fromCharCode(...new TextEncoder().encode(value)));
+  return standard.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function addressFromKeyForTax(delegateKey) {
+  try {
+    return addressFromKey(delegateKey);
+  } catch (err) {
+    throw new HavenSigningError(
+      `Invalid delegate key for tax declaration signing: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+var TaxDeclarationRefusedError = class extends HavenSigningError {
+  code = "TAX_DECLARATION_REFUSED";
+  constructor(message) {
+    super(message);
+    this.name = "TaxDeclarationRefusedError";
+  }
+};
 
 // src/next-step.ts
 var NEXT_TOOL_SERVER_NAMES = {
@@ -1212,6 +1385,6 @@ function hashDelegation(delegation) {
   return keccak256(encoded);
 }
 
-export { CAVEAT_TYPEHASH, DEFAULT_NEXT_TOOL_BY_ACTION, DELEGATION_TYPEHASH, DIRECT_PAYMENT_CHAIN_IDS, ERC7710_ASSET_TRANSFER_METHOD, EXECUTE_ABI, HAVEN_CLIENT_HEADER, HAVEN_MINIMUM_NODE_VERSION, HavenTypedDataRefusedError, MAX_TASK_BUDGET_TTL_SECONDS, NEXT_TOOL_SERVER_NAMES, NEXT_TOOL_SERVER_ROLES, SDK_CLIENT_IDENTITY, SDK_VERSION, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_SEPOLIA_CHAIN_ID, SWEEP_BASE_SEPOLIA_USDC_ADDRESS, SWEEP_BASE_USDC_ADDRESS, TRANSFER_WITH_AUTHORIZATION_TYPES, TYPED_DATA_NOT_ALLOWED, X402PaymentHeaderValidationError, X402_LEGACY_PAYMENT_HEADER_NAME, X402_MAX_AUTHORIZATION_WINDOW_SECONDS, X402_PAYMENT_HEADER_NAME, X402_PAYMENT_HEADER_NAMES, X402_PAYMENT_HEADER_NAMES_SENT, X402_PAYMENT_REQUIRED_HEADER_NAME, X402_PAYMENT_RESPONSE_HEADER_NAME, X402_SETTLEMENT_FORWARD_MARGIN_SECONDS, assertBoundDirectPaymentUserOp, assertFundingLegPaysDelegate, assertOwnSettlementChild, assertOwnTaskBudgetCloseUserOp, assertOwnTaskChild, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, buildX402IdempotencyKey, compareNodeVersions, createNextStepBuilder, decodeBase64Json, decodeBase64Utf8, defaultNextToolFor, encodeBase64Json, encodeBase64Utf8, encodePaymentProof, hashDelegation, havenClientIdentity, isErc7710Option, isSupportedNodeVersion, isSweepableChain, isTaskChildTypedData, normalizePaymentRequired, parseNextTool, parsePaymentRequired, parsePaymentRequiredResponse, readClientUpdate, renderNextTool, resolveTokenBySymbol, resolveTokenFromAddress, selectErc7710PaymentOption, selectPaymentOption, selectStandardPaymentOption, selectX402SettlementScheme, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, unsupportedNodeVersionMessage, validateStandardX402PaymentHeader, x402AssetTransferMethod, x402AuthorizationAmount, x402FacilitatorAddresses, x402PaymentHeaderNamesFor, x402PaymentHeaderNamesSent, x402V2PaymentEnvelope };
-//# sourceMappingURL=chunk-6JQT7HNR.js.map
-//# sourceMappingURL=chunk-6JQT7HNR.js.map
+export { CAVEAT_TYPEHASH, DEFAULT_NEXT_TOOL_BY_ACTION, DELEGATION_TYPEHASH, DIRECT_PAYMENT_CHAIN_IDS, ERC7710_ASSET_TRANSFER_METHOD, EXECUTE_ABI, HAVEN_CLIENT_HEADER, HAVEN_MINIMUM_NODE_VERSION, HavenTypedDataRefusedError, MAX_TASK_BUDGET_TTL_SECONDS, NEXT_TOOL_SERVER_NAMES, NEXT_TOOL_SERVER_ROLES, SDK_CLIENT_IDENTITY, SDK_VERSION, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_SEPOLIA_CHAIN_ID, SWEEP_BASE_SEPOLIA_USDC_ADDRESS, SWEEP_BASE_USDC_ADDRESS, TAX_DECLARATION_DOMAIN, TAX_DECLARATION_PRIMARY_TYPE, TAX_DECLARATION_TYPES, TRANSFER_WITH_AUTHORIZATION_TYPES, TYPED_DATA_NOT_ALLOWED, TaxDeclarationRefusedError, X402PaymentHeaderValidationError, X402_LEGACY_PAYMENT_HEADER_NAME, X402_MAX_AUTHORIZATION_WINDOW_SECONDS, X402_PAYMENT_HEADER_NAME, X402_PAYMENT_HEADER_NAMES, X402_PAYMENT_HEADER_NAMES_SENT, X402_PAYMENT_REQUIRED_HEADER_NAME, X402_PAYMENT_RESPONSE_HEADER_NAME, X402_SETTLEMENT_FORWARD_MARGIN_SECONDS, X_TAX_DECLARATION_HEADER, addressFromKey, assertBoundDirectPaymentUserOp, assertFundingLegPaysDelegate, assertOwnSettlementChild, assertOwnTaskBudgetCloseUserOp, assertOwnTaskChild, buildSignedTaxDeclaration, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, buildX402IdempotencyKey, compareNodeVersions, createNextStepBuilder, decodeBase64Json, decodeBase64Utf8, defaultNextToolFor, encodeBase64Json, encodeBase64Utf8, encodePaymentProof, encodeTaxDeclarationHeader, hashDelegation, havenClientIdentity, isErc7710Option, isSupportedNodeVersion, isSweepableChain, isTaskChildTypedData, normalizePaymentRequired, parseNextTool, parsePaymentRequired, parsePaymentRequiredResponse, principalAttributionHash, readClientUpdate, renderNextTool, resolveTokenBySymbol, resolveTokenFromAddress, selectErc7710PaymentOption, selectPaymentOption, selectStandardPaymentOption, selectX402SettlementScheme, signHash, sweepUsdcAddress, sweepUsdcDomain, taxPrincipalId, toStandardPaymentRequirements, unsupportedNodeVersionMessage, validateStandardX402PaymentHeader, verifySignature, verifyTaxDeclarationSignature, x402AssetTransferMethod, x402AuthorizationAmount, x402FacilitatorAddresses, x402PaymentHeaderNamesFor, x402PaymentHeaderNamesSent, x402V2PaymentEnvelope };
+//# sourceMappingURL=chunk-S35ZUPXQ.js.map
+//# sourceMappingURL=chunk-S35ZUPXQ.js.map