@rhinestone/sdk 1.5.0 → 2.0.0-beta.0

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

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PERMIT2_CLAIM_POLICY_ADDRESS = void 0;
-exports.buildPermit2ClaimPolicyCalldata = buildPermit2ClaimPolicyCalldata;
-exports.encodePermit2ClaimPolicyInitData = encodePermit2ClaimPolicyInitData;
-const viem_1 = require("viem");
-const types_1 = require("./types");
+import { concat, encodeAbiParameters, encodePacked, hashStruct, keccak256, maxUint256, toHex, } from 'viem';
+import { ANY_ADDRESS, FIELD_ARBITER, FIELD_EXPIRY, FIELD_FILL_EXPIRY, FIELD_RECIPIENT, FIELD_RECIPIENT_IS_SPONSOR, FIELD_TOKEN_IN, FIELD_TOKEN_OUT, MODE_CHECK_STORAGE, } from './types.js';
 // EIP-712 type definitions for Permit2/Mandate struct encoding.
 // Note: the token-out struct is named 'Token' in the Solidity contract (matching the
 // signed Permit2 message types in execution/permit2.ts).
@@ -42,31 +37,31 @@ const PERMIT2_TYPES = {
 };
 // --- EIP-712 hash helpers ---
 function hashArray(hashes) {
-    return (0, viem_1.keccak256)(hashes.length > 0 ? (0, viem_1.concat)(hashes) : '0x');
+    return keccak256(hashes.length > 0 ? concat(hashes) : '0x');
 }
 function hashTokenPermissionsArray(permitted) {
-    return hashArray(permitted.map(({ token, amount }) => (0, viem_1.hashStruct)({
+    return hashArray(permitted.map(({ token, amount }) => hashStruct({
         primaryType: 'TokenPermissions',
         types: PERMIT2_TYPES,
         data: { token, amount },
     })));
 }
 function hashTokenOutArray(tokenOut) {
-    return hashArray(tokenOut.map(({ token, amount }) => (0, viem_1.hashStruct)({
+    return hashArray(tokenOut.map(({ token, amount }) => hashStruct({
         primaryType: 'Token',
         types: PERMIT2_TYPES,
         data: { token, amount },
     })));
 }
 function hashOpStruct(op) {
-    return (0, viem_1.hashStruct)({
+    return hashStruct({
         primaryType: 'Op',
         types: PERMIT2_TYPES,
         data: { vt: op.vt, ops: Array.from(op.ops) },
     });
 }
 function hashMandateStruct(mandate) {
-    return (0, viem_1.hashStruct)({
+    return hashStruct({
         primaryType: 'Mandate',
         types: PERMIT2_TYPES,
         data: {
@@ -89,7 +84,7 @@ function hashMandateStruct(mandate) {
 // --- Token array encoding helpers ---
 /** Encodes a token+amount pair as [token_as_uint256:32][amount:32] (64 bytes) */
 function encodeTokenEntry(token, amount) {
-    return (0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'uint256' }], [token, amount]);
+    return encodeAbiParameters([{ type: 'address' }, { type: 'uint256' }], [token, amount]);
 }
 /**
  * Builds the policySpecificData calldata for a Permit2ClaimPolicy EIP-1271 check.
@@ -101,7 +96,7 @@ function encodeTokenEntry(token, amount) {
  *            else — pre-computed mandateHash [32]
  *
  */
-function buildPermit2ClaimPolicyCalldata(policy, message) {
+export function buildPermit2ClaimPolicyCalldata(policy, message) {
     const tokenInEnabled = !!policy.tokensIn?.length;
     const recipientEnabled = !!policy.recipients?.length;
     const fillExpiryEnabled = !!policy.fillExpiryBounds?.length;
@@ -114,13 +109,13 @@ function buildPermit2ClaimPolicyCalldata(policy, message) {
         recipientIsSponsorEnabled;
     const parts = [];
     // Header: [spender:20][nonce:32][deadline:32]  (spender == arbiter in Permit2 context)
-    parts.push((0, viem_1.encodePacked)(['address', 'uint256', 'uint256'], [message.spender, message.nonce, message.deadline]));
+    parts.push(encodePacked(['address', 'uint256', 'uint256'], [message.spender, message.nonce, message.deadline]));
     // TokenIn section
     if (tokenInEnabled) {
         // Expanded: [count:1][token_as_uint256:32][amount:32]...
         if (message.permitted.length > 255)
             throw new Error('permitted array exceeds max length of 255');
-        parts.push((0, viem_1.toHex)(message.permitted.length, { size: 1 }));
+        parts.push(toHex(message.permitted.length, { size: 1 }));
         for (const { token, amount } of message.permitted) {
             parts.push(encodeTokenEntry(token, amount));
         }
@@ -137,12 +132,12 @@ function buildPermit2ClaimPolicyCalldata(policy, message) {
         // Expanded mandate: target fields + minGas + ops hashes + q
         const target = message.mandate.target;
         // Target: [recipient:20][targetChain:32][fillExpiry:32]
-        parts.push((0, viem_1.encodePacked)(['address', 'uint256', 'uint256'], [target.recipient, target.targetChain, target.fillExpiry]));
+        parts.push(encodePacked(['address', 'uint256', 'uint256'], [target.recipient, target.targetChain, target.fillExpiry]));
         // TokenOut (inside target)
         if (tokenOutEnabled) {
             if (target.tokenOut.length > 255)
                 throw new Error('tokenOut array exceeds max length of 255');
-            parts.push((0, viem_1.toHex)(target.tokenOut.length, { size: 1 }));
+            parts.push(toHex(target.tokenOut.length, { size: 1 }));
             for (const { token, amount } of target.tokenOut) {
                 parts.push(encodeTokenEntry(token, amount));
             }
@@ -151,65 +146,65 @@ function buildPermit2ClaimPolicyCalldata(policy, message) {
             parts.push(hashTokenOutArray(target.tokenOut));
         }
         // minGas: uint128 = 16 bytes
-        parts.push((0, viem_1.toHex)(message.mandate.minGas, { size: 16 }));
+        parts.push(toHex(message.mandate.minGas, { size: 16 }));
         // originOpsHash and destOpsHash: always 32-byte hashes (we don't support ops checks)
         parts.push(hashOpStruct(message.mandate.originOps));
         parts.push(hashOpStruct(message.mandate.destOps));
         // qualificationHash: q is already keccak256(qualifier.encodedVal)
         parts.push(message.mandate.q);
     }
-    return (0, viem_1.concat)(parts);
+    return concat(parts);
 }
-exports.PERMIT2_CLAIM_POLICY_ADDRESS = '0x62E3588C6d861C9f986E82EC3757434EDF16ce91';
-function encodePermit2ClaimPolicyInitData(policy) {
+export const PERMIT2_CLAIM_POLICY_ADDRESS = '0x62E3588C6d861C9f986E82EC3757434EDF16ce91';
+export function encodePermit2ClaimPolicyInitData(policy) {
     let modeConfig = 0;
     const setMode = (fieldId) => {
-        modeConfig |= types_1.MODE_CHECK_STORAGE << (fieldId * 2);
+        modeConfig |= MODE_CHECK_STORAGE << (fieldId * 2);
     };
     if (policy.arbiters?.length)
-        setMode(types_1.FIELD_ARBITER);
+        setMode(FIELD_ARBITER);
     if (policy.expiryBounds)
-        setMode(types_1.FIELD_EXPIRY);
+        setMode(FIELD_EXPIRY);
     if (policy.tokensIn?.length)
-        setMode(types_1.FIELD_TOKEN_IN);
+        setMode(FIELD_TOKEN_IN);
     if (policy.recipients?.length)
-        setMode(types_1.FIELD_RECIPIENT);
+        setMode(FIELD_RECIPIENT);
     if (policy.fillExpiryBounds?.length)
-        setMode(types_1.FIELD_FILL_EXPIRY);
+        setMode(FIELD_FILL_EXPIRY);
     if (policy.tokensOut?.length)
-        setMode(types_1.FIELD_TOKEN_OUT);
+        setMode(FIELD_TOKEN_OUT);
     if (policy.recipientIsSponsor)
-        setMode(types_1.FIELD_RECIPIENT_IS_SPONSOR);
-    const parts = [(0, viem_1.toHex)(modeConfig, { size: 4 })];
+        setMode(FIELD_RECIPIENT_IS_SPONSOR);
+    const parts = [toHex(modeConfig, { size: 4 })];
     // Arbiter: [count: 1][address: 20] each
     if (policy.arbiters?.length) {
         if (policy.arbiters.length > 255)
             throw new Error('arbiters array exceeds max length of 255');
-        parts.push((0, viem_1.encodePacked)(['uint8', ...policy.arbiters.map(() => 'address')], [policy.arbiters.length, ...policy.arbiters]));
+        parts.push(encodePacked(['uint8', ...policy.arbiters.map(() => 'address')], [policy.arbiters.length, ...policy.arbiters]));
     }
     // Expiry: [maxExpiry: 16][minExpiry: 16] packed into uint256
     if (policy.expiryBounds) {
         const mask128 = (1n << 128n) - 1n;
         const min = (policy.expiryBounds.min ?? 0n) & mask128;
-        const max = (policy.expiryBounds.max ?? viem_1.maxUint256) & mask128;
-        parts.push((0, viem_1.toHex)((min & mask128) | (max << 128n), { size: 32 }));
+        const max = (policy.expiryBounds.max ?? maxUint256) & mask128;
+        parts.push(toHex((min & mask128) | (max << 128n), { size: 32 }));
     }
     // TokenIn: [count: 1][chainId: 32][token: 20] each
     if (policy.tokensIn?.length) {
         if (policy.tokensIn.length > 255)
             throw new Error('tokensIn array exceeds max length of 255');
-        parts.push((0, viem_1.toHex)(policy.tokensIn.length, { size: 1 }));
+        parts.push(toHex(policy.tokensIn.length, { size: 1 }));
         for (const { chainId, token } of policy.tokensIn) {
-            parts.push((0, viem_1.encodePacked)(['uint256', 'address'], [BigInt(chainId), token]));
+            parts.push(encodePacked(['uint256', 'address'], [BigInt(chainId), token]));
         }
     }
     // Recipient: [count: 1][chainId: 32][recipient: 20] each
     if (policy.recipients?.length) {
         if (policy.recipients.length > 255)
             throw new Error('recipients array exceeds max length of 255');
-        parts.push((0, viem_1.toHex)(policy.recipients.length, { size: 1 }));
+        parts.push(toHex(policy.recipients.length, { size: 1 }));
         for (const { chainId, recipient } of policy.recipients) {
-            parts.push((0, viem_1.encodePacked)(['uint256', 'address'], [BigInt(chainId), recipient === 'any' ? types_1.ANY_ADDRESS : recipient]));
+            parts.push(encodePacked(['uint256', 'address'], [BigInt(chainId), recipient === 'any' ? ANY_ADDRESS : recipient]));
         }
     }
     // FillExpiry: [count: 1][chainId: 32][max<<128|min packed into uint256] each
@@ -217,23 +212,23 @@ function encodePermit2ClaimPolicyInitData(policy) {
         if (policy.fillExpiryBounds.length > 255)
             throw new Error('fillExpiryBounds array exceeds max length of 255');
         const mask128 = (1n << 128n) - 1n;
-        parts.push((0, viem_1.toHex)(policy.fillExpiryBounds.length, { size: 1 }));
+        parts.push(toHex(policy.fillExpiryBounds.length, { size: 1 }));
         for (const { chainId, min: fMin, max: fMax } of policy.fillExpiryBounds) {
             const minVal = (fMin ?? 0n) & mask128;
-            const maxVal = (fMax ?? viem_1.maxUint256) & mask128;
+            const maxVal = (fMax ?? maxUint256) & mask128;
             const packed = minVal | (maxVal << 128n);
-            parts.push((0, viem_1.encodePacked)(['uint256', 'uint256'], [BigInt(chainId), packed]));
+            parts.push(encodePacked(['uint256', 'uint256'], [BigInt(chainId), packed]));
         }
     }
     // TokenOut: [count: 1][chainId: 32][token: 20] each
     if (policy.tokensOut?.length) {
         if (policy.tokensOut.length > 255)
             throw new Error('tokensOut array exceeds max length of 255');
-        parts.push((0, viem_1.toHex)(policy.tokensOut.length, { size: 1 }));
+        parts.push(toHex(policy.tokensOut.length, { size: 1 }));
         for (const { chainId, token } of policy.tokensOut) {
-            parts.push((0, viem_1.encodePacked)(['uint256', 'address'], [BigInt(chainId), token]));
+            parts.push(encodePacked(['uint256', 'address'], [BigInt(chainId), token]));
         }
     }
     // RecipientIsSponsor has no data payload — mode bit alone enables it
-    return (0, viem_1.concat)(parts);
+    return concat(parts);
 }

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

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ANY_ADDRESS = exports.MODE_CHECK_STORAGE = exports.FIELD_RECIPIENT_IS_SPONSOR = exports.FIELD_DEST_OPS = exports.FIELD_ORIGIN_OPS = exports.FIELD_TOKEN_OUT = exports.FIELD_FILL_EXPIRY = exports.FIELD_RECIPIENT = exports.FIELD_TOKEN_IN = exports.FIELD_EXPIRY = exports.FIELD_ARBITER = void 0;
 // Field IDs matching BaseDataTypes.sol
-exports.FIELD_ARBITER = 0;
-exports.FIELD_EXPIRY = 1;
-exports.FIELD_TOKEN_IN = 2;
-exports.FIELD_RECIPIENT = 3;
-exports.FIELD_FILL_EXPIRY = 4;
-exports.FIELD_TOKEN_OUT = 5;
-exports.FIELD_ORIGIN_OPS = 6;
-exports.FIELD_DEST_OPS = 7;
+export const FIELD_ARBITER = 0;
+export const FIELD_EXPIRY = 1;
+export const FIELD_TOKEN_IN = 2;
+export const FIELD_RECIPIENT = 3;
+export const FIELD_FILL_EXPIRY = 4;
+export const FIELD_TOKEN_OUT = 5;
+export const FIELD_ORIGIN_OPS = 6;
+export const FIELD_DEST_OPS = 7;
 // Field 8 is reserved in BaseDataTypes.sol
-exports.FIELD_RECIPIENT_IS_SPONSOR = 9;
+export const FIELD_RECIPIENT_IS_SPONSOR = 9;
 // Mode values
-exports.MODE_CHECK_STORAGE = 1;
+export const MODE_CHECK_STORAGE = 1;
 // Sentinel: allows any recipient address
-exports.ANY_ADDRESS = '0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF';
+export const ANY_ADDRESS = '0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF';

package/dist/src/modules/validators/smart-sessions.d.ts

@@ -1,7 +1,7 @@
 import { type Address, type Hex, type TypedDataDefinition } from 'viem';
-import type { Policy, ProviderConfig, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData } from '../../types';
-import { type Module } from '../common';
-import { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV } from './core';
+import type { Policy, ProviderConfig, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData } from '../../types.js';
+import { type Module } from '../common.js';
+import { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV } from './core.js';
 interface SessionData {
     sessionValidator: Address;
     sessionValidatorInitData: Hex;

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

@@ -1,34 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.INTENT_EXECUTION_POLICY_ADDRESS = exports.VALUE_LIMIT_POLICY_ADDRESS = exports.USAGE_LIMIT_POLICY_ADDRESS = exports.UNIVERSAL_ACTION_POLICY_ADDRESS = exports.SUDO_POLICY_ADDRESS = exports.TIME_FRAME_POLICY_ADDRESS = exports.SPENDING_LIMITS_POLICY_ADDRESS = exports.DUMMY_PRECLAIMOP_SELECTOR = exports.DUMMY_PRECLAIMOP_TARGET = exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = exports.SMART_SESSIONS_FALLBACK_TARGET_FLAG = exports.SMART_SESSION_EMISSARY_ADDRESS_DEV = exports.SMART_SESSION_EMISSARY_ADDRESS = void 0;
-exports.packSignature = packSignature;
-exports.getSessionData = getSessionData;
-exports.getPolicyData = getPolicyData;
-exports.getEnableSessionCall = getEnableSessionCall;
-exports.getPermissionId = getPermissionId;
-exports.getSmartSessionValidator = getSmartSessionValidator;
-exports.getSessionDetails = getSessionDetails;
-exports.isSessionEnabled = isSessionEnabled;
-exports.signEnableSession = signEnableSession;
-exports.buildMockSignature = buildMockSignature;
-const solady_1 = require("solady");
-const viem_1 = require("viem");
-const chains_1 = require("viem/chains");
-const accounts_1 = require("../../accounts");
-const startale_1 = require("../../accounts/startale");
-const utils_1 = require("../../accounts/utils");
-const compact_1 = require("../../execution/compact");
-const utils_2 = require("../../execution/utils");
-const registry_1 = require("../../orchestrator/registry");
-const smart_session_emissary_1 = __importDefault(require("../abi/smart-session-emissary"));
-const common_1 = require("../common");
-const core_1 = require("./core");
-Object.defineProperty(exports, "SMART_SESSION_EMISSARY_ADDRESS", { enumerable: true, get: function () { return core_1.SMART_SESSION_EMISSARY_ADDRESS; } });
-Object.defineProperty(exports, "SMART_SESSION_EMISSARY_ADDRESS_DEV", { enumerable: true, get: function () { return core_1.SMART_SESSION_EMISSARY_ADDRESS_DEV; } });
-const permit2_1 = require("./policies/claim/permit2");
+import { LibZip } from 'solady';
+import { concat, createPublicClient, encodeAbiParameters, encodeFunctionData, encodePacked, hashStruct, isHex, keccak256, maxUint256, padHex, size, toFunctionSelector, toHex, zeroAddress, zeroHash, } from 'viem';
+import { mainnet } from 'viem/chains';
+import { getAccountProvider } from '../../accounts/index.js';
+import { K1_DEFAULT_VALIDATOR_ADDRESS } from '../../accounts/startale.js';
+import { createTransport } from '../../accounts/utils.js';
+import { RESET_PERIOD_ONE_WEEK, SCOPE_MULTICHAIN, } from '../../execution/compact.js';
+import { signTypedData } from '../../execution/utils.js';
+import { getChainById, getWrappedTokenAddress, } from '../../orchestrator/registry.js';
+import smartSessionEmissaryAbi from '../abi/smart-session-emissary.js';
+import { MODULE_TYPE_ID_VALIDATOR } from '../common.js';
+import { getOwnerValidator, getValidator, SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, } from './core.js';
+import { encodePermit2ClaimPolicyInitData, PERMIT2_CLAIM_POLICY_ADDRESS, } from './policies/claim/permit2.js';
 const types = {
     PolicyData: [
         { name: 'policy', type: 'address' },
@@ -76,11 +58,8 @@ const types = {
 const SMART_SESSION_MODE_USE = '0x00';
 const SMART_SESSION_MODE_ENABLE = '0x01';
 const SMART_SESSIONS_FALLBACK_TARGET_FLAG = '0x0000000000000000000000000000000000000001';
-exports.SMART_SESSIONS_FALLBACK_TARGET_FLAG = SMART_SESSIONS_FALLBACK_TARGET_FLAG;
 const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = '0x00000001';
-exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG;
 const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = '0x00000002';
-exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION;
 // Dummy preclaimop action injected into every session so that the filler can trigger
 // verifyExecution (ENABLE mode) using an injected dummy preclaimop when there are no
 // real preclaimops. Target 0x...0001 is the ecRecover precompile; calls to it fail
@@ -89,23 +68,14 @@ exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESS
 // SMART_SESSIONS_FALLBACK_TARGET_FLAG — that is harmless because they operate in
 // different contexts (action matching vs. literal execution target).
 const DUMMY_PRECLAIMOP_TARGET = '0x0000000000000000000000000000000000000001';
-exports.DUMMY_PRECLAIMOP_TARGET = DUMMY_PRECLAIMOP_TARGET;
 const DUMMY_PRECLAIMOP_SELECTOR = '0x69123456';
-exports.DUMMY_PRECLAIMOP_SELECTOR = DUMMY_PRECLAIMOP_SELECTOR;
 const SPENDING_LIMITS_POLICY_ADDRESS = '0x00000088d48cf102a8cdb0137a9b173f957c6343';
-exports.SPENDING_LIMITS_POLICY_ADDRESS = SPENDING_LIMITS_POLICY_ADDRESS;
 const TIME_FRAME_POLICY_ADDRESS = '0x8177451511de0577b911c254e9551d981c26dc72';
-exports.TIME_FRAME_POLICY_ADDRESS = TIME_FRAME_POLICY_ADDRESS;
 const SUDO_POLICY_ADDRESS = '0x0000003111cd8e92337c100f22b7a9dbf8dee301';
-exports.SUDO_POLICY_ADDRESS = SUDO_POLICY_ADDRESS;
 const UNIVERSAL_ACTION_POLICY_ADDRESS = '0x0000006dda6c463511c4e9b05cfc34c1247fcf1f';
-exports.UNIVERSAL_ACTION_POLICY_ADDRESS = UNIVERSAL_ACTION_POLICY_ADDRESS;
 const USAGE_LIMIT_POLICY_ADDRESS = '0x1f34ef8311345a3a4a4566af321b313052f51493';
-exports.USAGE_LIMIT_POLICY_ADDRESS = USAGE_LIMIT_POLICY_ADDRESS;
 const VALUE_LIMIT_POLICY_ADDRESS = '0x730da93267e7e513e932301b47f2ac7d062abc83';
-exports.VALUE_LIMIT_POLICY_ADDRESS = VALUE_LIMIT_POLICY_ADDRESS;
 const INTENT_EXECUTION_POLICY_ADDRESS = '0xe9eA54d063975cDee9e06b7636d5563d95a7A23C';
-exports.INTENT_EXECUTION_POLICY_ADDRESS = INTENT_EXECUTION_POLICY_ADDRESS;
 const INTENT_EXECUTION_POLICY_ADDRESS_DEV = '0xa09b47de6e510cbdc18b97e9239bedcb44fb4901';
 const ACTION_CONDITION_EQUAL = 0;
 const ACTION_CONDITION_GREATER_THAN = 1;
@@ -123,7 +93,7 @@ function packSignature(signers, validatorSignature) {
             : SMART_SESSION_MODE_USE;
         const sessionData = getSessionData(signers.session);
         const packedSignature = signers.enableData
-            ? solady_1.LibZip.flzCompress((0, viem_1.encodeAbiParameters)([
+            ? LibZip.flzCompress(encodeAbiParameters([
                 {
                     type: 'tuple',
                     name: 'enableData',
@@ -222,9 +192,9 @@ function packSignature(signers, validatorSignature) {
                 { type: 'bytes' },
             ], [
                 {
-                    allocatorSig: viem_1.zeroHash,
+                    allocatorSig: zeroHash,
                     userSig: signers.enableData.userSignature,
-                    expires: viem_1.maxUint256,
+                    expires: maxUint256,
                     enableSession: {
                         chainDigestIndex: signers.enableData.sessionToEnableIndex,
                         hashesAndChainIds: signers.enableData.hashesAndChainIds,
@@ -232,24 +202,24 @@ function packSignature(signers, validatorSignature) {
                     },
                 },
                 {
-                    scope: compact_1.SCOPE_MULTICHAIN,
-                    resetPeriod: compact_1.RESET_PERIOD_ONE_WEEK,
-                    allocator: viem_1.zeroAddress,
+                    scope: SCOPE_MULTICHAIN,
+                    resetPeriod: RESET_PERIOD_ONE_WEEK,
+                    allocator: zeroAddress,
                     permissionId: getPermissionId(signers.session),
                 },
                 validatorSignature,
             ]))
             : validatorSignature;
         return signers.enableData
-            ? (0, viem_1.encodePacked)(['bytes1', 'bytes'], [smartSessionMode, packedSignature])
-            : (0, viem_1.encodePacked)(['bytes1', 'bytes32', 'bytes'], [smartSessionMode, permissionId, packedSignature]);
+            ? encodePacked(['bytes1', 'bytes'], [smartSessionMode, packedSignature])
+            : encodePacked(['bytes1', 'bytes32', 'bytes'], [smartSessionMode, permissionId, packedSignature]);
     }
     else {
         const SIGNATURE_IS_VALID_SIG_1271 = '0x00';
-        const policyDataOffset = BigInt(64 + (0, viem_1.size)(validatorSignature));
+        const policyDataOffset = BigInt(64 + size(validatorSignature));
         const mode = SIGNATURE_IS_VALID_SIG_1271;
         const policySpecificData = signers.claimPolicyData ?? '0x';
-        const signature = (0, viem_1.encodePacked)(['bytes1', 'bytes32', 'uint256', 'bytes', 'bytes'], [
+        const signature = encodePacked(['bytes1', 'bytes32', 'uint256', 'bytes', 'bytes'], [
             mode,
             permissionId,
             policyDataOffset,
@@ -267,7 +237,7 @@ async function getSessionDetails(account, sessions, provider, useDevContracts) {
     const chains = sessions.map((session) => session.chain);
     const hashesAndChainIds = signedSessions.map((session, index) => ({
         chainId: BigInt(chains[index].id),
-        sessionDigest: (0, viem_1.hashStruct)({
+        sessionDigest: hashStruct({
             types,
             primaryType: 'SignedSession',
             data: session,
@@ -294,9 +264,9 @@ async function getSessionDetails(account, sessions, provider, useDevContracts) {
     };
 }
 async function isSessionEnabled(account, provider, session, useDevContracts) {
-    const publicClient = (0, viem_1.createPublicClient)({
+    const publicClient = createPublicClient({
         chain: session.chain,
-        transport: (0, utils_1.createTransport)(session.chain, provider),
+        transport: createTransport(session.chain, provider),
     });
     const isEnabled = await publicClient.readContract({
         address: getSmartSessionEmissaryAddress(useDevContracts),
@@ -318,30 +288,30 @@ async function isSessionEnabled(account, provider, session, useDevContracts) {
     return isEnabled;
 }
 async function signEnableSession(config, details) {
-    const account = (0, accounts_1.getAccountProvider)(config);
-    const validator = (0, core_1.getOwnerValidator)(config);
+    const account = getAccountProvider(config);
+    const validator = getOwnerValidator(config);
     const isStartaleK1 = account.type === 'startale' &&
         validator.address.toLowerCase() ===
-            startale_1.K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
+            K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
     if (isStartaleK1) {
         const chainIds = details.hashesAndChainIds.map((h) => h.chainId);
         const uniqueChainIds = [...new Set(chainIds.map((c) => c.toString()))];
         if (uniqueChainIds.length > 1) {
             throw new Error('Startale accounts with K1 validator do not support multi-chain session enable');
         }
-        const chain = (0, registry_1.getChainById)(Number(chainIds[0]));
-        return (0, utils_2.signTypedData)(config, details.data, chain, undefined, {
+        const chain = getChainById(Number(chainIds[0]));
+        return signTypedData(config, details.data, chain, undefined, {
             skipErc6492: true,
         });
     }
-    return (0, utils_2.signTypedData)(config, details.data, chains_1.mainnet, undefined, {
+    return signTypedData(config, details.data, mainnet, undefined, {
         skipErc6492: true,
     });
 }
 async function getSessionNonce(account, session, lockTag, provider, useDevContracts) {
-    const publicClient = (0, viem_1.createPublicClient)({
+    const publicClient = createPublicClient({
         chain: session.chain,
-        transport: (0, utils_1.createTransport)(session.chain, provider),
+        transport: createTransport(session.chain, provider),
     });
     const nonce = await publicClient.readContract({
         address: getSmartSessionEmissaryAddress(useDevContracts),
@@ -386,7 +356,7 @@ function getSignedSession(account, lockTag, session, nonce, useDevContracts) {
         sessionValidatorInitData: session.sessionValidatorInitData,
         salt: session.salt,
         smartSessionEmissary: getSmartSessionEmissaryAddress(useDevContracts),
-        expires: viem_1.maxUint256,
+        expires: maxUint256,
         nonce,
     };
 }
@@ -395,21 +365,21 @@ async function getEnableSessionCall(account, session, enableSessionSignature, ha
     const permissionId = getPermissionId(session);
     return {
         to: getSmartSessionEmissaryAddress(useDevContracts),
-        data: (0, viem_1.encodeFunctionData)({
-            abi: smart_session_emissary_1.default,
+        data: encodeFunctionData({
+            abi: smartSessionEmissaryAbi,
             functionName: 'setConfig',
             args: [
                 account,
                 {
-                    scope: compact_1.SCOPE_MULTICHAIN,
-                    resetPeriod: compact_1.RESET_PERIOD_ONE_WEEK,
-                    allocator: viem_1.zeroAddress,
+                    scope: SCOPE_MULTICHAIN,
+                    resetPeriod: RESET_PERIOD_ONE_WEEK,
+                    allocator: zeroAddress,
                     permissionId,
                 },
                 {
-                    allocatorSig: viem_1.zeroHash,
+                    allocatorSig: zeroHash,
                     userSig: enableSessionSignature,
-                    expires: viem_1.maxUint256,
+                    expires: maxUint256,
                     session: {
                         chainDigestIndex: sessionToEnableIndex,
                         hashesAndChainIds,
@@ -421,11 +391,11 @@ async function getEnableSessionCall(account, session, enableSessionSignature, ha
     };
 }
 function getSessionData(session, useDevContracts) {
-    const validator = (0, core_1.getValidator)(session.owners);
+    const validator = getValidator(session.owners);
     const allowedContent = [
         {
             contentNames: [''],
-            appDomainSeparator: viem_1.zeroHash,
+            appDomainSeparator: zeroHash,
         },
     ];
     const erc7739Data = {
@@ -451,8 +421,8 @@ function getSessionData(session, useDevContracts) {
     const injectedActions = [
         // Native token wrapping
         {
-            target: (0, registry_1.getWrappedTokenAddress)(session.chain),
-            selector: (0, viem_1.toFunctionSelector)({
+            target: getWrappedTokenAddress(session.chain),
+            selector: toFunctionSelector({
                 type: 'function',
                 name: 'deposit',
                 inputs: [],
@@ -493,20 +463,20 @@ function getSessionData(session, useDevContracts) {
         : [sudoAction];
     return {
         sessionValidator: validator.address,
-        salt: viem_1.zeroHash,
+        salt: zeroHash,
         sessionValidatorInitData: validator.initData,
         erc7739Policies: erc7739Data,
         actions,
         // Note: Permit2ClaimPolicy has no dev deployment — same address in all environments
         claimPolicies: session.claimPolicies?.map((p) => ({
-            policy: permit2_1.PERMIT2_CLAIM_POLICY_ADDRESS,
-            initData: (0, permit2_1.encodePermit2ClaimPolicyInitData)(p),
+            policy: PERMIT2_CLAIM_POLICY_ADDRESS,
+            initData: encodePermit2ClaimPolicyInitData(p),
         })) ?? [],
     };
 }
 function getPermissionId(session) {
     const sessionData = getSessionData(session);
-    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+    return keccak256(encodeAbiParameters([
         {
             type: 'address',
             name: 'sessionValidator',
@@ -563,14 +533,14 @@ function getPolicyData(policy, useDevContracts) {
                 condition: ACTION_CONDITION_EQUAL,
                 offset: 0n,
                 isLimited: false,
-                ref: viem_1.zeroHash,
+                ref: zeroHash,
                 usage: { limit: 0n, used: 0n },
             }));
             for (let i = 0; i < policy.rules.length; i++) {
                 const rule = policy.rules[i];
-                const ref = (0, viem_1.isHex)(rule.referenceValue)
-                    ? (0, viem_1.padHex)(rule.referenceValue)
-                    : (0, viem_1.toHex)(rule.referenceValue, { size: 32 });
+                const ref = isHex(rule.referenceValue)
+                    ? padHex(rule.referenceValue)
+                    : toHex(rule.referenceValue, { size: 32 });
                 rules[i] = {
                     condition: getCondition(rule.condition),
                     offset: rule.calldataOffset,
@@ -584,7 +554,7 @@ function getPolicyData(policy, useDevContracts) {
             }
             return {
                 policy: UNIVERSAL_ACTION_POLICY_ADDRESS,
-                initData: (0, viem_1.encodeAbiParameters)([
+                initData: encodeAbiParameters([
                     {
                         components: [
                             {
@@ -657,13 +627,13 @@ function getPolicyData(policy, useDevContracts) {
             const limits = policy.limits.map(({ amount }) => amount);
             return {
                 policy: SPENDING_LIMITS_POLICY_ADDRESS,
-                initData: (0, viem_1.encodeAbiParameters)([{ type: 'address[]' }, { type: 'uint256[]' }], [tokens, limits]),
+                initData: encodeAbiParameters([{ type: 'address[]' }, { type: 'uint256[]' }], [tokens, limits]),
             };
         }
         case 'time-frame': {
             return {
                 policy: TIME_FRAME_POLICY_ADDRESS,
-                initData: (0, viem_1.encodePacked)(['uint48', 'uint48'], [
+                initData: encodePacked(['uint48', 'uint48'], [
                     Math.floor(policy.validUntil / 1000),
                     Math.floor(policy.validAfter / 1000),
                 ]),
@@ -672,13 +642,13 @@ function getPolicyData(policy, useDevContracts) {
         case 'usage-limit': {
             return {
                 policy: USAGE_LIMIT_POLICY_ADDRESS,
-                initData: (0, viem_1.encodePacked)(['uint128'], [policy.limit]),
+                initData: encodePacked(['uint128'], [policy.limit]),
             };
         }
         case 'value-limit': {
             return {
                 policy: VALUE_LIMIT_POLICY_ADDRESS,
-                initData: (0, viem_1.encodeAbiParameters)([{ type: 'uint256' }], [policy.limit]),
+                initData: encodeAbiParameters([{ type: 'uint256' }], [policy.limit]),
             };
         }
     }
@@ -696,13 +666,13 @@ function getSmartSessionValidator(config) {
         initData: '0x',
         deInitData: '0x',
         additionalContext: '0x',
-        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+        type: MODULE_TYPE_ID_VALIDATOR,
     };
 }
 function getSmartSessionEmissaryAddress(useDevContracts) {
     return useDevContracts === true
-        ? core_1.SMART_SESSION_EMISSARY_ADDRESS_DEV
-        : core_1.SMART_SESSION_EMISSARY_ADDRESS;
+        ? SMART_SESSION_EMISSARY_ADDRESS_DEV
+        : SMART_SESSION_EMISSARY_ADDRESS;
 }
 /**
  * Builds a mockSignature for SSX validation gas estimation.
@@ -728,7 +698,7 @@ function buildMockSignature(session, useDevContracts, chainCount = 1, targetChai
     // mock emissary, so sessionDigest can be zeroHash throughout.
     const hashesAndChainIds = Array.from({ length: safeChainCount }, (_, i) => ({
         chainId: i === 0 ? BigInt(primaryChainId) : 0n,
-        sessionDigest: viem_1.zeroHash,
+        sessionDigest: zeroHash,
     }));
     const dummySigners = {
         type: 'experimental_session',
@@ -742,8 +712,9 @@ function buildMockSignature(session, useDevContracts, chainCount = 1, targetChai
     };
     const dummyValidatorSignature = `0x${'00'.repeat(65)}`;
     const sigData = packSignature(dummySigners, dummyValidatorSignature);
-    return (0, viem_1.concat)([emissaryAddress, sigData]);
+    return concat([emissaryAddress, sigData]);
 }
 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, getSessionData, getPolicyData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, isSessionEnabled, signEnableSession, buildMockSignature, };

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

@@ -1,6 +1,6 @@
 import type { Address } from 'viem';
-import type { AuthProvider } from '../auth/provider';
-import type { IntentInput, IntentOpStatus, IntentResult, IntentRoute, Portfolio, SignedIntentOp, SplitIntentsInput, SplitIntentsResult } from './types';
+import type { AuthProvider } from '../auth/provider.js';
+import type { IntentInput, IntentOpStatus, IntentResult, IntentRoute, Portfolio, SignedIntentOp, SplitIntentsInput, SplitIntentsResult } from './types.js';
 export declare class Orchestrator {
     private serverUrl;
     private authProvider;