@rhinestone/sdk 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/src/modules/validators/core.js

@@ -1,12 +1,11 @@
 import { bytesToHex, concat, encodeAbiParameters, encodePacked, hexToBytes, maxUint48, pad, toHex, } from 'viem';
-import { OwnersFieldRequiredError } from '../../accounts/error.js';
+import { AccountConfigurationNotSupportedError, OwnersFieldRequiredError, } from '../../accounts/error.js';
 import { MODULE_TYPE_ID_VALIDATOR } from '../common.js';
 const SMART_SESSION_EMISSARY_ADDRESS_DEV = '0x60731de80d78548875f8a67c4fec2a8660194e0c';
 const SMART_SESSION_EMISSARY_ADDRESS = '0xad568b3f825a8d5ffc06dd3253526b64d810ae89';
 const OWNABLE_VALIDATOR_ADDRESS = '0x000000000013fdb5234e4e3162a810f54d9f7e98';
-const ENS_VALIDATOR_ADDRESS = '0xdc38f07b060374b6480c4bf06231e7d10955bca4';
+const ENS_HCA_MODULE = '0x5049ecBd4d961aE6DFEED9b7ccCe7f026454970E';
 const WEBAUTHN_VALIDATOR_ADDRESS = '0x0000000000578c4cb0e472a5462da43c495c3f33';
-const SOCIAL_RECOVERY_VALIDATOR_ADDRESS = '0xa04d053b3c8021e8d5bf641816c42daa75d8b597';
 const MULTI_FACTOR_VALIDATOR_ADDRESS = '0xf6bdf42c9be18ceca5c06c42a43daf7fbbe7896b';
 // Legacy
 const OWNABLE_V0_VALIDATOR_ADDRESS = '0x2483da3a338895199e5e538530213157e931bf06';
@@ -14,21 +13,37 @@ const OWNABLE_BETA_VALIDATOR_ADDRESS = '0x0000000000e9e6e96bcaa3c113187cdb7e38ae
 const WEBAUTHN_V0_VALIDATOR_ADDRESS = '0x0000000000578c4cb0e472a5462da43c495c3f33';
 const ECDSA_MOCK_SIGNATURE = '0x81d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b';
 const WEBAUTHN_MOCK_SIGNATURE = '0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001b9b86eb98fda3ed4d797d9e690588dfadf17b329a76a47cec935bebf92d7ddc80000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000001700000000000000000000000000000000000000000000000000000000000000019b2e9410bb6850f9f660a03d609d5a844fb96bcdc87a15139b03ee22c70f469100d2b865a215c3bf786387064effa8fcedcb1d625b5148f8a1236d5e3ff11acf000000000000000000000000000000000000000000000000000000000000002549960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d9763050000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000867b2274797065223a22776562617574686e2e676574222c226368616c6c656e6765223a22396a4546696a75684557724d34534f572d7443684a625545484550343456636a634a2d42716f3166544d38222c226f726967696e223a22687474703a2f2f6c6f63616c686f73743a38303830222c2263726f73734f726967696e223a66616c73657d0000000000000000000000000000000000000000000000000000';
+// ENS validation is only available on HCA accounts (its validator default is
+// the HCA module). True for a direct ENS owner set or an ENS sub-validator
+// nested in a multi-factor config.
+function ownerSetUsesEns(owners) {
+    return (owners.type === 'ens' ||
+        (owners.type === 'multi-factor' &&
+            owners.validators.some((validator) => validator.type === 'ens')));
+}
 function getOwnerValidator(config) {
     if (!config.owners) {
         throw new OwnersFieldRequiredError();
     }
+    // ENS owners resolve to the HCA module, which is only valid for HCA accounts.
+    // Other account types would silently install/sign against the wrong validator.
+    if (ownerSetUsesEns(config.owners) && config.account?.type !== 'hca') {
+        throw new AccountConfigurationNotSupportedError('ENS owners are only supported on HCA accounts', config.account?.type ?? 'nexus');
+    }
     return getValidator(config.owners);
 }
 function getMockSignature(ownerSet) {
     switch (ownerSet.type) {
-        case 'ecdsa':
-        case 'ens': {
-            // ENS validator uses same mock signature format as ECDSA for UserOps
+        case 'ecdsa': {
             const owners = ownerSet.accounts.map((account) => account.address);
             const signatures = owners.map(() => ECDSA_MOCK_SIGNATURE);
             return concat(signatures);
         }
+        case 'ens': {
+            // ENS validator uses same mock signature format as ECDSA for UserOps
+            const signatures = ownerSet.owners.map(() => ECDSA_MOCK_SIGNATURE);
+            return concat(signatures);
+        }
         case 'passkey':
             return WEBAUTHN_MOCK_SIGNATURE;
         case 'multi-factor': {
@@ -67,14 +82,16 @@ function getValidator(owners) {
         case 'ecdsa':
             return getOwnableValidator(owners.threshold ?? 1, owners.accounts.map((account) => account.address), owners.module);
         case 'ens':
-            return getENSValidator(owners.threshold ?? 1, owners.accounts.map((account) => account.address), owners.ownerExpirations, owners.module);
+            // ENS validation is baked into the HCA account implementation, so the
+            // module address is fixed (no override).
+            return getENSValidator(owners.threshold ?? 1, owners.owners.map((o) => o.account.address), owners.owners.map((o) => o.expiration));
         case 'passkey':
             return getWebAuthnValidator(owners.threshold ?? 1, owners.accounts.map((account) => ({
                 pubKey: account.publicKey,
                 authenticatorId: account.id,
-            })));
+            })), owners.module);
         case 'multi-factor': {
-            return getMultiFactorValidator(owners.threshold ?? 1, owners.validators);
+            return getMultiFactorValidator(owners.threshold ?? 1, owners.validators, owners.module);
         }
     }
 }
@@ -93,13 +110,20 @@ function getOwnableValidator(threshold, owners, address) {
         type: MODULE_TYPE_ID_VALIDATOR,
     };
 }
-function getENSValidator(threshold, owners, ownerExpirations, address) {
+function getENSValidator(threshold, owners, expirations) {
     // format: (uint256 threshold, Owner[] owners)
     // where Owner is a tuple of (address addr, uint48 expiration)
-    const ownerPairs = owners.map((owner, index) => ({
-        addr: owner.toLowerCase(),
-        expiration: ownerExpirations[index] ?? maxUint48,
-    }));
+    const ownerPairs = owners.map((owner, index) => {
+        const expiration = expirations[index];
+        return {
+            addr: owner.toLowerCase(),
+            // maxUint48 is the on-chain "never expires" sentinel; it's outside the
+            // representable Date range, so an omitted expiry maps to it directly.
+            expiration: expiration !== undefined
+                ? Math.floor(expiration.getTime() / 1000)
+                : Number(maxUint48),
+        };
+    });
     // Sort by address to match ENS validator's expectations
     const sortedPairs = ownerPairs.sort((a, b) => a.addr.localeCompare(b.addr));
     const ownersWithExpiration = sortedPairs;
@@ -114,9 +138,8 @@ function getENSValidator(threshold, owners, ownerExpirations, address) {
             ],
         },
     ], [BigInt(threshold), ownersWithExpiration]);
-    const moduleAddress = address ?? ENS_VALIDATOR_ADDRESS;
     return {
-        address: moduleAddress,
+        address: ENS_HCA_MODULE,
         initData,
         deInitData: '0x',
         additionalContext: '0x',
@@ -178,9 +201,9 @@ function getWebAuthnValidator(threshold, webAuthnCredentials, address) {
         type: MODULE_TYPE_ID_VALIDATOR,
     };
 }
-function getMultiFactorValidator(threshold, validators) {
+function getMultiFactorValidator(threshold, validators, address) {
     return {
-        address: MULTI_FACTOR_VALIDATOR_ADDRESS,
+        address: address ?? MULTI_FACTOR_VALIDATOR_ADDRESS,
         initData: encodePacked(['uint8', 'bytes'], [
             threshold,
             encodeAbiParameters([
@@ -221,26 +244,6 @@ function getMultiFactorValidator(threshold, validators) {
         type: MODULE_TYPE_ID_VALIDATOR,
     };
 }
-function getSocialRecoveryValidator(guardians, threshold = 1) {
-    const guardianAddresses = guardians.map((guardian) => guardian.address);
-    guardianAddresses.sort();
-    return {
-        type: MODULE_TYPE_ID_VALIDATOR,
-        address: SOCIAL_RECOVERY_VALIDATOR_ADDRESS,
-        initData: encodeAbiParameters([
-            {
-                type: 'uint256',
-                name: 'threshold',
-            },
-            {
-                type: 'address[]',
-                name: 'guardians',
-            },
-        ], [BigInt(threshold), guardianAddresses]),
-        deInitData: '0x',
-        additionalContext: '0x',
-    };
-}
 function parsePublicKey(publicKey) {
     const bytes = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;
     const offset = bytes.length === 65 ? 1 : 0;
@@ -263,4 +266,4 @@ function supportsEip712(validator) {
             return true;
     }
 }
-export { OWNABLE_VALIDATOR_ADDRESS, ENS_VALIDATOR_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, MULTI_FACTOR_VALIDATOR_ADDRESS, WEBAUTHN_V0_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, getOwnerValidator, getOwnableValidator, getENSValidator, getWebAuthnValidator, getMultiFactorValidator, getSocialRecoveryValidator, getValidator, getMockSignature, supportsEip712, };
+export { OWNABLE_VALIDATOR_ADDRESS, ENS_HCA_MODULE, WEBAUTHN_VALIDATOR_ADDRESS, MULTI_FACTOR_VALIDATOR_ADDRESS, WEBAUTHN_V0_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, getOwnerValidator, getOwnableValidator, getENSValidator, getWebAuthnValidator, getMultiFactorValidator, getValidator, getMockSignature, supportsEip712, ownerSetUsesEns, };

package/dist/src/modules/validators/cross-chain-permits.d.ts

@@ -0,0 +1,21 @@
+import type { CrossChainPermissionInput, CrossChainPermit } from '../../types.js';
+/**
+ * Resolve a {@link CrossChainPermissionInput} into a {@link CrossChainPermit}:
+ * normalise single/array legs, resolve `TokenSymbol`s to per-chain ERC-20
+ * addresses, and convert `Date` validity bounds to unix-seconds.
+ *
+ * @internal Used by `expandCrossChainPermit`; not part of the public API.
+ */
+declare function resolveCrossChainPermission(input: CrossChainPermissionInput): CrossChainPermit;
+/**
+ * Convert a resolved {@link CrossChainPermit} back into the
+ * {@link CrossChainPermissionInput} shape accepted by
+ * `SessionDefinition.crossChainPermits`.
+ *
+ * Useful when a permit was persisted in its resolved (unix-seconds) form and
+ * has to be re-supplied as session input: converts `bigint` deadlines to
+ * `Date` and maps `recipientIsAccount` to the inverse `allowRecipientNotAccount`.
+ */
+declare function toCrossChainPermissionInput(permit: CrossChainPermit): CrossChainPermissionInput;
+export { resolveCrossChainPermission, toCrossChainPermissionInput };
+//# sourceMappingURL=cross-chain-permits.d.ts.map

package/dist/src/modules/validators/cross-chain-permits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-chain-permits.d.ts","sourceRoot":"","sources":["../../../../modules/validators/cross-chain-permits.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,yBAAyB,EACzB,gBAAgB,EAEjB,MAAM,aAAa,CAAA;AAyBpB;;;;;;GAMG;AACH,iBAAS,2BAA2B,CAClC,KAAK,EAAE,yBAAyB,GAC/B,gBAAgB,CA0DlB;AAQD;;;;;;;;GAQG;AACH,iBAAS,2BAA2B,CAClC,MAAM,EAAE,gBAAgB,GACvB,yBAAyB,CAuB3B;AAED,OAAO,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,CAAA"}

package/dist/src/modules/validators/cross-chain-permits.js

@@ -0,0 +1,111 @@
+import { isAddress } from 'viem';
+import { getTokenAddress } from '../../orchestrator/registry.js';
+function dateToUnixSeconds(input) {
+    // Date.getTime() returns milliseconds since epoch; the on-chain policy
+    // expects unix-seconds. Integer division matches the Permit2 deadline
+    // convention.
+    return BigInt(Math.floor(input.getTime() / 1000));
+}
+function resolveTokenForChain(token, chainId) {
+    return isAddress(token) ? token : getTokenAddress(token, chainId);
+}
+// Normalise the single-object / array / omitted shapes into arrays. An
+// omitted side stays `undefined` (no restriction), mirroring how the
+// underlying Permit2 policy treats an absent token list.
+function normalizeLegs(legs) {
+    if (legs === undefined)
+        return undefined;
+    const arr = Array.isArray(legs) ? legs : [legs];
+    return arr.length ? arr : undefined;
+}
+/**
+ * Resolve a {@link CrossChainPermissionInput} into a {@link CrossChainPermit}:
+ * normalise single/array legs, resolve `TokenSymbol`s to per-chain ERC-20
+ * addresses, and convert `Date` validity bounds to unix-seconds.
+ *
+ * @internal Used by `expandCrossChainPermit`; not part of the public API.
+ */
+function resolveCrossChainPermission(input) {
+    const fromLegs = normalizeLegs(input.from);
+    const toLegs = normalizeLegs(input.to);
+    const from = fromLegs?.map((leg) => ({
+        chain: leg.chain,
+        token: resolveTokenForChain(leg.token, leg.chain.id),
+        maxAmount: leg.maxAmount,
+    }));
+    const to = toLegs?.map((leg) => ({
+        chain: leg.chain,
+        token: resolveTokenForChain(leg.token, leg.chain.id),
+        recipient: leg.recipient,
+    }));
+    const validUntil = input.validUntil !== undefined
+        ? dateToUnixSeconds(input.validUntil)
+        : undefined;
+    const validAfter = input.validAfter !== undefined
+        ? dateToUnixSeconds(input.validAfter)
+        : undefined;
+    // Detect an obviously-broken time window early. The on-chain policy
+    // would reject any intent in this state anyway; surfacing it at build
+    // time saves a round-trip to chain.
+    if (validUntil !== undefined &&
+        validAfter !== undefined &&
+        validAfter > validUntil) {
+        throw new Error(`crossChainPermits: validAfter (${validAfter}) is greater than validUntil (${validUntil})`);
+    }
+    const fillDeadline = input.fillDeadline?.map(({ chain, min, max }) => ({
+        chain,
+        min: min !== undefined ? dateToUnixSeconds(min) : undefined,
+        max: max !== undefined ? dateToUnixSeconds(max) : undefined,
+    }));
+    return {
+        from,
+        to,
+        validUntil,
+        validAfter,
+        fillDeadline,
+        // Inverted default: callers must opt out of bridge-to-self
+        // explicitly. This stops a session key from quietly bridging to an
+        // attacker-controlled recipient.
+        recipientIsAccount: !input.allowRecipientNotAccount,
+        // Passed through verbatim. `getArbitersForSettlementLayers` expands
+        // undefined/empty to "all supported layers" at session-data build
+        // time.
+        settlementLayers: input.settlementLayers,
+    };
+}
+function unixSecondsToDate(seconds) {
+    // Inverse of dateToUnixSeconds: on-chain deadlines are unix-seconds; Date
+    // expects milliseconds.
+    return new Date(Number(seconds) * 1000);
+}
+/**
+ * Convert a resolved {@link CrossChainPermit} back into the
+ * {@link CrossChainPermissionInput} shape accepted by
+ * `SessionDefinition.crossChainPermits`.
+ *
+ * Useful when a permit was persisted in its resolved (unix-seconds) form and
+ * has to be re-supplied as session input: converts `bigint` deadlines to
+ * `Date` and maps `recipientIsAccount` to the inverse `allowRecipientNotAccount`.
+ */
+function toCrossChainPermissionInput(permit) {
+    return {
+        from: permit.from,
+        to: permit.to,
+        validUntil: permit.validUntil !== undefined
+            ? unixSecondsToDate(permit.validUntil)
+            : undefined,
+        validAfter: permit.validAfter !== undefined
+            ? unixSecondsToDate(permit.validAfter)
+            : undefined,
+        fillDeadline: permit.fillDeadline?.map(({ chain, min, max }) => ({
+            chain,
+            min: min !== undefined ? unixSecondsToDate(min) : undefined,
+            max: max !== undefined ? unixSecondsToDate(max) : undefined,
+        })),
+        allowRecipientNotAccount: permit.recipientIsAccount !== undefined
+            ? !permit.recipientIsAccount
+            : undefined,
+        settlementLayers: permit.settlementLayers,
+    };
+}
+export { resolveCrossChainPermission, toCrossChainPermissionInput };

package/dist/src/modules/validators/permissions.d.ts

@@ -1,4 +1,5 @@
 import type { Permission, ScopedAction } from '../../types.js';
+export declare const FAR_FUTURE_MS = 4102444800000;
 declare function resolvePermission(permission: Permission): ScopedAction[];
 declare function resolvePermissions(permissions: readonly Permission[]): ScopedAction[];
 export { resolvePermissions, resolvePermission };

package/dist/src/modules/validators/permissions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../../modules/validators/permissions.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,UAAU,EAEV,YAAY,EAEb,MAAM,aAAa,CAAA;AA0CpB,iBAAS,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,YAAY,EAAE,CA+FjE;AAED,iBAAS,kBAAkB,CACzB,WAAW,EAAE,SAAS,UAAU,EAAE,GACjC,YAAY,EAAE,CAEhB;AAED,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../../modules/validators/permissions.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAEV,UAAU,EAEV,YAAY,EAEb,MAAM,aAAa,CAAA;AAiHpB,eAAO,MAAM,aAAa,gBAAoB,CAAA;AAE9C,iBAAS,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,YAAY,EAAE,CA0NjE;AAkBD,iBAAS,kBAAkB,CACzB,WAAW,EAAE,SAAS,UAAU,EAAE,GACjC,YAAY,EAAE,CAwBhB;AAED,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/src/modules/validators/permissions.js

@@ -1,4 +1,4 @@
-import { isAddress, isHex, size, toFunctionSelector, } from 'viem';
+import { isAddress, isHex, padHex, size, toFunctionSelector, } from 'viem';
 function isStaticAbiType(type) {
     if (type === 'address' || type === 'bool')
         return true;
@@ -33,12 +33,53 @@ function toReferenceValue(value, abiType) {
         if (typeof value === 'string' &&
             isHex(value) &&
             size(value) === expectedSize) {
-            return value;
+            // Solidity calldata encodes bytesN (N<32) left-aligned + right-padded
+            // inside its 32-byte word, whereas address/uint*/bool are right-aligned
+            // + left-padded. Downstream `encodeActionParamRule` unconditionally
+            // left-pads with `padHex`, which is correct for the right-aligned types
+            // but wrong for bytesN. Pre-encode here to the full 32-byte hex with
+            // the correct alignment so the policy's bytes32 == bytes32 comparison
+            // matches what's actually in calldata.
+            return padHex(value, { size: 32, dir: 'right' });
         }
         throw new Error(`Expected ${expectedSize}-byte hex string for ${abiType}`);
     }
     throw new Error(`Unsupported ABI type: ${abiType}`);
 }
+// Right-fold an array of leaves into a right-leaning OR chain:
+//   [a, b, c]  →  OR(a, OR(b, c))
+// Right-leaning is fine because ArgPolicy evaluates with short-circuit; any
+// shape that uses every leaf and respects post-order produces the same result.
+function orChain(leaves) {
+    let acc = leaves[leaves.length - 1];
+    for (let i = leaves.length - 2; i >= 0; i--) {
+        acc = { type: 'or', left: leaves[i], right: acc };
+    }
+    return acc;
+}
+function andChain(leaves) {
+    let acc = leaves[leaves.length - 1];
+    for (let i = leaves.length - 2; i >= 0; i--) {
+        acc = { type: 'and', left: leaves[i], right: acc };
+    }
+    return acc;
+}
+// On-chain ERC20SpendingLimitPolicy._isTokenTransferOrApprove matches by
+// 4-byte selector, accepting only these four. Selector-gating here keeps the
+// SDK's accepted set congruent with the contract's — a same-shaped function
+// like `mint(address,uint256)` would otherwise pass argument-type checks and
+// fail every call on-chain.
+const ERC20_SPENDING_LIMIT_SELECTORS = new Set([
+    '0x095ea7b3', // approve(address,uint256)
+    '0x39509351', // increaseAllowance(address,uint256)
+    '0xa9059cbb', // transfer(address,uint256)
+    '0x23b872dd', // transferFrom(address,address,uint256)
+]);
+// Year 2100 in ms — well within uint128 after the encoder's ms→s conversion.
+// Used as the one-sided default for `validUntil` when only `validAfter` is set.
+// Exported so the cross-chain permit expansion (smart-sessions.ts) applies the
+// same always-passing upper bound instead of defaulting to 0 (already expired).
+export const FAR_FUTURE_MS = 4_102_444_800_000;
 function resolvePermission(permission) {
     const { abi, address, functions } = permission;
     const actions = [];
@@ -58,11 +99,57 @@ function resolvePermission(permission) {
         }
         const abiEntry = abiEntries[0];
         const selector = toFunctionSelector(abiEntry);
-        const policies = config.policies ? [...config.policies] : [];
-        const params = config.params ?? {};
-        const paramEntries = Object.entries(params).filter(([, v]) => v !== undefined);
+        if (Object.hasOwn(config, 'policies')) {
+            throw new Error(`Function "${fnName}": \`policies\` was removed from permission configs. ` +
+                'Use params, maxUses, validUntil/validAfter, valueLimit, or spendingLimit instead.');
+        }
+        const policies = [];
+        // --- Sugar field expansion -----------------------------------------------
+        if (config.maxUses !== undefined) {
+            policies.push({ type: 'usage-limit', limit: config.maxUses });
+        }
+        if (config.validUntil !== undefined || config.validAfter !== undefined) {
+            const validUntil = config.validUntil !== undefined
+                ? config.validUntil.getTime()
+                : FAR_FUTURE_MS;
+            const validAfter = config.validAfter !== undefined ? config.validAfter.getTime() : 0;
+            if (validUntil < validAfter) {
+                throw new Error(`Function "${fnName}": validUntil (${validUntil}) is before validAfter (${validAfter}).`);
+            }
+            policies.push({ type: 'time-frame', validUntil, validAfter });
+        }
+        if (config.valueLimit !== undefined) {
+            // Runtime backstop: payable-gating is enforced at the type level, but
+            // users can bypass with `as` casts. valueLimit on a non-payable function
+            // is harmless on-chain (msg.value is always 0, the cap always passes)
+            // but it leaks intent — throw rather than encode dead weight.
+            if (abiEntry.stateMutability !== 'payable') {
+                throw new Error(`Function "${fnName}" is not payable — \`valueLimit\` only constrains native ETH ` +
+                    'attached to the call, which is always zero for non-payable functions. ' +
+                    'Remove `valueLimit`.');
+            }
+            policies.push({ type: 'value-limit', limit: config.valueLimit });
+        }
+        if (config.spendingLimit !== undefined) {
+            // Runtime backstop: type-level gate restricts shape, but ERC20SpendingLimitPolicy
+            // dispatches by selector on-chain — a same-shaped function like
+            // mint(address,uint256) would encode successfully and fail every call.
+            if (!ERC20_SPENDING_LIMIT_SELECTORS.has(selector)) {
+                throw new Error(`Function "${fnName}" (selector ${selector}) is not an ERC-20 transfer/approve ` +
+                    'selector; `spendingLimit` only works on approve, increaseAllowance, ' +
+                    'transfer, or transferFrom. The on-chain policy dispatches by selector ' +
+                    'and would fail every call for other functions.');
+            }
+            policies.push({
+                type: 'spending-limits',
+                limits: [config.spendingLimit],
+            });
+        }
+        // --- End sugar field expansion -------------------------------------------
+        const rawParams = config.params ?? {};
+        const paramEntries = Object.entries(rawParams).filter(([, v]) => v !== undefined);
         if (paramEntries.length > 0) {
-            const rules = paramEntries.map(([paramName, rule]) => {
+            const normalized = paramEntries.map(([paramName, rule]) => {
                 const paramIndex = abiEntry.inputs.findIndex((p) => p.name === paramName);
                 if (paramIndex === -1) {
                     throw new Error(`Parameter "${paramName}" not found in function "${fnName}". ` +
@@ -75,21 +162,79 @@ function resolvePermission(permission) {
                         '(address, bool, uint*, int*, bytes1–bytes32).');
                 }
                 const calldataOffset = BigInt(paramIndex) * 32n;
-                const referenceValue = toReferenceValue(rule.value, param.type);
+                if (rule.anyOf !== undefined) {
+                    if (rule.anyOf.length === 0) {
+                        throw new Error(`Parameter "${paramName}" has empty anyOf — provide at least one value.`);
+                    }
+                    return {
+                        paramName,
+                        calldataOffset,
+                        abiType: param.type,
+                        anyOf: rule.anyOf,
+                    };
+                }
                 return {
-                    condition: rule.condition,
+                    paramName,
                     calldataOffset,
-                    referenceValue,
-                    ...(rule.usageLimit !== undefined
-                        ? { usageLimit: rule.usageLimit }
-                        : {}),
+                    abiType: param.type,
+                    condition: rule.condition,
+                    value: rule.value,
+                    usageLimit: rule.usageLimit,
                 };
             });
-            policies.push({
-                type: 'universal-action',
-                valueLimitPerUse: config.valueLimitPerUse ?? 0n,
-                rules: rules,
-            });
+            const usesArgPolicy = normalized.some((n) => n.anyOf !== undefined);
+            // UniActionPolicy/ArgPolicy reject `msg.value > valueLimitPerUse`, so a
+            // default of 0 would block any non-zero msg.value before the standalone
+            // value-limit policy (sugar) could allow it. Inherit the sugar's cap so
+            // the per-use gate matches user intent; value-limit still enforces the
+            // cumulative cap on top.
+            const embeddedValueLimit = config.valueLimitPerUse ?? config.valueLimit ?? 0n;
+            if (usesArgPolicy) {
+                // One sub-expression per param, then AND across params.
+                const perParam = normalized.map((n) => {
+                    if (n.anyOf !== undefined) {
+                        const leaves = n.anyOf.map((v) => ({
+                            type: 'rule',
+                            rule: {
+                                condition: 'equal',
+                                calldataOffset: n.calldataOffset,
+                                referenceValue: toReferenceValue(v, n.abiType),
+                            },
+                        }));
+                        return leaves.length === 1 ? leaves[0] : orChain(leaves);
+                    }
+                    return {
+                        type: 'rule',
+                        rule: {
+                            condition: n.condition,
+                            calldataOffset: n.calldataOffset,
+                            referenceValue: toReferenceValue(n.value, n.abiType),
+                            ...(n.usageLimit !== undefined
+                                ? { usageLimit: n.usageLimit }
+                                : {}),
+                        },
+                    };
+                });
+                policies.push({
+                    type: 'arg-policy',
+                    valueLimitPerUse: embeddedValueLimit,
+                    expression: perParam.length === 1 ? perParam[0] : andChain(perParam),
+                });
+            }
+            else {
+                // Flat AND-of-rules — cheaper to init via UniActionPolicy.
+                const rules = normalized.map((n) => ({
+                    condition: n.condition,
+                    calldataOffset: n.calldataOffset,
+                    referenceValue: toReferenceValue(n.value, n.abiType),
+                    ...(n.usageLimit !== undefined ? { usageLimit: n.usageLimit } : {}),
+                }));
+                policies.push({
+                    type: 'universal-action',
+                    valueLimitPerUse: embeddedValueLimit,
+                    rules: rules,
+                });
+            }
         }
         else if (config.valueLimitPerUse !== undefined) {
             policies.push({
@@ -105,7 +250,36 @@ function resolvePermission(permission) {
     }
     return actions;
 }
+// Error-path only: recover the function name behind a selector for the
+// duplicate-permission message.
+function findFunctionName(permission, selector) {
+    return Object.keys(permission.functions).find((name) => {
+        const entry = permission.abi.find((e) => e.type === 'function' &&
+            e.name === name);
+        return entry !== undefined && toFunctionSelector(entry) === selector;
+    });
+}
 function resolvePermissions(permissions) {
-    return permissions.flatMap(resolvePermission);
+    // On-chain, actions are keyed by keccak(target, selector): two permission
+    // entries for the same function on the same contract share one actionId,
+    // and the later entry's `initializeWithMultiplexer` silently overwrites the
+    // earlier one's policy config. Reject at build time instead of letting the
+    // collision surface as an opaque InvalidSignature() at execution.
+    const seen = new Set();
+    return permissions.flatMap((permission) => {
+        const actions = resolvePermission(permission);
+        for (const action of actions) {
+            const key = `${action.target.toLowerCase()}:${action.selector.toLowerCase()}`;
+            if (seen.has(key)) {
+                const fnName = findFunctionName(permission, action.selector);
+                throw new Error(`Duplicate permission for function "${fnName}" (selector ${action.selector}) ` +
+                    `on ${action.target}: permission entries for the same function on the same ` +
+                    "contract share one on-chain action, so the later entry's policies would " +
+                    'silently overwrite the earlier ones. Merge them into a single entry.');
+            }
+            seen.add(key);
+        }
+        return actions;
+    });
 }
 export { resolvePermissions, resolvePermission };

package/dist/src/modules/validators/policies/claim/arbiters.d.ts

@@ -0,0 +1,22 @@
+import type { Address } from 'viem';
+import type { CrossChainSettlementLayer } from '../../../../types.js';
+/**
+ * Collects every distinct arbiter address that any chain in the registry
+ * has deployed for the given settlement layers. The resulting whitelist
+ * is what the Permit2 claim policy enforces on-chain — a session signed
+ * once with this whitelist is valid against any of those arbiters.
+ *
+ * **"Any" means any of the *supported* settlement layers**, not any
+ * address on earth. When `layers` is empty or undefined, this resolver
+ * expands to the union of every layer in
+ * {@link SETTLEMENT_LAYER_CONTRACT_KEYS}, so the on-chain arbiter check
+ * stays meaningful (the worst case is still a Rhinestone-blessed
+ * arbiter). To get a truly unrestricted whitelist a caller would have
+ * to bypass this helper entirely.
+ *
+ * @param layers   Settlement layers the session is permitted to use.
+ *                 Empty/undefined ⇒ all supported layers.
+ * @param useDevContracts  Pull from the dev address book instead of mainnet.
+ */
+export declare function getArbitersForSettlementLayers(layers: readonly CrossChainSettlementLayer[] | undefined, useDevContracts?: boolean): Address[] | undefined;
+//# sourceMappingURL=arbiters.d.ts.map

package/dist/src/modules/validators/policies/claim/arbiters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arbiters.d.ts","sourceRoot":"","sources":["../../../../../../modules/validators/policies/claim/arbiters.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAiBlE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,SAAS,yBAAyB,EAAE,GAAG,SAAS,EACxD,eAAe,CAAC,EAAE,OAAO,GACxB,OAAO,EAAE,GAAG,SAAS,CA8BvB"}

package/dist/src/modules/validators/policies/claim/arbiters.js

@@ -0,0 +1,57 @@
+import { contractAddresses, contractAddressesDev, } from '@rhinestone/shared-configs';
+/**
+ * The contract registry keys (per `shared-configs/contracts.{,dev}.js`)
+ * that each settlement layer expands to. `ACROSS` whitelists both arbiter
+ * impls so a session is permissioned for the 7579 and multicall paths
+ * regardless of which one the orchestrator picks at intent time.
+ */
+const SETTLEMENT_LAYER_CONTRACT_KEYS = {
+    SAME_CHAIN: ['samechainArbiter'],
+    ECO: ['ecoArbiter'],
+    ACROSS: ['across7579Arbiter', 'acrossMulticallArbiter'],
+};
+/**
+ * Collects every distinct arbiter address that any chain in the registry
+ * has deployed for the given settlement layers. The resulting whitelist
+ * is what the Permit2 claim policy enforces on-chain — a session signed
+ * once with this whitelist is valid against any of those arbiters.
+ *
+ * **"Any" means any of the *supported* settlement layers**, not any
+ * address on earth. When `layers` is empty or undefined, this resolver
+ * expands to the union of every layer in
+ * {@link SETTLEMENT_LAYER_CONTRACT_KEYS}, so the on-chain arbiter check
+ * stays meaningful (the worst case is still a Rhinestone-blessed
+ * arbiter). To get a truly unrestricted whitelist a caller would have
+ * to bypass this helper entirely.
+ *
+ * @param layers   Settlement layers the session is permitted to use.
+ *                 Empty/undefined ⇒ all supported layers.
+ * @param useDevContracts  Pull from the dev address book instead of mainnet.
+ */
+export function getArbitersForSettlementLayers(layers, useDevContracts) {
+    const effectiveLayers = !layers || layers.length === 0
+        ? Object.keys(SETTLEMENT_LAYER_CONTRACT_KEYS)
+        : layers;
+    const registry = useDevContracts ? contractAddressesDev : contractAddresses;
+    const keys = effectiveLayers.flatMap((l) => SETTLEMENT_LAYER_CONTRACT_KEYS[l]);
+    const seen = new Set();
+    const addresses = [];
+    // shared-configs is shaped Record<chainId, Record<contractKey, Address>>.
+    // The same logical arbiter often shares an address across chains, but a
+    // given key may also have multiple addresses live in the wild (e.g.
+    // post-redeploy). We collect every unique address we see for the keys
+    // the caller asked for, deduplicated case-insensitively.
+    for (const chainContracts of Object.values(registry)) {
+        for (const key of keys) {
+            const addr = chainContracts[key];
+            if (!addr)
+                continue;
+            const norm = addr.toLowerCase();
+            if (seen.has(norm))
+                continue;
+            seen.add(norm);
+            addresses.push(addr);
+        }
+    }
+    return addresses.length ? addresses : undefined;
+}