@haven_ai/sdk 0.3.0-alpha.0 → 0.5.0-alpha.1

package/dist/edge.d.cts

@@ -0,0 +1,105 @@
+export { M as AgentPaymentFailureCode, Q as AgentPaymentNextAction, b_ as CAVEAT_ENFORCERS, b$ as DELEGATION_MANAGER, c0 as DIRECT_PAYMENT_CHAIN_IDS, a7 as DIRECT_SIGN_CONTEXT_VERSION, a8 as ENTRY_POINT_V07, c1 as EXECUTE_ABI, aa as HAVEN_CLIENT_HEADER, ab as HAVEN_CONNECTOR_CHANNEL, ac as HAVEN_MINIMUM_NODE_VERSION, c2 as HYBRID_DELEGATOR_IMPLEMENTATION, ai as HavenApiError, a as HavenClientUpdate, E as HavenError, am as HavenSigningError, ao as HavenTypedDataRefusedError, ap as HavenUnsupportedSignerVersionError, aq as HavenUserOpBindingError, c3 as MAX_SETTLEMENT_WINDOW_SECONDS, aw as NextStep, ay as NextStepHandoff, aA as NextStepTarget, aI as ROOT_AUTHORITY, aL as SIGNER_UPDATE_FALLBACK, c4 as SIMPLE_FACTORY_ADDRESS, aQ as SettlementChildExpectation, c5 as SettlementChildTypedData, aR as SignerRefusalCode, j as SweepAuthorization, aV as SweepExpectedAuth, a_ as TYPED_DATA_NOT_ALLOWED, b1 as X402ExpectedAuth, b5 as X402PaymentOption, X as X402PaymentRequired, bg as assertBoundDirectPaymentUserOp, c6 as assertFundingLegPaysDelegate, c7 as assertOwnSettlementChild, bh as assertUserOpTypedDataBinding, bi as buildSweepAuthorizationMessage, bj as buildSweepTypedData, bk as buildX402ExpectedMessage, c8 as chainIdForNetwork, bm as connectorRerunCommand, bo as createNextStepBuilder, bp as decodeBase64Json, bs as deriveDelegateAccountAddress, bt as encodeBase64Json, bw as havenClientIdentity, bz as isPackedUserOperationTypedData, c9 as isSettlementChildTypedData, bA as isSupportedNodeVersion, bD as packedUserOperationHash, bH as readClientUpdate, bN as selectStandardPaymentOption, bS as toStandardPaymentRequirements, bT as unsupportedNodeVersionMessage, bV as verifySettlementChild, bX as x402AuthorizationAmount, bZ as x402V2PaymentEnvelope } from './base64-BUMXmruY.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`.
+ */
+
+/** `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 Haven's own
+ * shape: one delegation, redeemed by `ownAccount`, granted by someone else,
+ * 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,105 @@
+export { M as AgentPaymentFailureCode, Q as AgentPaymentNextAction, b_ as CAVEAT_ENFORCERS, b$ as DELEGATION_MANAGER, c0 as DIRECT_PAYMENT_CHAIN_IDS, a7 as DIRECT_SIGN_CONTEXT_VERSION, a8 as ENTRY_POINT_V07, c1 as EXECUTE_ABI, aa as HAVEN_CLIENT_HEADER, ab as HAVEN_CONNECTOR_CHANNEL, ac as HAVEN_MINIMUM_NODE_VERSION, c2 as HYBRID_DELEGATOR_IMPLEMENTATION, ai as HavenApiError, a as HavenClientUpdate, E as HavenError, am as HavenSigningError, ao as HavenTypedDataRefusedError, ap as HavenUnsupportedSignerVersionError, aq as HavenUserOpBindingError, c3 as MAX_SETTLEMENT_WINDOW_SECONDS, aw as NextStep, ay as NextStepHandoff, aA as NextStepTarget, aI as ROOT_AUTHORITY, aL as SIGNER_UPDATE_FALLBACK, c4 as SIMPLE_FACTORY_ADDRESS, aQ as SettlementChildExpectation, c5 as SettlementChildTypedData, aR as SignerRefusalCode, j as SweepAuthorization, aV as SweepExpectedAuth, a_ as TYPED_DATA_NOT_ALLOWED, b1 as X402ExpectedAuth, b5 as X402PaymentOption, X as X402PaymentRequired, bg as assertBoundDirectPaymentUserOp, c6 as assertFundingLegPaysDelegate, c7 as assertOwnSettlementChild, bh as assertUserOpTypedDataBinding, bi as buildSweepAuthorizationMessage, bj as buildSweepTypedData, bk as buildX402ExpectedMessage, c8 as chainIdForNetwork, bm as connectorRerunCommand, bo as createNextStepBuilder, bp as decodeBase64Json, bs as deriveDelegateAccountAddress, bt as encodeBase64Json, bw as havenClientIdentity, bz as isPackedUserOperationTypedData, c9 as isSettlementChildTypedData, bA as isSupportedNodeVersion, bD as packedUserOperationHash, bH as readClientUpdate, bN as selectStandardPaymentOption, bS as toStandardPaymentRequirements, bT as unsupportedNodeVersionMessage, bV as verifySettlementChild, bX as x402AuthorizationAmount, bZ as x402V2PaymentEnvelope } from './base64-BUMXmruY.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`.
+ */
+
+/** `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 Haven's own
+ * shape: one delegation, redeemed by `ownAccount`, granted by someone else,
+ * 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 { DIRECT_PAYMENT_CHAIN_IDS, EXECUTE_ABI, HAVEN_CLIENT_HEADER, HAVEN_MINIMUM_NODE_VERSION, HavenTypedDataRefusedError, TYPED_DATA_NOT_ALLOWED, assertBoundDirectPaymentUserOp, assertFundingLegPaysDelegate, assertOwnSettlementChild, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, createNextStepBuilder, decodeBase64Json, encodeBase64Json, havenClientIdentity, isSupportedNodeVersion, readClientUpdate, selectStandardPaymentOption, toStandardPaymentRequirements, unsupportedNodeVersionMessage, x402AuthorizationAmount, x402V2PaymentEnvelope } from './chunk-KQ7JXKTV.js';
+import { HavenSigningError } from './chunk-GLNG2GF7.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-GLNG2GF7.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"]}