@rhinestone/sdk 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/src/modules/validators/smart-sessions.js

@@ -68,12 +68,13 @@ const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSIO
 // intentionally uncommon.
 const DUMMY_PRECLAIMOP_TARGET = '0x0000000000000000000000000000000000000420';
 const DUMMY_PRECLAIMOP_SELECTOR = '0x69123456';
-const SPENDING_LIMITS_POLICY_ADDRESS = '0x00000088d48cf102a8cdb0137a9b173f957c6343';
-const TIME_FRAME_POLICY_ADDRESS = '0x8177451511de0577b911c254e9551d981c26dc72';
-const SUDO_POLICY_ADDRESS = '0x0000003111cd8e92337c100f22b7a9dbf8dee301';
-const UNIVERSAL_ACTION_POLICY_ADDRESS = '0x0000006dda6c463511c4e9b05cfc34c1247fcf1f';
-const USAGE_LIMIT_POLICY_ADDRESS = '0x1f34ef8311345a3a4a4566af321b313052f51493';
-const VALUE_LIMIT_POLICY_ADDRESS = '0x730da93267e7e513e932301b47f2ac7d062abc83';
+const SPENDING_LIMITS_POLICY_ADDRESS = '0x000000000033212E272655D8a22402Db819477A6';
+const TIME_FRAME_POLICY_ADDRESS = '0x0000000000D30f611fA3bf652ac6879428586930';
+const SUDO_POLICY_ADDRESS = '0x0000000000FEEc8D74e3143fBaBbca515358d869';
+const UNIVERSAL_ACTION_POLICY_ADDRESS = '0x0000000000714Cf48FcF88A0bFBa70d313415032';
+const ARG_POLICY_ADDRESS = '0x0000000000167edE64D8751daACDdC0312565a73';
+const USAGE_LIMIT_POLICY_ADDRESS = '0x00000000001d4479FA2A947026204d0283ceDe4B';
+const VALUE_LIMIT_POLICY_ADDRESS = '0x000000000021dC45451291BCDfc9f0B46d6f0278';
 const INTENT_EXECUTION_POLICY_ADDRESS = '0xe9eA54d063975cDee9e06b7636d5563d95a7A23C';
 const INTENT_EXECUTION_POLICY_ADDRESS_DEV = '0xa09b47de6e510cbdc18b97e9239bedcb44fb4901';
 const ACTION_CONDITION_EQUAL = 0;
@@ -83,6 +84,44 @@ const ACTION_CONDITION_GREATER_THAN_OR_EQUAL = 3;
 const ACTION_CONDITION_LESS_THAN_OR_EQUAL = 4;
 const ACTION_CONDITION_NOT_EQUAL = 5;
 const ACTION_CONDITION_IN_RANGE = 6;
+// ArgPolicy expression-tree node packing — must match ArgPolicyTreeLib.sol:
+//   bits  0..1  : node type (0=rule, 1=NOT, 2=AND, 3=OR)
+//   bits  2..9  : rule index (rule nodes only)
+//   bits 10..17 : left/only child index
+//   bits 18..25 : right child index (AND/OR only)
+const ARG_NODE_TYPE_RULE = 0n;
+const ARG_NODE_TYPE_NOT = 1n;
+const ARG_NODE_TYPE_AND = 2n;
+const ARG_NODE_TYPE_OR = 3n;
+const ARG_RULE_INDEX_SHIFT = 2n;
+const ARG_LEFT_CHILD_SHIFT = 10n;
+const ARG_RIGHT_CHILD_SHIFT = 18n;
+// On-chain caps from ArgPolicyTreeLib.sol; fail early instead of letting
+// the deployment revert with `TooManyRules` / `TooManyNodes`.
+const ARG_MAX_RULES = 128;
+const ARG_MAX_NODES = 256;
+const DEFAULT_POLICY_ADDRESSES = {
+    sudo: SUDO_POLICY_ADDRESS,
+    universalAction: UNIVERSAL_ACTION_POLICY_ADDRESS,
+    argPolicy: ARG_POLICY_ADDRESS,
+    spendingLimits: SPENDING_LIMITS_POLICY_ADDRESS,
+    timeFrame: TIME_FRAME_POLICY_ADDRESS,
+    usageLimit: USAGE_LIMIT_POLICY_ADDRESS,
+    valueLimit: VALUE_LIMIT_POLICY_ADDRESS,
+};
+function resolvePolicyAddresses(overrides) {
+    if (!overrides)
+        return DEFAULT_POLICY_ADDRESSES;
+    return {
+        sudo: overrides.sudo ?? DEFAULT_POLICY_ADDRESSES.sudo,
+        universalAction: overrides.universalAction ?? DEFAULT_POLICY_ADDRESSES.universalAction,
+        argPolicy: overrides.argPolicy ?? DEFAULT_POLICY_ADDRESSES.argPolicy,
+        spendingLimits: overrides.spendingLimits ?? DEFAULT_POLICY_ADDRESSES.spendingLimits,
+        timeFrame: overrides.timeFrame ?? DEFAULT_POLICY_ADDRESSES.timeFrame,
+        usageLimit: overrides.usageLimit ?? DEFAULT_POLICY_ADDRESSES.usageLimit,
+        valueLimit: overrides.valueLimit ?? DEFAULT_POLICY_ADDRESSES.valueLimit,
+    };
+}
 function packSignature(signers, validatorSignature) {
     const session = signers.session;
     const permissionId = getPermissionId(session);
@@ -390,7 +429,8 @@ async function getEnableSessionCall(account, session, enableSessionSignature, ha
     };
 }
 function toSession(definition, options = {}) {
-    const sessionData = resolveSessionData(definition, options.useDevContracts);
+    const addresses = resolvePolicyAddresses(definition.policyAddresses);
+    const sessionData = resolveSessionData(definition, options.useDevContracts, addresses);
     return {
         chain: definition.chain,
         owners: definition.owners,
@@ -429,7 +469,7 @@ function resolvePermit2ClaimPolicy(policy) {
         })),
     };
 }
-function resolveSessionData(session, useDevContracts) {
+function resolveSessionData(session, useDevContracts, addresses = DEFAULT_POLICY_ADDRESSES) {
     const validator = getValidator(session.owners);
     const allowedContent = [
         {
@@ -441,7 +481,7 @@ function resolveSessionData(session, useDevContracts) {
         allowedERC7739Content: allowedContent,
         erc1271Policies: [
             {
-                policy: SUDO_POLICY_ADDRESS,
+                policy: addresses.sudo,
                 initData: '0x',
             },
         ],
@@ -451,7 +491,7 @@ function resolveSessionData(session, useDevContracts) {
         actionTarget: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
         actionPolicies: [
             {
-                policy: SUDO_POLICY_ADDRESS,
+                policy: addresses.sudo,
                 initData: '0x',
             },
         ],
@@ -491,9 +531,9 @@ function resolveSessionData(session, useDevContracts) {
             actionTarget: 'target' in action
                 ? action.target
                 : SMART_SESSIONS_FALLBACK_TARGET_FLAG,
-            actionPolicies: action.policies?.map((policy) => getPolicyData(policy, useDevContracts)) ?? [
+            actionPolicies: action.policies?.map((policy) => getPolicyData(policy, useDevContracts, addresses)) ?? [
                 {
-                    policy: SUDO_POLICY_ADDRESS,
+                    policy: addresses.sudo,
                     initData: '0x',
                 },
             ],
@@ -547,11 +587,88 @@ function getPermissionIdFromData(sessionData) {
         sessionData.salt,
     ]));
 }
-function getPolicyData(policy, useDevContracts) {
+function getActionConditionId(condition) {
+    switch (condition) {
+        case 'equal':
+            return ACTION_CONDITION_EQUAL;
+        case 'greaterThan':
+            return ACTION_CONDITION_GREATER_THAN;
+        case 'lessThan':
+            return ACTION_CONDITION_LESS_THAN;
+        case 'greaterThanOrEqual':
+            return ACTION_CONDITION_GREATER_THAN_OR_EQUAL;
+        case 'lessThanOrEqual':
+            return ACTION_CONDITION_LESS_THAN_OR_EQUAL;
+        case 'notEqual':
+            return ACTION_CONDITION_NOT_EQUAL;
+        case 'inRange':
+            return ACTION_CONDITION_IN_RANGE;
+    }
+}
+function encodeActionParamRule(rule) {
+    const ref = isHex(rule.referenceValue)
+        ? padHex(rule.referenceValue)
+        : toHex(rule.referenceValue, { size: 32 });
+    return {
+        condition: getActionConditionId(rule.condition),
+        offset: rule.calldataOffset,
+        isLimited: rule.usageLimit !== undefined,
+        ref,
+        usage: {
+            limit: rule.usageLimit ?? 0n,
+            used: 0n,
+        },
+    };
+}
+// Compile an ArgPolicyExpression AST into the on-chain wire format
+// (flat rules[] + bit-packed nodes[] + rootNodeIndex). Post-order walk:
+// children get appended before their parent so a parent's child indices
+// always reference earlier slots.
+function compileArgPolicyExpression(expr) {
+    const rules = [];
+    const nodes = [];
+    function walk(e) {
+        switch (e.type) {
+            case 'rule': {
+                const ruleIdx = rules.length;
+                rules.push(encodeActionParamRule(e.rule));
+                const nodeIdx = nodes.length;
+                nodes.push(ARG_NODE_TYPE_RULE | (BigInt(ruleIdx) << ARG_RULE_INDEX_SHIFT));
+                return nodeIdx;
+            }
+            case 'not': {
+                const childIdx = walk(e.child);
+                const nodeIdx = nodes.length;
+                nodes.push(ARG_NODE_TYPE_NOT | (BigInt(childIdx) << ARG_LEFT_CHILD_SHIFT));
+                return nodeIdx;
+            }
+            case 'and':
+            case 'or': {
+                const leftIdx = walk(e.left);
+                const rightIdx = walk(e.right);
+                const nodeIdx = nodes.length;
+                const nodeType = e.type === 'and' ? ARG_NODE_TYPE_AND : ARG_NODE_TYPE_OR;
+                nodes.push(nodeType |
+                    (BigInt(leftIdx) << ARG_LEFT_CHILD_SHIFT) |
+                    (BigInt(rightIdx) << ARG_RIGHT_CHILD_SHIFT));
+                return nodeIdx;
+            }
+        }
+    }
+    const rootNodeIndex = walk(expr);
+    if (rules.length > ARG_MAX_RULES) {
+        throw new Error(`ArgPolicy expression has ${rules.length} rules, max is ${ARG_MAX_RULES}`);
+    }
+    if (nodes.length > ARG_MAX_NODES) {
+        throw new Error(`ArgPolicy expression has ${nodes.length} nodes, max is ${ARG_MAX_NODES}`);
+    }
+    return { rules, packedNodes: nodes, rootNodeIndex };
+}
+function getPolicyData(policy, useDevContracts, addresses = DEFAULT_POLICY_ADDRESSES) {
     switch (policy.type) {
         case 'sudo':
             return {
-                policy: SUDO_POLICY_ADDRESS,
+                policy: addresses.sudo,
                 initData: '0x',
             };
         case 'intent-execution':
@@ -562,24 +679,6 @@ function getPolicyData(policy, useDevContracts) {
                 initData: '0x',
             };
         case 'universal-action': {
-            function getCondition(condition) {
-                switch (condition) {
-                    case 'equal':
-                        return ACTION_CONDITION_EQUAL;
-                    case 'greaterThan':
-                        return ACTION_CONDITION_GREATER_THAN;
-                    case 'lessThan':
-                        return ACTION_CONDITION_LESS_THAN;
-                    case 'greaterThanOrEqual':
-                        return ACTION_CONDITION_GREATER_THAN_OR_EQUAL;
-                    case 'lessThanOrEqual':
-                        return ACTION_CONDITION_LESS_THAN_OR_EQUAL;
-                    case 'notEqual':
-                        return ACTION_CONDITION_NOT_EQUAL;
-                    case 'inRange':
-                        return ACTION_CONDITION_IN_RANGE;
-                }
-            }
             const MAX_RULES = 16;
             const rules = createFixedArray(MAX_RULES, () => ({
                 condition: ACTION_CONDITION_EQUAL,
@@ -589,23 +688,10 @@ function getPolicyData(policy, useDevContracts) {
                 usage: { limit: 0n, used: 0n },
             }));
             for (let i = 0; i < policy.rules.length; i++) {
-                const rule = policy.rules[i];
-                const ref = isHex(rule.referenceValue)
-                    ? padHex(rule.referenceValue)
-                    : toHex(rule.referenceValue, { size: 32 });
-                rules[i] = {
-                    condition: getCondition(rule.condition),
-                    offset: rule.calldataOffset,
-                    isLimited: rule.usageLimit !== undefined,
-                    ref,
-                    usage: {
-                        limit: rule.usageLimit ? rule.usageLimit : 0n,
-                        used: 0n,
-                    },
-                };
+                rules[i] = encodeActionParamRule(policy.rules[i]);
             }
             return {
-                policy: UNIVERSAL_ACTION_POLICY_ADDRESS,
+                policy: addresses.universalAction,
                 initData: encodeAbiParameters([
                     {
                         components: [
@@ -674,17 +760,69 @@ function getPolicyData(policy, useDevContracts) {
                 ]),
             };
         }
+        case 'arg-policy': {
+            const { rules, packedNodes, rootNodeIndex } = compileArgPolicyExpression(policy.expression);
+            return {
+                policy: addresses.argPolicy,
+                initData: encodeAbiParameters([
+                    {
+                        components: [
+                            { name: 'valueLimitPerUse', type: 'uint256' },
+                            {
+                                components: [
+                                    { name: 'rootNodeIndex', type: 'uint8' },
+                                    {
+                                        components: [
+                                            { name: 'condition', type: 'uint8' },
+                                            { name: 'offset', type: 'uint64' },
+                                            { name: 'isLimited', type: 'bool' },
+                                            { name: 'ref', type: 'bytes32' },
+                                            {
+                                                components: [
+                                                    { name: 'limit', type: 'uint256' },
+                                                    { name: 'used', type: 'uint256' },
+                                                ],
+                                                name: 'usage',
+                                                type: 'tuple',
+                                            },
+                                        ],
+                                        name: 'rules',
+                                        type: 'tuple[]',
+                                    },
+                                    { name: 'packedNodes', type: 'uint256[]' },
+                                ],
+                                name: 'paramRules',
+                                type: 'tuple',
+                            },
+                        ],
+                        name: 'ActionConfig',
+                        type: 'tuple',
+                    },
+                ], [
+                    {
+                        valueLimitPerUse: policy.valueLimitPerUse ?? 0n,
+                        paramRules: {
+                            rootNodeIndex,
+                            rules,
+                            packedNodes,
+                        },
+                    },
+                ]),
+            };
+        }
         case 'spending-limits': {
             const tokens = policy.limits.map(({ token }) => token);
             const limits = policy.limits.map(({ amount }) => amount);
             return {
-                policy: SPENDING_LIMITS_POLICY_ADDRESS,
+                policy: addresses.spendingLimits,
                 initData: encodeAbiParameters([{ type: 'address[]' }, { type: 'uint256[]' }], [tokens, limits]),
             };
         }
         case 'time-frame': {
+            // Deployed TimeFramePolicy slices initData[0:12] and unpacks as
+            // uint48 validUntil || uint48 validAfter (high 48 bits || low 48 bits).
             return {
-                policy: TIME_FRAME_POLICY_ADDRESS,
+                policy: addresses.timeFrame,
                 initData: encodePacked(['uint48', 'uint48'], [
                     Math.floor(policy.validUntil / 1000),
                     Math.floor(policy.validAfter / 1000),
@@ -693,13 +831,13 @@ function getPolicyData(policy, useDevContracts) {
         }
         case 'usage-limit': {
             return {
-                policy: USAGE_LIMIT_POLICY_ADDRESS,
+                policy: addresses.usageLimit,
                 initData: encodePacked(['uint128'], [policy.limit]),
             };
         }
         case 'value-limit': {
             return {
-                policy: VALUE_LIMIT_POLICY_ADDRESS,
+                policy: addresses.valueLimit,
                 initData: encodeAbiParameters([{ type: 'uint256' }], [policy.limit]),
             };
         }
@@ -726,41 +864,47 @@ function getSmartSessionEmissaryAddress(useDevContracts) {
         ? SMART_SESSION_EMISSARY_ADDRESS_DEV
         : SMART_SESSION_EMISSARY_ADDRESS;
 }
-/**
- * Builds a mockSignature for SSX validation gas estimation.
- * Format: emissaryAddress (20 bytes) + enable-mode sigData.
- * Uses real session data (policies/actions from the user's session config) with dummy
- * sigs and hashes — the mock emissary skips sig verification and only writes storage.
- * The orchestrator slices off the first 20 bytes to identify the validator, then
- * simulates verifyExecution with the mock emissary to estimate gas before the user signs.
- */
-function buildMockSignature(session, useDevContracts, chainCount = 1, targetChainId) {
+function buildMockSignature(session, useDevContracts, chainCount = 1, targetChainId, 
+// Defaults to the historical first-use ENABLE shape.
+shape = 'enable') {
+    // packSignature keys ENABLE vs USE on enableData *presence* within the
+    // verifyExecutions branch, and takes the ERC-1271 branch when verifyExecutions
+    // is false — so derive both from the requested shape.
+    const verifyExecutions = shape !== 'erc1271';
+    const includeEnableData = shape === 'enable';
     const emissaryAddress = getSmartSessionEmissaryAddress(useDevContracts);
-    // Use targetChainId when provided (per-chain mockSignatures path) so the
-    // mock emissary's chainId check passes on the correct chain. Falls back to
-    // session.chain.id for the global mockSignature (single-chain path).
-    const primaryChainId = targetChainId ?? session.chain.id;
-    // Normalize chainCount to a finite positive integer. Guards against
-    // accidental NaN/undefined from caller (e.g. `sourceChains?.length` when
-    // sourceChains is undefined) which would otherwise make Array.from produce
-    // an empty array and silently drop the ChainId check.
-    const safeChainCount = Number.isFinite(chainCount) && chainCount > 0 ? Math.floor(chainCount) : 1;
-    // Build one entry per chain — first entry is the real chain ID (for the ChainId check),
-    // remaining entries use chainId 0 as placeholders. Hash mismatch is skipped by the
-    // mock emissary, so sessionDigest can be zeroHash throughout.
-    const hashesAndChainIds = Array.from({ length: safeChainCount }, (_, i) => ({
-        chainId: i === 0 ? BigInt(primaryChainId) : 0n,
-        sessionDigest: zeroHash,
-    }));
-    const dummySigners = {
-        type: 'experimental_session',
-        session,
-        verifyExecutions: true,
-        enableData: {
+    // Include enableData only when the session is actually being enabled (ENABLE
+    // shape) — its presence is what makes packSignature emit 0x01 vs 0x00, and it's
+    // ignored entirely by the USE / ERC-1271 shapes. Built lazily so steady-state
+    // shapes skip the chainId-entry allocation.
+    let enableData;
+    if (includeEnableData) {
+        // Use targetChainId when provided (per-chain mockSignatures path) so the mock
+        // emissary's chainId check passes on the correct chain. Falls back to
+        // session.chain.id for the global mockSignature (single-chain path).
+        const primaryChainId = targetChainId ?? session.chain.id;
+        // Normalize chainCount to a finite positive integer — guards against NaN/
+        // undefined from callers (e.g. `sourceChains?.length`) that would otherwise
+        // produce an empty array and silently drop the ChainId check.
+        const safeChainCount = Number.isFinite(chainCount) && chainCount > 0 ? Math.floor(chainCount) : 1;
+        // First entry is the real chain ID (for the ChainId check), the rest are
+        // chainId 0 placeholders. Hash mismatch is skipped by the mock emissary, so
+        // sessionDigest can be zeroHash throughout.
+        const hashesAndChainIds = Array.from({ length: safeChainCount }, (_, i) => ({
+            chainId: i === 0 ? BigInt(primaryChainId) : 0n,
+            sessionDigest: zeroHash,
+        }));
+        enableData = {
             userSignature: `0x${'00'.repeat(65)}`,
             hashesAndChainIds,
             sessionToEnableIndex: 0,
-        },
+        };
+    }
+    const dummySigners = {
+        type: 'experimental_session',
+        session,
+        verifyExecutions,
+        ...(enableData && { enableData }),
     };
     const dummyValidatorSignature = `0x${'00'.repeat(65)}`;
     const sigData = packSignature(dummySigners, dummyValidatorSignature);
@@ -769,4 +913,4 @@ function buildMockSignature(session, useDevContracts, chainCount = 1, targetChai
 function createFixedArray(length, getValue) {
     return Array.from({ length }, (_, i) => getValue(i));
 }
-export { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, SMART_SESSIONS_FALLBACK_TARGET_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION, DUMMY_PRECLAIMOP_TARGET, DUMMY_PRECLAIMOP_SELECTOR, SPENDING_LIMITS_POLICY_ADDRESS, TIME_FRAME_POLICY_ADDRESS, SUDO_POLICY_ADDRESS, UNIVERSAL_ACTION_POLICY_ADDRESS, USAGE_LIMIT_POLICY_ADDRESS, VALUE_LIMIT_POLICY_ADDRESS, INTENT_EXECUTION_POLICY_ADDRESS, packSignature, toSession, resolvePermit2ClaimPolicy, getSessionData, getPolicyData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, isSessionEnabled, signEnableSession, buildMockSignature, };
+export { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, SMART_SESSIONS_FALLBACK_TARGET_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION, DUMMY_PRECLAIMOP_TARGET, DUMMY_PRECLAIMOP_SELECTOR, SPENDING_LIMITS_POLICY_ADDRESS, TIME_FRAME_POLICY_ADDRESS, SUDO_POLICY_ADDRESS, UNIVERSAL_ACTION_POLICY_ADDRESS, ARG_POLICY_ADDRESS, USAGE_LIMIT_POLICY_ADDRESS, VALUE_LIMIT_POLICY_ADDRESS, INTENT_EXECUTION_POLICY_ADDRESS, packSignature, toSession, resolvePermit2ClaimPolicy, getSessionData, getPolicyData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, isSessionEnabled, signEnableSession, buildMockSignature, };

package/dist/src/orchestrator/caip2.d.ts

@@ -1,7 +1,13 @@
-type Caip2ChainId = `eip155:${number}`;
+type EvmCaip2ChainId = `eip155:${number}`;
+type SolanaCaip2ChainId = `solana:${string}`;
+type TronCaip2ChainId = `tron:${string}`;
+type Caip2ChainId = EvmCaip2ChainId | SolanaCaip2ChainId | TronCaip2ChainId;
 declare function toCaip2(chainId: number): Caip2ChainId;
 declare function fromCaip2(chainId: string): number;
 declare function isCaip2(chainId: string): chainId is Caip2ChainId;
-export type { Caip2ChainId };
-export { fromCaip2, isCaip2, toCaip2 };
+declare function isEvmCaip2(chainId: string): chainId is EvmCaip2ChainId;
+/** True when a numeric chain id corresponds to a known non-eip155 namespace. */
+declare function isNonEvmChainId(chainId: number): boolean;
+export type { Caip2ChainId, EvmCaip2ChainId, SolanaCaip2ChainId, TronCaip2ChainId, };
+export { fromCaip2, isCaip2, isEvmCaip2, isNonEvmChainId, toCaip2 };
 //# sourceMappingURL=caip2.d.ts.map

package/dist/src/orchestrator/caip2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"caip2.d.ts","sourceRoot":"","sources":["../../../orchestrator/caip2.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,GAAG,UAAU,MAAM,EAAE,CAAA;AAItC,iBAAS,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAK9C;AAED,iBAAS,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAK1C;AAED,iBAAS,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,YAAY,CAEzD;AAED,YAAY,EAAE,YAAY,EAAE,CAAA;AAC5B,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,CAAA"}
+{"version":3,"file":"caip2.d.ts","sourceRoot":"","sources":["../../../orchestrator/caip2.ts"],"names":[],"mappings":"AAOA,KAAK,eAAe,GAAG,UAAU,MAAM,EAAE,CAAA;AACzC,KAAK,kBAAkB,GAAG,UAAU,MAAM,EAAE,CAAA;AAC5C,KAAK,gBAAgB,GAAG,QAAQ,MAAM,EAAE,CAAA;AACxC,KAAK,YAAY,GAAG,eAAe,GAAG,kBAAkB,GAAG,gBAAgB,CAAA;AAmB3E,iBAAS,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAO9C;AAED,iBAAS,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAS1C;AAED,iBAAS,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,YAAY,CAGzD;AAED,iBAAS,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,eAAe,CAE/D;AAED,gFAAgF;AAChF,iBAAS,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,YAAY,EACV,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,gBAAgB,GACjB,CAAA;AACD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,OAAO,EAAE,CAAA"}

package/dist/src/orchestrator/caip2.js

@@ -1,17 +1,52 @@
+// CAIP-2 wire format. Mirrors the orchestrator's caip2.ts namespace registry
+// — Solana / Tron synthetic numeric ids round-trip through the same CAIP-2
+// strings the orchestrator emits, so the SDK and orchestrator agree on the
+// wire shape without needing the user to think about CAIP-2 themselves.
+//
+// Spec: https://chainagnostic.org/CAIPs/caip-2
 const EIP155_CAIP2_REGEX = /^eip155:\d+$/;
+const NON_EIP155_CAIP2_REGEX = /^(?:solana|tron):[-_a-zA-Z0-9]{1,32}$/;
+// Synthetic numeric ids ↔ CAIP-2 strings for non-eip155 chains. Must match
+// the orchestrator's NON_EIP155_CAIP2_TO_ID exactly — these flow over the
+// wire and any drift would cause routing failures.
+const NON_EIP155_ID_TO_CAIP2 = {
+    792703809: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+    728126428: 'tron:0x2b6653dc',
+};
+const NON_EIP155_CAIP2_TO_ID = Object.fromEntries(Object.entries(NON_EIP155_ID_TO_CAIP2).map(([id, caip2]) => [
+    caip2,
+    Number(id),
+]));
 function toCaip2(chainId) {
     if (!Number.isInteger(chainId) || chainId < 0) {
-        throw new Error(`Invalid EVM chain id: ${chainId}`);
+        throw new Error(`Invalid chain id: ${chainId}`);
     }
+    const nonEvm = NON_EIP155_ID_TO_CAIP2[chainId];
+    if (nonEvm)
+        return nonEvm;
     return `eip155:${chainId}`;
 }
 function fromCaip2(chainId) {
-    if (!EIP155_CAIP2_REGEX.test(chainId)) {
-        throw new Error(`Invalid CAIP-2 chain id: ${chainId}`);
+    if (EIP155_CAIP2_REGEX.test(chainId)) {
+        return Number(chainId.slice('eip155:'.length));
     }
-    return Number(chainId.slice('eip155:'.length));
+    if (NON_EIP155_CAIP2_REGEX.test(chainId)) {
+        const id = NON_EIP155_CAIP2_TO_ID[chainId];
+        if (id !== undefined)
+            return id;
+    }
+    throw new Error(`Invalid CAIP-2 chain id: ${chainId}`);
 }
 function isCaip2(chainId) {
+    if (EIP155_CAIP2_REGEX.test(chainId))
+        return true;
+    return chainId in NON_EIP155_CAIP2_TO_ID;
+}
+function isEvmCaip2(chainId) {
     return EIP155_CAIP2_REGEX.test(chainId);
 }
-export { fromCaip2, isCaip2, toCaip2 };
+/** True when a numeric chain id corresponds to a known non-eip155 namespace. */
+function isNonEvmChainId(chainId) {
+    return chainId in NON_EIP155_ID_TO_CAIP2;
+}
+export { fromCaip2, isCaip2, isEvmCaip2, isNonEvmChainId, toCaip2 };

package/dist/src/orchestrator/client.d.ts

@@ -1,6 +1,6 @@
 import type { Address } from 'viem';
 import type { AuthProvider } from '../auth/provider.js';
-import type { IntentInput, IntentOpStatus, IntentSubmitRequestInternal, IntentSubmitResponse, Portfolio, QuoteResponse, SplitIntentsInput, SplitIntentsResult } from './types.js';
+import type { IntentInput, IntentOpStatus, IntentSubmitRequestInternal, IntentSubmitResponse, Portfolio, QuoteResponse, SettlementLayerFilter, SplitIntentsInput, SplitIntentsResult } from './types.js';
 interface PolicyContext {
     intentInput: unknown;
     isSponsored: boolean;
@@ -24,5 +24,6 @@ export declare class Orchestrator {
     private getSubmitHeaders;
     private fetch;
 }
+export declare function encodeSettlementLayers(filter: SettlementLayerFilter): readonly string[];
 export {};
 //# sourceMappingURL=client.d.ts.map

package/dist/src/orchestrator/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAQpD,OAAO,KAAK,EAKV,WAAW,EACX,cAAc,EAEd,2BAA2B,EAC3B,oBAAoB,EACpB,SAAS,EAET,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAEnB,MAAM,SAAS,CAAA;AAGhB,UAAU,aAAa;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,WAAW,EAAE,OAAO,CAAA;CACrB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,YAAY,CAAC,CAAwB;gBAG3C,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,YAAY,EAC1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAO5B,YAAY,CAChB,cAAc,EAAE,OAAO,EACvB,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,MAAM,CAAC,EAAE;YAAE,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;SAAE,CAAA;KAC1C,GACA,OAAO,CAAC,SAAS,CAAC;IA0Cf,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;IAUvD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAkB/D,YAAY,CAChB,OAAO,EAAE,2BAA2B,EACpC,aAAa,CAAC,EAAE,aAAa,GAC5B,OAAO,CAAC,oBAAoB,CAAC;IAe1B,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;YAoB5C,UAAU;YAWV,gBAAgB;YAiBhB,KAAK;CAwBpB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAQpD,OAAO,KAAK,EAMV,WAAW,EACX,cAAc,EAEd,2BAA2B,EAC3B,oBAAoB,EACpB,SAAS,EAET,aAAa,EACb,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,EAEnB,MAAM,SAAS,CAAA;AAGhB,UAAU,aAAa;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,WAAW,EAAE,OAAO,CAAA;CACrB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,YAAY,CAAC,CAAwB;gBAG3C,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,YAAY,EAC1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAO5B,YAAY,CAChB,cAAc,EAAE,OAAO,EACvB,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,MAAM,CAAC,EAAE;YAAE,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;SAAE,CAAA;KAC1C,GACA,OAAO,CAAC,SAAS,CAAC;IAyCf,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;IAUvD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAqB/D,YAAY,CAChB,OAAO,EAAE,2BAA2B,EACpC,aAAa,CAAC,EAAE,aAAa,GAC5B,OAAO,CAAC,oBAAoB,CAAC;IAe1B,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;YAgB5C,UAAU;YAWV,gBAAgB;YAiBhB,KAAK;CA8BpB;AA4HD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,qBAAqB,GAC5B,SAAS,MAAM,EAAE,CAInB"}