@haven_ai/sdk 0.4.0-alpha.0 → 0.6.0-alpha.0

package/dist/edge.cjs

@@ -0,0 +1,299 @@
+'use strict';
+
+var chunkCK4NLLMO_cjs = require('./chunk-CK4NLLMO.cjs');
+var chunkS42QSWJY_cjs = require('./chunk-S42QSWJY.cjs');
+var secp256k1 = require('@noble/curves/secp256k1');
+var accounts = require('viem/accounts');
+var viem = require('viem');
+
+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 accounts.privateKeyToAddress(`0x${hexBytes(privateKey, 32, "private key")}`);
+  } catch (err) {
+    throw new chunkS42QSWJY_cjs.HavenSigningError(
+      `Invalid private key: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function signHash(privateKey, hash) {
+  try {
+    const { r, s, recovery } = secp256k1.secp256k1.sign(hexBytes(hash, 32, "hash"), hexBytes(privateKey, 32, "private key"), { lowS: true });
+    return viem.serializeSignature({
+      r: `0x${r.toString(16).padStart(64, "0")}`,
+      s: `0x${s.toString(16).padStart(64, "0")}`,
+      yParity: recovery
+    });
+  } catch (err) {
+    throw new chunkS42QSWJY_cjs.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.secp256k1.Signature.fromCompact(sig.slice(0, 128)).addRecoveryBit(recoveryBit).recoverPublicKey(hashHex).toHex(false);
+    const recovered = accounts.publicKeyToAddress(`0x${publicKey}`);
+    return recovered.toLowerCase() === expectedAddress.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+
+Object.defineProperty(exports, "CAVEAT_TYPEHASH", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.CAVEAT_TYPEHASH; }
+});
+Object.defineProperty(exports, "DELEGATION_TYPEHASH", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.DELEGATION_TYPEHASH; }
+});
+Object.defineProperty(exports, "DIRECT_PAYMENT_CHAIN_IDS", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.DIRECT_PAYMENT_CHAIN_IDS; }
+});
+Object.defineProperty(exports, "EXECUTE_ABI", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.EXECUTE_ABI; }
+});
+Object.defineProperty(exports, "HAVEN_CLIENT_HEADER", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.HAVEN_CLIENT_HEADER; }
+});
+Object.defineProperty(exports, "HAVEN_MINIMUM_NODE_VERSION", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.HAVEN_MINIMUM_NODE_VERSION; }
+});
+Object.defineProperty(exports, "HavenTypedDataRefusedError", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.HavenTypedDataRefusedError; }
+});
+Object.defineProperty(exports, "MAX_TASK_BUDGET_TTL_SECONDS", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.MAX_TASK_BUDGET_TTL_SECONDS; }
+});
+Object.defineProperty(exports, "TYPED_DATA_NOT_ALLOWED", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.TYPED_DATA_NOT_ALLOWED; }
+});
+Object.defineProperty(exports, "assertBoundDirectPaymentUserOp", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.assertBoundDirectPaymentUserOp; }
+});
+Object.defineProperty(exports, "assertFundingLegPaysDelegate", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.assertFundingLegPaysDelegate; }
+});
+Object.defineProperty(exports, "assertOwnSettlementChild", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.assertOwnSettlementChild; }
+});
+Object.defineProperty(exports, "assertOwnTaskBudgetCloseUserOp", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.assertOwnTaskBudgetCloseUserOp; }
+});
+Object.defineProperty(exports, "assertOwnTaskChild", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.assertOwnTaskChild; }
+});
+Object.defineProperty(exports, "buildSweepAuthorizationMessage", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.buildSweepAuthorizationMessage; }
+});
+Object.defineProperty(exports, "buildSweepTypedData", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.buildSweepTypedData; }
+});
+Object.defineProperty(exports, "buildX402ExpectedMessage", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.buildX402ExpectedMessage; }
+});
+Object.defineProperty(exports, "createNextStepBuilder", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.createNextStepBuilder; }
+});
+Object.defineProperty(exports, "decodeBase64Json", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.decodeBase64Json; }
+});
+Object.defineProperty(exports, "encodeBase64Json", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.encodeBase64Json; }
+});
+Object.defineProperty(exports, "hashDelegation", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.hashDelegation; }
+});
+Object.defineProperty(exports, "havenClientIdentity", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.havenClientIdentity; }
+});
+Object.defineProperty(exports, "isSupportedNodeVersion", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.isSupportedNodeVersion; }
+});
+Object.defineProperty(exports, "isTaskChildTypedData", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.isTaskChildTypedData; }
+});
+Object.defineProperty(exports, "readClientUpdate", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.readClientUpdate; }
+});
+Object.defineProperty(exports, "selectStandardPaymentOption", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.selectStandardPaymentOption; }
+});
+Object.defineProperty(exports, "toStandardPaymentRequirements", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.toStandardPaymentRequirements; }
+});
+Object.defineProperty(exports, "unsupportedNodeVersionMessage", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.unsupportedNodeVersionMessage; }
+});
+Object.defineProperty(exports, "x402AuthorizationAmount", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.x402AuthorizationAmount; }
+});
+Object.defineProperty(exports, "x402V2PaymentEnvelope", {
+  enumerable: true,
+  get: function () { return chunkCK4NLLMO_cjs.x402V2PaymentEnvelope; }
+});
+Object.defineProperty(exports, "AgentPaymentFailureCode", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.AgentPaymentFailureCode; }
+});
+Object.defineProperty(exports, "AgentPaymentNextAction", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.AgentPaymentNextAction; }
+});
+Object.defineProperty(exports, "CAVEAT_ENFORCERS", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.CAVEAT_ENFORCERS; }
+});
+Object.defineProperty(exports, "DELEGATION_MANAGER", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.DELEGATION_MANAGER; }
+});
+Object.defineProperty(exports, "DELEGATION_TUPLE_COMPONENTS", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.DELEGATION_TUPLE_COMPONENTS; }
+});
+Object.defineProperty(exports, "DIRECT_SIGN_CONTEXT_VERSION", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.DIRECT_SIGN_CONTEXT_VERSION; }
+});
+Object.defineProperty(exports, "ENTRY_POINT_V07", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.ENTRY_POINT_V07; }
+});
+Object.defineProperty(exports, "HAVEN_CONNECTOR_CHANNEL", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.HAVEN_CONNECTOR_CHANNEL; }
+});
+Object.defineProperty(exports, "HYBRID_DELEGATOR_IMPLEMENTATION", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.HYBRID_DELEGATOR_IMPLEMENTATION; }
+});
+Object.defineProperty(exports, "HavenApiError", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.HavenApiError; }
+});
+Object.defineProperty(exports, "HavenError", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.HavenError; }
+});
+Object.defineProperty(exports, "HavenSigningError", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.HavenSigningError; }
+});
+Object.defineProperty(exports, "HavenUnsupportedSignerVersionError", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.HavenUnsupportedSignerVersionError; }
+});
+Object.defineProperty(exports, "HavenUserOpBindingError", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.HavenUserOpBindingError; }
+});
+Object.defineProperty(exports, "MAX_SETTLEMENT_WINDOW_SECONDS", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.MAX_SETTLEMENT_WINDOW_SECONDS; }
+});
+Object.defineProperty(exports, "REDEEM_DELEGATIONS_ABI", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.REDEEM_DELEGATIONS_ABI; }
+});
+Object.defineProperty(exports, "ROOT_AUTHORITY", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.ROOT_AUTHORITY; }
+});
+Object.defineProperty(exports, "SIGNER_UPDATE_FALLBACK", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.SIGNER_UPDATE_FALLBACK; }
+});
+Object.defineProperty(exports, "SIMPLE_FACTORY_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.SIMPLE_FACTORY_ADDRESS; }
+});
+Object.defineProperty(exports, "SINGLE_DEFAULT_MODE", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.SINGLE_DEFAULT_MODE; }
+});
+Object.defineProperty(exports, "SignerRefusalCode", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.SignerRefusalCode; }
+});
+Object.defineProperty(exports, "assertRedeemsOwnBudgetDelegation", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.assertRedeemsOwnBudgetDelegation; }
+});
+Object.defineProperty(exports, "assertUserOpTypedDataBinding", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.assertUserOpTypedDataBinding; }
+});
+Object.defineProperty(exports, "chainIdForNetwork", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.chainIdForNetwork; }
+});
+Object.defineProperty(exports, "connectorRerunCommand", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.connectorRerunCommand; }
+});
+Object.defineProperty(exports, "deriveDelegateAccountAddress", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.deriveDelegateAccountAddress; }
+});
+Object.defineProperty(exports, "isPackedUserOperationTypedData", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.isPackedUserOperationTypedData; }
+});
+Object.defineProperty(exports, "isSettlementChildTypedData", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.isSettlementChildTypedData; }
+});
+Object.defineProperty(exports, "packedUserOperationHash", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.packedUserOperationHash; }
+});
+Object.defineProperty(exports, "verifySettlementChild", {
+  enumerable: true,
+  get: function () { return chunkS42QSWJY_cjs.verifySettlementChild; }
+});
+exports.addressFromKey = addressFromKey;
+exports.signHash = signHash;
+exports.verifySignature = verifySignature;
+//# sourceMappingURL=edge.cjs.map
+//# sourceMappingURL=edge.cjs.map

package/dist/edge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/edge-signing.ts"],"names":["privateKeyToAddress","HavenSigningError","secp256k1","serializeSignature","publicKeyToAddress"],"mappings":"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","file":"edge.cjs","sourcesContent":["import { secp256k1 } from '@noble/curves/secp256k1'\nimport { privateKeyToAddress, publicKeyToAddress } from 'viem/accounts'\nimport { serializeSignature, type Hex } from 'viem'\nimport { HavenSigningError } from './types.js'\n\n/**\n * #3173: the three key helpers the edge signer needs, without ethers.\n *\n * `./signer.ts` implements the same three on ethers, and the SDK barrel pulls\n * ethers in for them (and for `provider.ts` / `receipt.ts`). The edge signer\n * already ships viem, and viem signs with `@noble/curves` underneath — these\n * use the same curve library directly, synchronously (viem's own `sign` is\n * async), so `@haven_ai/sdk/edge` stays ethers-free and a signer session stops\n * paying for module init it never uses. Byte-equivalence with the ethers forms\n * is pinned in `edge-signing.test.ts`: same address, same 65-byte `r‖s‖v`\n * serialisation with low-s and v = 27/28, same recovery verdicts, and the same\n * refusals (high-s twin, wrong lengths) — with three stated strict-direction\n * exceptions, see `hexBytes`. Raw ECDSA over the hash — never the EIP-191\n * prefixed digest.\n */\n\n/** secp256k1 order / 2 — a signature with s above this is the malleable twin ethers rejects. */\nconst HALF_N = BigInt('0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0')\n\n/**\n * Stricter than ethers, never looser: the lowercase `0x` prefix and the exact\n * byte length are required. Ethers accepts an uppercase `0X` prefix on a\n * signature and the 64-byte EIP-2098 compact form, and is inconsistent on a\n * private key (`Wallet` accepts unprefixed and refuses `0X`; `SigningKey` does\n * the reverse); every such form is refused here — the divergences are pinned\n * in `edge-signing.test.ts` with ethers control assertions, and every\n * well-formed input is byte-equivalent.\n */\nfunction hexBytes(value: string, bytes: number, what: string): string {\n  if (!/^0x[0-9a-fA-F]+$/.test(value) || value.length !== 2 + bytes * 2) {\n    throw new Error(`${what} must be a 0x-prefixed ${bytes}-byte hex string`)\n  }\n  return value.slice(2)\n}\n\nexport function addressFromKey(privateKey: string): string {\n  try {\n    // Same gate as signHash: a key that derives an address must also sign.\n    return privateKeyToAddress(`0x${hexBytes(privateKey, 32, 'private key')}`)\n  } catch (err) {\n    throw new HavenSigningError(\n      `Invalid private key: ${err instanceof Error ? err.message : String(err)}`,\n    )\n  }\n}\n\nexport function signHash(privateKey: string, hash: string): string {\n  try {\n    const { r, s, recovery } = secp256k1.sign(hexBytes(hash, 32, 'hash'), hexBytes(privateKey, 32, 'private key'), { lowS: true })\n    // viem serialises the trailing byte from yParity (0/1 → 27/28), the same\n    // `v` ethers' `Signature.serialized` writes.\n    return serializeSignature({\n      r: `0x${r.toString(16).padStart(64, '0')}`,\n      s: `0x${s.toString(16).padStart(64, '0')}`,\n      yParity: recovery,\n    })\n  } catch (err) {\n    throw new HavenSigningError(\n      `Failed to sign hash: ${err instanceof Error ? err.message : String(err)}`,\n    )\n  }\n}\n\nexport function verifySignature(hash: string, signature: string, expectedAddress: string): boolean {\n  try {\n    const sig = hexBytes(signature, 65, 'signature')\n    const hashHex = hexBytes(hash, 32, 'hash')\n    // Reject the high-s malleable twin, as ethers does — one signature per message.\n    if (BigInt(`0x${sig.slice(64, 128)}`) > HALF_N) return false\n    const yParityOrV = Number.parseInt(sig.slice(128), 16)\n    const recoveryBit = yParityOrV === 0 || yParityOrV === 27 ? 0 : yParityOrV === 1 || yParityOrV === 28 ? 1 : -1\n    if (recoveryBit < 0) return false\n    const publicKey = secp256k1.Signature.fromCompact(sig.slice(0, 128))\n      .addRecoveryBit(recoveryBit)\n      .recoverPublicKey(hashHex)\n      .toHex(false)\n    const recovered = publicKeyToAddress(`0x${publicKey}`)\n    return recovered.toLowerCase() === expectedAddress.toLowerCase()\n  } catch {\n    return false\n  }\n}\n"]}

package/dist/edge.d.cts

@@ -0,0 +1,125 @@
+export { U as AgentPaymentFailureCode, Y as AgentPaymentNextAction, cb as CAVEAT_ENFORCERS, cc as CAVEAT_TYPEHASH, cd as DELEGATION_MANAGER, ce as DELEGATION_TYPEHASH, cf as DIRECT_PAYMENT_CHAIN_IDS, ac as DIRECT_SIGN_CONTEXT_VERSION, cg as DelegationForHashing, ad as ENTRY_POINT_V07, ch as EXECUTE_ABI, af as HAVEN_CLIENT_HEADER, ag as HAVEN_CONNECTOR_CHANNEL, ah as HAVEN_MINIMUM_NODE_VERSION, ci as HYBRID_DELEGATOR_IMPLEMENTATION, an as HavenApiError, a as HavenClientUpdate, I as HavenError, ar as HavenSigningError, at as HavenTypedDataRefusedError, au as HavenUnsupportedSignerVersionError, av as HavenUserOpBindingError, cj as MAX_SETTLEMENT_WINDOW_SECONDS, ax as MAX_TASK_BUDGET_TTL_SECONDS, aC as NextStep, aE as NextStepHandoff, aG as NextStepTarget, aO as ROOT_AUTHORITY, aR as SIGNER_UPDATE_FALLBACK, ck as SIMPLE_FACTORY_ADDRESS, aW as SettlementChildExpectation, cl as SettlementChildTypedData, aX as SignerRefusalCode, j as SweepAuthorization, a$ as SweepExpectedAuth, b4 as TYPED_DATA_NOT_ALLOWED, b5 as TaskBudgetCloseExpectation, b6 as TaskChildExpectation, b7 as TaskChildTypedData, ba as X402ExpectedAuth, be as X402PaymentOption, X as X402PaymentRequired, bp as assertBoundDirectPaymentUserOp, cm as assertFundingLegPaysDelegate, cn as assertOwnSettlementChild, bq as assertOwnTaskBudgetCloseUserOp, br as assertOwnTaskChild, bs as assertUserOpTypedDataBinding, bt as buildSweepAuthorizationMessage, bu as buildSweepTypedData, bv as buildX402ExpectedMessage, co as chainIdForNetwork, bx as connectorRerunCommand, bz as createNextStepBuilder, bA as decodeBase64Json, bD as deriveDelegateAccountAddress, bE as encodeBase64Json, bH as hashDelegation, bI as havenClientIdentity, bL as isPackedUserOperationTypedData, cp as isSettlementChildTypedData, bM as isSupportedNodeVersion, bO as isTaskChildTypedData, bQ as packedUserOperationHash, bU as readClientUpdate, b_ as selectStandardPaymentOption, c3 as toStandardPaymentRequirements, c4 as unsupportedNodeVersionMessage, c6 as verifySettlementChild, c8 as x402AuthorizationAmount, ca as x402V2PaymentEnvelope } from './base64-cD9kR4JL.cjs';
+import { Hex, Address } from 'viem';
+import 'x402/types';
+
+declare function addressFromKey(privateKey: string): string;
+declare function signHash(privateKey: string, hash: string): string;
+declare function verifySignature(hash: string, signature: string, expectedAddress: string): boolean;
+
+/**
+ * #3272 (B1 follow-up) — what `DelegationManager.redeemDelegations` actually
+ * does with the bytes `haven_sign`'s unbound branch allows through.
+ *
+ * `assertBoundDirectPaymentUserOp` (then in the signer's `tools.ts`, now
+ * `direct-payment-guard.ts`) used to stop at "the inner
+ * call decodes as `redeemDelegations`" — it never looked at the ARGUMENTS.
+ * MetaMask's DelegationManager (v1.3.0) treats an EMPTY permission context
+ * (an ABI-encoded `Delegation[]` of length 0) as self-authorised: with no
+ * delegation to check, it calls `IDeleGatorCore(msg.sender).executeFromExecutor`
+ * directly — running the paired `executionCallData` AS THE ACCOUNT, with no
+ * caveat, no budget, no recipient pin. Since `HybridDeleGator.transferOwnership`
+ * / `updateSigners` / `addKey` are `onlyEntryPointOrSelf`, a self-call in that
+ * slot captures the account exactly as a bare `execute(self, 0,
+ * transferOwnership(attacker))` would — the redeemDelegations wrapper was
+ * never inspected past its own selector.
+ *
+ * This module decodes and verifies the REAL redemption shape Haven's backend
+ * emits (`packages/backend/src/rails/delegation-rail.ts` `prepareRedemption`):
+ * exactly one permission context, exactly one delegation in it, whose
+ * `delegate` is this signer's own account (so the redemption authority is
+ * this signer's, not forwarded from elsewhere) and whose `delegator` is a
+ * DIFFERENT address (so it is a real grant, not a no-op self-delegation),
+ * under `ExecutionMode.SingleDefault`, with no trailing or non-canonical
+ * bytes anywhere in the chain.
+ *
+ * The `Delegation`/`Caveat` tuple shape is vendored from
+ * `@metamask/delegation-abis`' `IDelegationManager` ABI (a devDependency
+ * only, in `@haven_ai/signer`'s `package.json`) and pinned against the kit's
+ * own encoder by `packages/signer/src/redemption-guard.pins.test.ts`.
+ *
+ * TASK BUDGETS (#3329) widen the accepted chain from exactly one link to ONE
+ * OR TWO: `[budget]` (unchanged) or `[task child, budget]` — leaf first, as
+ * everywhere else in this file. The two-link case is safe by the SAME
+ * reasoning as the one-link case, extended one hop: the task child's own
+ * `delegate` AND `delegator` are this signer's OWN account (a
+ * SELF-delegation — `assertOwnTaskChild` in `task-budget-guards.ts` is what
+ * proves its caveats narrow, never widen, the budget it chains under), and
+ * the budget link underneath it keeps the existing (3)/(4) shape: delegate ==
+ * own account, delegator != own account (a real grant from elsewhere). A
+ * chain redeemed this way can therefore only ever be AS OR MORE restrictive
+ * than redeeming the budget directly — the task child ADDS caveats (amount,
+ * recipient, expiry); it can never remove one, because
+ * `DelegationManager.redeemDelegations` ANDs every caveat of every link in
+ * the chain (the same AND-only property `settlement-child.ts`'s header
+ * documents). Any OTHER two-link chain — a leaf delegated by a third party, a
+ * leaf whose delegate is not this signer's own account, a chain longer than
+ * two — is refused exactly as before.
+ */
+
+/** `Delegation` — `(address delegate, address delegator, bytes32 authority, Caveat[] caveats, uint256 salt, bytes signature)`. */
+declare const DELEGATION_TUPLE_COMPONENTS: readonly [{
+    readonly name: "delegate";
+    readonly type: "address";
+}, {
+    readonly name: "delegator";
+    readonly type: "address";
+}, {
+    readonly name: "authority";
+    readonly type: "bytes32";
+}, {
+    readonly name: "caveats";
+    readonly type: "tuple[]";
+    readonly components: readonly [{
+        readonly name: "enforcer";
+        readonly type: "address";
+    }, {
+        readonly name: "terms";
+        readonly type: "bytes";
+    }, {
+        readonly name: "args";
+        readonly type: "bytes";
+    }];
+}, {
+    readonly name: "salt";
+    readonly type: "uint256";
+}, {
+    readonly name: "signature";
+    readonly type: "bytes";
+}];
+/** `DelegationManager.redeemDelegations(bytes[],bytes32[],bytes[])` — selector `0xcef6d209`. */
+declare const REDEEM_DELEGATIONS_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "redeemDelegations";
+    readonly inputs: readonly [{
+        readonly name: "_permissionContexts";
+        readonly type: "bytes[]";
+    }, {
+        readonly name: "_modes";
+        readonly type: "bytes32[]";
+    }, {
+        readonly name: "_executionCallDatas";
+        readonly type: "bytes[]";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}];
+/**
+ * `ExecutionMode.SingleDefault` — all-zero `bytes32`
+ * (`@metamask/smart-accounts-kit`'s `ExecutionMode` enum). The backend never
+ * emits any other mode (`delegation-rail.ts`'s `prepareRedemption` always
+ * passes `[ExecutionMode.SingleDefault]`), so any other value here is refused
+ * rather than interpreted.
+ */
+declare const SINGLE_DEFAULT_MODE: Hex;
+/**
+ * Verify `redeemCalldata` (the bytes passed to `execute()`, selector already
+ * confirmed to be `redeemDelegations` by the caller) is EXACTLY one of Haven's
+ * two shapes: a single delegation redeemed by `ownAccount` and granted by
+ * someone else, or (#3329) that grant behind one task-budget child `ownAccount`
+ * delegated to itself; in `SingleDefault` mode, with no encoding slack
+ * anywhere. Throws
+ * `HavenSigningError` (never returns) on any disagreement.
+ */
+declare function assertRedeemsOwnBudgetDelegation(redeemCalldata: Hex, ownAccount: Address): void;
+
+export { DELEGATION_TUPLE_COMPONENTS, REDEEM_DELEGATIONS_ABI, SINGLE_DEFAULT_MODE, addressFromKey, assertRedeemsOwnBudgetDelegation, signHash, verifySignature };

package/dist/edge.d.ts

@@ -0,0 +1,125 @@
+export { U as AgentPaymentFailureCode, Y as AgentPaymentNextAction, cb as CAVEAT_ENFORCERS, cc as CAVEAT_TYPEHASH, cd as DELEGATION_MANAGER, ce as DELEGATION_TYPEHASH, cf as DIRECT_PAYMENT_CHAIN_IDS, ac as DIRECT_SIGN_CONTEXT_VERSION, cg as DelegationForHashing, ad as ENTRY_POINT_V07, ch as EXECUTE_ABI, af as HAVEN_CLIENT_HEADER, ag as HAVEN_CONNECTOR_CHANNEL, ah as HAVEN_MINIMUM_NODE_VERSION, ci as HYBRID_DELEGATOR_IMPLEMENTATION, an as HavenApiError, a as HavenClientUpdate, I as HavenError, ar as HavenSigningError, at as HavenTypedDataRefusedError, au as HavenUnsupportedSignerVersionError, av as HavenUserOpBindingError, cj as MAX_SETTLEMENT_WINDOW_SECONDS, ax as MAX_TASK_BUDGET_TTL_SECONDS, aC as NextStep, aE as NextStepHandoff, aG as NextStepTarget, aO as ROOT_AUTHORITY, aR as SIGNER_UPDATE_FALLBACK, ck as SIMPLE_FACTORY_ADDRESS, aW as SettlementChildExpectation, cl as SettlementChildTypedData, aX as SignerRefusalCode, j as SweepAuthorization, a$ as SweepExpectedAuth, b4 as TYPED_DATA_NOT_ALLOWED, b5 as TaskBudgetCloseExpectation, b6 as TaskChildExpectation, b7 as TaskChildTypedData, ba as X402ExpectedAuth, be as X402PaymentOption, X as X402PaymentRequired, bp as assertBoundDirectPaymentUserOp, cm as assertFundingLegPaysDelegate, cn as assertOwnSettlementChild, bq as assertOwnTaskBudgetCloseUserOp, br as assertOwnTaskChild, bs as assertUserOpTypedDataBinding, bt as buildSweepAuthorizationMessage, bu as buildSweepTypedData, bv as buildX402ExpectedMessage, co as chainIdForNetwork, bx as connectorRerunCommand, bz as createNextStepBuilder, bA as decodeBase64Json, bD as deriveDelegateAccountAddress, bE as encodeBase64Json, bH as hashDelegation, bI as havenClientIdentity, bL as isPackedUserOperationTypedData, cp as isSettlementChildTypedData, bM as isSupportedNodeVersion, bO as isTaskChildTypedData, bQ as packedUserOperationHash, bU as readClientUpdate, b_ as selectStandardPaymentOption, c3 as toStandardPaymentRequirements, c4 as unsupportedNodeVersionMessage, c6 as verifySettlementChild, c8 as x402AuthorizationAmount, ca as x402V2PaymentEnvelope } from './base64-cD9kR4JL.js';
+import { Hex, Address } from 'viem';
+import 'x402/types';
+
+declare function addressFromKey(privateKey: string): string;
+declare function signHash(privateKey: string, hash: string): string;
+declare function verifySignature(hash: string, signature: string, expectedAddress: string): boolean;
+
+/**
+ * #3272 (B1 follow-up) — what `DelegationManager.redeemDelegations` actually
+ * does with the bytes `haven_sign`'s unbound branch allows through.
+ *
+ * `assertBoundDirectPaymentUserOp` (then in the signer's `tools.ts`, now
+ * `direct-payment-guard.ts`) used to stop at "the inner
+ * call decodes as `redeemDelegations`" — it never looked at the ARGUMENTS.
+ * MetaMask's DelegationManager (v1.3.0) treats an EMPTY permission context
+ * (an ABI-encoded `Delegation[]` of length 0) as self-authorised: with no
+ * delegation to check, it calls `IDeleGatorCore(msg.sender).executeFromExecutor`
+ * directly — running the paired `executionCallData` AS THE ACCOUNT, with no
+ * caveat, no budget, no recipient pin. Since `HybridDeleGator.transferOwnership`
+ * / `updateSigners` / `addKey` are `onlyEntryPointOrSelf`, a self-call in that
+ * slot captures the account exactly as a bare `execute(self, 0,
+ * transferOwnership(attacker))` would — the redeemDelegations wrapper was
+ * never inspected past its own selector.
+ *
+ * This module decodes and verifies the REAL redemption shape Haven's backend
+ * emits (`packages/backend/src/rails/delegation-rail.ts` `prepareRedemption`):
+ * exactly one permission context, exactly one delegation in it, whose
+ * `delegate` is this signer's own account (so the redemption authority is
+ * this signer's, not forwarded from elsewhere) and whose `delegator` is a
+ * DIFFERENT address (so it is a real grant, not a no-op self-delegation),
+ * under `ExecutionMode.SingleDefault`, with no trailing or non-canonical
+ * bytes anywhere in the chain.
+ *
+ * The `Delegation`/`Caveat` tuple shape is vendored from
+ * `@metamask/delegation-abis`' `IDelegationManager` ABI (a devDependency
+ * only, in `@haven_ai/signer`'s `package.json`) and pinned against the kit's
+ * own encoder by `packages/signer/src/redemption-guard.pins.test.ts`.
+ *
+ * TASK BUDGETS (#3329) widen the accepted chain from exactly one link to ONE
+ * OR TWO: `[budget]` (unchanged) or `[task child, budget]` — leaf first, as
+ * everywhere else in this file. The two-link case is safe by the SAME
+ * reasoning as the one-link case, extended one hop: the task child's own
+ * `delegate` AND `delegator` are this signer's OWN account (a
+ * SELF-delegation — `assertOwnTaskChild` in `task-budget-guards.ts` is what
+ * proves its caveats narrow, never widen, the budget it chains under), and
+ * the budget link underneath it keeps the existing (3)/(4) shape: delegate ==
+ * own account, delegator != own account (a real grant from elsewhere). A
+ * chain redeemed this way can therefore only ever be AS OR MORE restrictive
+ * than redeeming the budget directly — the task child ADDS caveats (amount,
+ * recipient, expiry); it can never remove one, because
+ * `DelegationManager.redeemDelegations` ANDs every caveat of every link in
+ * the chain (the same AND-only property `settlement-child.ts`'s header
+ * documents). Any OTHER two-link chain — a leaf delegated by a third party, a
+ * leaf whose delegate is not this signer's own account, a chain longer than
+ * two — is refused exactly as before.
+ */
+
+/** `Delegation` — `(address delegate, address delegator, bytes32 authority, Caveat[] caveats, uint256 salt, bytes signature)`. */
+declare const DELEGATION_TUPLE_COMPONENTS: readonly [{
+    readonly name: "delegate";
+    readonly type: "address";
+}, {
+    readonly name: "delegator";
+    readonly type: "address";
+}, {
+    readonly name: "authority";
+    readonly type: "bytes32";
+}, {
+    readonly name: "caveats";
+    readonly type: "tuple[]";
+    readonly components: readonly [{
+        readonly name: "enforcer";
+        readonly type: "address";
+    }, {
+        readonly name: "terms";
+        readonly type: "bytes";
+    }, {
+        readonly name: "args";
+        readonly type: "bytes";
+    }];
+}, {
+    readonly name: "salt";
+    readonly type: "uint256";
+}, {
+    readonly name: "signature";
+    readonly type: "bytes";
+}];
+/** `DelegationManager.redeemDelegations(bytes[],bytes32[],bytes[])` — selector `0xcef6d209`. */
+declare const REDEEM_DELEGATIONS_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "redeemDelegations";
+    readonly inputs: readonly [{
+        readonly name: "_permissionContexts";
+        readonly type: "bytes[]";
+    }, {
+        readonly name: "_modes";
+        readonly type: "bytes32[]";
+    }, {
+        readonly name: "_executionCallDatas";
+        readonly type: "bytes[]";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}];
+/**
+ * `ExecutionMode.SingleDefault` — all-zero `bytes32`
+ * (`@metamask/smart-accounts-kit`'s `ExecutionMode` enum). The backend never
+ * emits any other mode (`delegation-rail.ts`'s `prepareRedemption` always
+ * passes `[ExecutionMode.SingleDefault]`), so any other value here is refused
+ * rather than interpreted.
+ */
+declare const SINGLE_DEFAULT_MODE: Hex;
+/**
+ * Verify `redeemCalldata` (the bytes passed to `execute()`, selector already
+ * confirmed to be `redeemDelegations` by the caller) is EXACTLY one of Haven's
+ * two shapes: a single delegation redeemed by `ownAccount` and granted by
+ * someone else, or (#3329) that grant behind one task-budget child `ownAccount`
+ * delegated to itself; in `SingleDefault` mode, with no encoding slack
+ * anywhere. Throws
+ * `HavenSigningError` (never returns) on any disagreement.
+ */
+declare function assertRedeemsOwnBudgetDelegation(redeemCalldata: Hex, ownAccount: Address): void;
+
+export { DELEGATION_TUPLE_COMPONENTS, REDEEM_DELEGATIONS_ABI, SINGLE_DEFAULT_MODE, addressFromKey, assertRedeemsOwnBudgetDelegation, signHash, verifySignature };

package/dist/edge.js

@@ -0,0 +1,56 @@
+export { CAVEAT_TYPEHASH, DELEGATION_TYPEHASH, DIRECT_PAYMENT_CHAIN_IDS, EXECUTE_ABI, HAVEN_CLIENT_HEADER, HAVEN_MINIMUM_NODE_VERSION, HavenTypedDataRefusedError, MAX_TASK_BUDGET_TTL_SECONDS, TYPED_DATA_NOT_ALLOWED, assertBoundDirectPaymentUserOp, assertFundingLegPaysDelegate, assertOwnSettlementChild, assertOwnTaskBudgetCloseUserOp, assertOwnTaskChild, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, createNextStepBuilder, decodeBase64Json, encodeBase64Json, hashDelegation, havenClientIdentity, isSupportedNodeVersion, isTaskChildTypedData, readClientUpdate, selectStandardPaymentOption, toStandardPaymentRequirements, unsupportedNodeVersionMessage, x402AuthorizationAmount, x402V2PaymentEnvelope } from './chunk-3WSEX3GW.js';
+import { HavenSigningError } from './chunk-63GPTEEY.js';
+export { AgentPaymentFailureCode, AgentPaymentNextAction, CAVEAT_ENFORCERS, DELEGATION_MANAGER, DELEGATION_TUPLE_COMPONENTS, DIRECT_SIGN_CONTEXT_VERSION, ENTRY_POINT_V07, HAVEN_CONNECTOR_CHANNEL, HYBRID_DELEGATOR_IMPLEMENTATION, HavenApiError, HavenError, HavenSigningError, HavenUnsupportedSignerVersionError, HavenUserOpBindingError, MAX_SETTLEMENT_WINDOW_SECONDS, REDEEM_DELEGATIONS_ABI, ROOT_AUTHORITY, SIGNER_UPDATE_FALLBACK, SIMPLE_FACTORY_ADDRESS, SINGLE_DEFAULT_MODE, SignerRefusalCode, assertRedeemsOwnBudgetDelegation, assertUserOpTypedDataBinding, chainIdForNetwork, connectorRerunCommand, deriveDelegateAccountAddress, isPackedUserOperationTypedData, isSettlementChildTypedData, packedUserOperationHash, verifySettlementChild } from './chunk-63GPTEEY.js';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { privateKeyToAddress, publicKeyToAddress } from 'viem/accounts';
+import { serializeSignature } from 'viem';
+
+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;
+  }
+}
+
+export { addressFromKey, signHash, verifySignature };
+//# sourceMappingURL=edge.js.map
+//# sourceMappingURL=edge.js.map

package/dist/edge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/edge-signing.ts"],"names":[],"mappings":"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","file":"edge.js","sourcesContent":["import { secp256k1 } from '@noble/curves/secp256k1'\nimport { privateKeyToAddress, publicKeyToAddress } from 'viem/accounts'\nimport { serializeSignature, type Hex } from 'viem'\nimport { HavenSigningError } from './types.js'\n\n/**\n * #3173: the three key helpers the edge signer needs, without ethers.\n *\n * `./signer.ts` implements the same three on ethers, and the SDK barrel pulls\n * ethers in for them (and for `provider.ts` / `receipt.ts`). The edge signer\n * already ships viem, and viem signs with `@noble/curves` underneath — these\n * use the same curve library directly, synchronously (viem's own `sign` is\n * async), so `@haven_ai/sdk/edge` stays ethers-free and a signer session stops\n * paying for module init it never uses. Byte-equivalence with the ethers forms\n * is pinned in `edge-signing.test.ts`: same address, same 65-byte `r‖s‖v`\n * serialisation with low-s and v = 27/28, same recovery verdicts, and the same\n * refusals (high-s twin, wrong lengths) — with three stated strict-direction\n * exceptions, see `hexBytes`. Raw ECDSA over the hash — never the EIP-191\n * prefixed digest.\n */\n\n/** secp256k1 order / 2 — a signature with s above this is the malleable twin ethers rejects. */\nconst HALF_N = BigInt('0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0')\n\n/**\n * Stricter than ethers, never looser: the lowercase `0x` prefix and the exact\n * byte length are required. Ethers accepts an uppercase `0X` prefix on a\n * signature and the 64-byte EIP-2098 compact form, and is inconsistent on a\n * private key (`Wallet` accepts unprefixed and refuses `0X`; `SigningKey` does\n * the reverse); every such form is refused here — the divergences are pinned\n * in `edge-signing.test.ts` with ethers control assertions, and every\n * well-formed input is byte-equivalent.\n */\nfunction hexBytes(value: string, bytes: number, what: string): string {\n  if (!/^0x[0-9a-fA-F]+$/.test(value) || value.length !== 2 + bytes * 2) {\n    throw new Error(`${what} must be a 0x-prefixed ${bytes}-byte hex string`)\n  }\n  return value.slice(2)\n}\n\nexport function addressFromKey(privateKey: string): string {\n  try {\n    // Same gate as signHash: a key that derives an address must also sign.\n    return privateKeyToAddress(`0x${hexBytes(privateKey, 32, 'private key')}`)\n  } catch (err) {\n    throw new HavenSigningError(\n      `Invalid private key: ${err instanceof Error ? err.message : String(err)}`,\n    )\n  }\n}\n\nexport function signHash(privateKey: string, hash: string): string {\n  try {\n    const { r, s, recovery } = secp256k1.sign(hexBytes(hash, 32, 'hash'), hexBytes(privateKey, 32, 'private key'), { lowS: true })\n    // viem serialises the trailing byte from yParity (0/1 → 27/28), the same\n    // `v` ethers' `Signature.serialized` writes.\n    return serializeSignature({\n      r: `0x${r.toString(16).padStart(64, '0')}`,\n      s: `0x${s.toString(16).padStart(64, '0')}`,\n      yParity: recovery,\n    })\n  } catch (err) {\n    throw new HavenSigningError(\n      `Failed to sign hash: ${err instanceof Error ? err.message : String(err)}`,\n    )\n  }\n}\n\nexport function verifySignature(hash: string, signature: string, expectedAddress: string): boolean {\n  try {\n    const sig = hexBytes(signature, 65, 'signature')\n    const hashHex = hexBytes(hash, 32, 'hash')\n    // Reject the high-s malleable twin, as ethers does — one signature per message.\n    if (BigInt(`0x${sig.slice(64, 128)}`) > HALF_N) return false\n    const yParityOrV = Number.parseInt(sig.slice(128), 16)\n    const recoveryBit = yParityOrV === 0 || yParityOrV === 27 ? 0 : yParityOrV === 1 || yParityOrV === 28 ? 1 : -1\n    if (recoveryBit < 0) return false\n    const publicKey = secp256k1.Signature.fromCompact(sig.slice(0, 128))\n      .addRecoveryBit(recoveryBit)\n      .recoverPublicKey(hashHex)\n      .toHex(false)\n    const recovered = publicKeyToAddress(`0x${publicKey}`)\n    return recovered.toLowerCase() === expectedAddress.toLowerCase()\n  } catch {\n    return false\n  }\n}\n"]}