@rhinestone/sdk 2.0.0-beta.44 → 2.0.0-beta.45

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

@@ -0,0 +1,30 @@
+import { encodeAbiParameters, keccak256 } from 'viem';
+import { encodePermit2ClaimPolicyInitData, PERMIT2_CLAIM_POLICY_ADDRESS, } from '../policies/claim/permit2.js';
+import { resolvePermit2ClaimPolicy } from './policies/claim.js';
+export function getPermissionIdFromData(session) {
+    return keccak256(encodeAbiParameters([
+        { type: 'address', name: 'sessionValidator' },
+        { type: 'bytes', name: 'sessionValidatorInitData' },
+        { type: 'bytes32', name: 'salt' },
+    ], [
+        session.sessionValidator,
+        session.sessionValidatorInitData,
+        session.salt,
+    ]));
+}
+export function getSessionData(session) {
+    return {
+        sessionValidator: session.sessionValidator,
+        sessionValidatorInitData: session.sessionValidatorInitData,
+        salt: session.salt,
+        erc7739Policies: session.erc7739Policies,
+        actions: session.actions,
+        claimPolicies: session.claimPolicies.map((policy) => ({
+            policy: PERMIT2_CLAIM_POLICY_ADDRESS,
+            initData: encodePermit2ClaimPolicyInitData(resolvePermit2ClaimPolicy(policy)),
+        })),
+    };
+}
+export function getPermissionId(session) {
+    return session.permissionId;
+}

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

@@ -0,0 +1,10 @@
+import { type Hex } from 'viem';
+import type { Session, SmartSessionMockShape } from './types.js';
+export declare function buildSmartSessionMockSignature(input: {
+    readonly session: Session;
+    readonly environment: 'production' | 'development';
+    readonly chainCount?: number;
+    readonly targetChainId?: number;
+    readonly shape?: SmartSessionMockShape;
+}): Hex;
+//# sourceMappingURL=mock-signature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock-signature.d.ts","sourceRoot":"","sources":["../../../../../modules/validators/smart-sessions/mock-signature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,GAAG,EAAY,MAAM,MAAM,CAAA;AAGjD,OAAO,KAAK,EAEV,OAAO,EAEP,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAEhB,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,CAAA;IAClD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,qBAAqB,CAAA;CACvC,GAAG,GAAG,CA4BN"}

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

@@ -0,0 +1,31 @@
+import { concat, zeroHash } from 'viem';
+import { getSmartSessionEmissaryAddress } from './module.js';
+import { encodeSmartSessionSignature } from './signature.js';
+export function buildSmartSessionMockSignature(input) {
+    const shape = input.shape ?? 'enable';
+    let enableData;
+    if (shape === 'enable') {
+        const chainCount = Number.isFinite(input.chainCount) && (input.chainCount ?? 0) > 0
+            ? Math.floor(input.chainCount)
+            : 1;
+        const primaryChainId = input.targetChainId ?? input.session.chain.id;
+        enableData = {
+            userSignature: `0x${'00'.repeat(65)}`,
+            hashesAndChainIds: Array.from({ length: chainCount }, (_, index) => ({
+                chainId: index === 0 ? BigInt(primaryChainId) : 0n,
+                sessionDigest: zeroHash,
+            })),
+            sessionToEnableIndex: 0,
+        };
+    }
+    const signers = {
+        kind: 'smart-session',
+        session: input.session,
+        verifyExecutions: shape !== 'erc1271',
+        ...(enableData ? { enableData } : {}),
+    };
+    return concat([
+        getSmartSessionEmissaryAddress(input.environment),
+        encodeSmartSessionSignature(signers, `0x${'00'.repeat(65)}`),
+    ]);
+}

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

@@ -0,0 +1,11 @@
+import type { Address } from 'viem';
+import type { ResolvedModule } from '../../types.js';
+export declare const SMART_SESSION_EMISSARY_ADDRESS: Address;
+export declare const SMART_SESSION_EMISSARY_ADDRESS_DEV: Address;
+export declare function getSmartSessionEmissaryAddress(environment: 'production' | 'development'): Address;
+export declare function resolveSmartSessionModule(input: {
+    readonly enabled: boolean;
+    readonly address?: Address;
+    readonly environment: 'production' | 'development';
+}): ResolvedModule | undefined;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../modules/validators/smart-sessions/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD,eAAO,MAAM,8BAA8B,EAAE,OACC,CAAA;AAC9C,eAAO,MAAM,kCAAkC,EAAE,OACH,CAAA;AAE9C,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,YAAY,GAAG,aAAa,GACxC,OAAO,CAIT;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,CAAA;CACnD,GAAG,cAAc,GAAG,SAAS,CAS7B"}

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

@@ -0,0 +1,18 @@
+export const SMART_SESSION_EMISSARY_ADDRESS = '0xad568b3f825a8d5ffc06dd3253526b64d810ae89';
+export const SMART_SESSION_EMISSARY_ADDRESS_DEV = '0x60731de80d78548875f8a67c4fec2a8660194e0c';
+export function getSmartSessionEmissaryAddress(environment) {
+    return environment === 'development'
+        ? SMART_SESSION_EMISSARY_ADDRESS_DEV
+        : SMART_SESSION_EMISSARY_ADDRESS;
+}
+export function resolveSmartSessionModule(input) {
+    if (!input.enabled)
+        return undefined;
+    return {
+        kind: 'validator',
+        address: input.address ?? getSmartSessionEmissaryAddress(input.environment),
+        initData: '0x',
+        deInitData: '0x',
+        additionalContext: '0x',
+    };
+}

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

@@ -0,0 +1,23 @@
+import type { Address } from 'viem';
+import type { SessionPolicyAddresses } from '../types.js';
+export declare const SPENDING_LIMITS_POLICY_ADDRESS: Address;
+export declare const TIME_FRAME_POLICY_ADDRESS: Address;
+export declare const SUDO_POLICY_ADDRESS: Address;
+export declare const UNIVERSAL_ACTION_POLICY_ADDRESS: Address;
+export declare const ARG_POLICY_ADDRESS: Address;
+export declare const USAGE_LIMIT_POLICY_ADDRESS: Address;
+export declare const VALUE_LIMIT_POLICY_ADDRESS: Address;
+export declare const INTENT_EXECUTION_POLICY_ADDRESS: Address;
+export declare const INTENT_EXECUTION_POLICY_ADDRESS_DEV: Address;
+export interface ResolvedPolicyAddresses {
+    readonly sudo: Address;
+    readonly universalAction: Address;
+    readonly argPolicy: Address;
+    readonly spendingLimits: Address;
+    readonly timeFrame: Address;
+    readonly usageLimit: Address;
+    readonly valueLimit: Address;
+}
+export declare const DEFAULT_POLICY_ADDRESSES: ResolvedPolicyAddresses;
+export declare function resolvePolicyAddresses(overrides?: SessionPolicyAddresses): ResolvedPolicyAddresses;
+//# sourceMappingURL=addresses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../../../../modules/validators/smart-sessions/policies/addresses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD,eAAO,MAAM,8BAA8B,EAAE,OACC,CAAA;AAC9C,eAAO,MAAM,yBAAyB,EAAE,OACM,CAAA;AAC9C,eAAO,MAAM,mBAAmB,EAAE,OACY,CAAA;AAC9C,eAAO,MAAM,+BAA+B,EAAE,OACA,CAAA;AAC9C,eAAO,MAAM,kBAAkB,EAAE,OACa,CAAA;AAC9C,eAAO,MAAM,0BAA0B,EAAE,OACK,CAAA;AAC9C,eAAO,MAAM,0BAA0B,EAAE,OACK,CAAA;AAC9C,eAAO,MAAM,+BAA+B,EAAE,OACA,CAAA;AAC9C,eAAO,MAAM,mCAAmC,EAAE,OACJ,CAAA;AAE9C,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAA;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC7B;AAED,eAAO,MAAM,wBAAwB,EAAE,uBAQrC,CAAA;AAEF,wBAAgB,sBAAsB,CACpC,SAAS,CAAC,EAAE,sBAAsB,GACjC,uBAAuB,CAYzB"}

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

@@ -0,0 +1,29 @@
+export const SPENDING_LIMITS_POLICY_ADDRESS = '0x000000000033212E272655D8a22402Db819477A6';
+export const TIME_FRAME_POLICY_ADDRESS = '0x0000000000D30f611fA3bf652ac6879428586930';
+export const SUDO_POLICY_ADDRESS = '0x0000000000FEEc8D74e3143fBaBbca515358d869';
+export const UNIVERSAL_ACTION_POLICY_ADDRESS = '0x0000000000714Cf48FcF88A0bFBa70d313415032';
+export const ARG_POLICY_ADDRESS = '0x0000000000167edE64D8751daACDdC0312565a73';
+export const USAGE_LIMIT_POLICY_ADDRESS = '0x00000000001d4479FA2A947026204d0283ceDe4B';
+export const VALUE_LIMIT_POLICY_ADDRESS = '0x000000000021dC45451291BCDfc9f0B46d6f0278';
+export const INTENT_EXECUTION_POLICY_ADDRESS = '0xe9eA54d063975cDee9e06b7636d5563d95a7A23C';
+export const INTENT_EXECUTION_POLICY_ADDRESS_DEV = '0xa09b47de6e510cbdc18b97e9239bedcb44fb4901';
+export const DEFAULT_POLICY_ADDRESSES = Object.freeze({
+    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,
+});
+export function resolvePolicyAddresses(overrides) {
+    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,
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { InternalPermit2ClaimPolicy, Permit2ClaimMessage } from '../../policies/claim/permit2.js';
+import type { CrossChainPermit, Permit2ClaimPolicy, SessionPolicy } from '../types.js';
+export declare function expandCrossChainPermit(permit: CrossChainPermit, environment: 'production' | 'development'): {
+    readonly claim: Permit2ClaimPolicy;
+    readonly fallbackPolicies: readonly SessionPolicy[];
+};
+export declare function permit2ClaimPolicyMatchesMessage(policy: Permit2ClaimPolicy, message: Permit2ClaimMessage): boolean;
+export declare function selectPermit2ClaimPolicyForMessage(policies: readonly Permit2ClaimPolicy[], message: Permit2ClaimMessage): Permit2ClaimPolicy | undefined;
+export declare function resolvePermit2ClaimPolicy(policy: Permit2ClaimPolicy): InternalPermit2ClaimPolicy;
+//# sourceMappingURL=claim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claim.d.ts","sourceRoot":"","sources":["../../../../../../modules/validators/smart-sessions/policies/claim.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,0BAA0B,EAC1B,mBAAmB,EACpB,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,aAAa,EACd,MAAM,UAAU,CAAA;AAEjB,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,YAAY,GAAG,aAAa,GACxC;IACD,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAA;IAClC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,aAAa,EAAE,CAAA;CACpD,CA+CA;AAED,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAgDT;AAED,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,OAAO,EAAE,mBAAmB,GAC3B,kBAAkB,GAAG,SAAS,CAOhC;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,kBAAkB,GACzB,0BAA0B,CAwB5B"}

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

@@ -0,0 +1,106 @@
+import { isAddressEqual } from 'viem';
+import { FAR_FUTURE_MS } from '../../permissions.js';
+import { getArbitersForSettlementLayers } from '../../policies/claim/arbiters.js';
+export function expandCrossChainPermit(permit, environment) {
+    const sourceTokens = permit.from?.length
+        ? permit.from.map(({ chain, token }) => ({ chain, address: token }))
+        : undefined;
+    const destinationTokens = permit.to?.length
+        ? permit.to.map(({ chain, token }) => ({ chain, address: token }))
+        : undefined;
+    const recipientsList = (permit.to ?? [])
+        .filter(({ recipient }) => recipient !== undefined)
+        .map(({ chain, recipient }) => ({
+        chain,
+        address: recipient,
+    }));
+    const permitDeadline = permit.validAfter !== undefined || permit.validUntil !== undefined
+        ? { min: permit.validAfter, max: permit.validUntil }
+        : undefined;
+    const claim = {
+        type: 'permit2',
+        spenders: getArbitersForSettlementLayers(permit.settlementLayers, environment === 'development'),
+        sourceTokens,
+        destinationTokens,
+        recipients: recipientsList.length ? recipientsList : undefined,
+        recipientIsAccount: permit.recipientIsAccount,
+        permitDeadline,
+        fillDeadline: permit.fillDeadline,
+    };
+    const fallbackPolicies = [];
+    const limits = (permit.from ?? [])
+        .filter(({ maxAmount }) => maxAmount !== undefined)
+        .map(({ token, maxAmount }) => ({ token, amount: maxAmount }));
+    if (limits.length)
+        fallbackPolicies.push({ type: 'spending-limits', limits });
+    if (permitDeadline) {
+        fallbackPolicies.push({
+            type: 'time-frame',
+            validUntil: permit.validUntil === undefined
+                ? FAR_FUTURE_MS
+                : Number(permit.validUntil * 1000n),
+            validAfter: permit.validAfter === undefined ? 0 : Number(permit.validAfter * 1000n),
+        });
+    }
+    return { claim, fallbackPolicies };
+}
+export function permit2ClaimPolicyMatchesMessage(policy, message) {
+    if (policy.spenders?.length &&
+        !policy.spenders.some((spender) => isAddressEqual(spender, message.spender))) {
+        return false;
+    }
+    if (policy.sourceTokens?.length) {
+        const allowed = new Set(policy.sourceTokens.map(({ address }) => address.toLowerCase()));
+        if (!message.permitted.every(({ token }) => allowed.has(token.toLowerCase()))) {
+            return false;
+        }
+    }
+    const targetChain = message.mandate.target.targetChain;
+    if (policy.destinationTokens?.length) {
+        const allowed = new Set(policy.destinationTokens
+            .filter(({ chain }) => BigInt(chain.id) === targetChain)
+            .map(({ address }) => address.toLowerCase()));
+        if (!message.mandate.target.tokenOut.every(({ token }) => allowed.has(token.toLowerCase()))) {
+            return false;
+        }
+    }
+    if (policy.recipients?.length) {
+        const recipients = policy.recipients.filter(({ chain }) => BigInt(chain.id) === targetChain);
+        if (recipients.length &&
+            !recipients.some(({ address }) => address === 'any' ||
+                isAddressEqual(address, message.mandate.target.recipient))) {
+            return false;
+        }
+    }
+    return true;
+}
+export function selectPermit2ClaimPolicyForMessage(policies, message) {
+    if (policies.length <= 1)
+        return policies[0];
+    return (policies.find((policy) => permit2ClaimPolicyMatchesMessage(policy, message)) ?? policies[0]);
+}
+export function resolvePermit2ClaimPolicy(policy) {
+    return {
+        type: 'permit2-claim',
+        arbiters: policy.spenders ? [...policy.spenders] : undefined,
+        tokensIn: policy.sourceTokens?.map(({ chain, address }) => ({
+            chainId: chain.id,
+            token: address,
+        })),
+        tokensOut: policy.destinationTokens?.map(({ chain, address }) => ({
+            chainId: chain.id,
+            token: address,
+        })),
+        recipients: policy.recipients?.map(({ chain, address }) => ({
+            chainId: chain.id,
+            recipient: address,
+        })),
+        recipientIsSponsor: policy.recipientIsAccount,
+        expiryBounds: policy.permitDeadline,
+        fillExpiryBounds: policy.fillDeadline?.map(({ chain, min, max }) => ({
+            chainId: chain.id,
+            min,
+            max,
+        })),
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { ResolvedPolicy, SessionPolicy } from '../types.js';
+import { type ResolvedPolicyAddresses } from './addresses.js';
+export declare function encodeSessionPolicy(policy: SessionPolicy, environment: 'production' | 'development', addresses?: ResolvedPolicyAddresses): ResolvedPolicy;
+//# sourceMappingURL=encode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../../../../modules/validators/smart-sessions/policies/encode.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAEV,cAAc,EACd,aAAa,EAGd,MAAM,UAAU,CAAA;AACjB,OAAO,EAIL,KAAK,uBAAuB,EAC7B,MAAM,aAAa,CAAA;AAiGpB,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,YAAY,GAAG,aAAa,EACzC,SAAS,GAAE,uBAAkD,GAC5D,cAAc,CA6JhB"}

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

@@ -0,0 +1,197 @@
+import { encodeAbiParameters, encodePacked, isHex, padHex, toHex, zeroHash, } from 'viem';
+import { DEFAULT_POLICY_ADDRESSES, INTENT_EXECUTION_POLICY_ADDRESS, INTENT_EXECUTION_POLICY_ADDRESS_DEV, } from './addresses.js';
+const conditionIds = {
+    equal: 0,
+    greaterThan: 1,
+    lessThan: 2,
+    greaterThanOrEqual: 3,
+    lessThanOrEqual: 4,
+    notEqual: 5,
+    inRange: 6,
+};
+function encodeRule(rule) {
+    return {
+        condition: conditionIds[rule.condition],
+        offset: rule.calldataOffset,
+        isLimited: rule.usageLimit !== undefined,
+        ref: isHex(rule.referenceValue)
+            ? padHex(rule.referenceValue)
+            : toHex(rule.referenceValue, { size: 32 }),
+        usage: { limit: rule.usageLimit ?? 0n, used: 0n },
+    };
+}
+function compileExpression(expression) {
+    const rules = [];
+    const nodes = [];
+    const walk = (node) => {
+        if (node.type === 'rule') {
+            const ruleIndex = rules.push(encodeRule(node.rule)) - 1;
+            const nodeIndex = nodes.length;
+            nodes.push(BigInt(ruleIndex) << 2n);
+            return nodeIndex;
+        }
+        if (node.type === 'not') {
+            const child = walk(node.child);
+            const nodeIndex = nodes.length;
+            nodes.push(1n | (BigInt(child) << 10n));
+            return nodeIndex;
+        }
+        const left = walk(node.left);
+        const right = walk(node.right);
+        const nodeIndex = nodes.length;
+        nodes.push((node.type === 'and' ? 2n : 3n) |
+            (BigInt(left) << 10n) |
+            (BigInt(right) << 18n));
+        return nodeIndex;
+    };
+    const rootNodeIndex = walk(expression);
+    if (rules.length > 128) {
+        throw new Error(`ArgPolicy expression has ${rules.length} rules, max is 128`);
+    }
+    if (nodes.length > 256) {
+        throw new Error(`ArgPolicy expression has ${nodes.length} nodes, max is 256`);
+    }
+    return { rules, packedNodes: nodes, rootNodeIndex };
+}
+export function encodeSessionPolicy(policy, environment, addresses = DEFAULT_POLICY_ADDRESSES) {
+    switch (policy.type) {
+        case 'sudo':
+            return { policy: addresses.sudo, initData: '0x' };
+        case 'intent-execution':
+            return {
+                policy: environment === 'development'
+                    ? INTENT_EXECUTION_POLICY_ADDRESS_DEV
+                    : INTENT_EXECUTION_POLICY_ADDRESS,
+                initData: '0x',
+            };
+        case 'universal-action': {
+            const rules = Array.from({ length: 16 }, () => ({
+                condition: 0,
+                offset: 0n,
+                isLimited: false,
+                ref: zeroHash,
+                usage: { limit: 0n, used: 0n },
+            }));
+            if (policy.rules.length > rules.length) {
+                throw new Error('Universal action policy supports at most 16 rules');
+            }
+            policy.rules.forEach((rule, index) => {
+                rules[index] = encodeRule(rule);
+            });
+            return {
+                policy: addresses.universalAction,
+                initData: encodeAbiParameters([
+                    {
+                        name: 'ActionConfig',
+                        type: 'tuple',
+                        components: [
+                            { name: 'valueLimitPerUse', type: 'uint256' },
+                            {
+                                name: 'paramRules',
+                                type: 'tuple',
+                                components: [
+                                    { name: 'length', type: 'uint256' },
+                                    {
+                                        name: 'rules',
+                                        type: 'tuple[16]',
+                                        components: [
+                                            { name: 'condition', type: 'uint8' },
+                                            { name: 'offset', type: 'uint64' },
+                                            { name: 'isLimited', type: 'bool' },
+                                            { name: 'ref', type: 'bytes32' },
+                                            {
+                                                name: 'usage',
+                                                type: 'tuple',
+                                                components: [
+                                                    { name: 'limit', type: 'uint256' },
+                                                    { name: 'used', type: 'uint256' },
+                                                ],
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ], [
+                    {
+                        valueLimitPerUse: policy.valueLimitPerUse ?? 0n,
+                        paramRules: { length: BigInt(policy.rules.length), rules },
+                    },
+                ]),
+            };
+        }
+        case 'arg-policy': {
+            const compiled = compileExpression(policy.expression);
+            return {
+                policy: addresses.argPolicy,
+                initData: encodeAbiParameters([
+                    {
+                        name: 'ActionConfig',
+                        type: 'tuple',
+                        components: [
+                            { name: 'valueLimitPerUse', type: 'uint256' },
+                            {
+                                name: 'paramRules',
+                                type: 'tuple',
+                                components: [
+                                    { name: 'rootNodeIndex', type: 'uint8' },
+                                    {
+                                        name: 'rules',
+                                        type: 'tuple[]',
+                                        components: [
+                                            { name: 'condition', type: 'uint8' },
+                                            { name: 'offset', type: 'uint64' },
+                                            { name: 'isLimited', type: 'bool' },
+                                            { name: 'ref', type: 'bytes32' },
+                                            {
+                                                name: 'usage',
+                                                type: 'tuple',
+                                                components: [
+                                                    { name: 'limit', type: 'uint256' },
+                                                    { name: 'used', type: 'uint256' },
+                                                ],
+                                            },
+                                        ],
+                                    },
+                                    { name: 'packedNodes', type: 'uint256[]' },
+                                ],
+                            },
+                        ],
+                    },
+                ], [
+                    {
+                        valueLimitPerUse: policy.valueLimitPerUse ?? 0n,
+                        paramRules: compiled,
+                    },
+                ]),
+            };
+        }
+        case 'spending-limits':
+            return {
+                policy: addresses.spendingLimits,
+                initData: encodeAbiParameters([{ type: 'address[]' }, { type: 'uint256[]' }], [
+                    policy.limits.map(({ token }) => token),
+                    policy.limits.map(({ amount }) => amount),
+                ]),
+            };
+        case 'time-frame':
+            return {
+                policy: addresses.timeFrame,
+                initData: encodePacked(['uint48', 'uint48'], [
+                    Math.floor(policy.validUntil / 1000),
+                    Math.floor(policy.validAfter / 1000),
+                ]),
+            };
+        case 'usage-limit':
+            return {
+                policy: addresses.usageLimit,
+                initData: encodePacked(['uint128'], [policy.limit]),
+            };
+        case 'value-limit':
+            return {
+                policy: addresses.valueLimit,
+                initData: encodeAbiParameters([{ type: 'uint256' }], [policy.limit]),
+            };
+    }
+}

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

@@ -0,0 +1,16 @@
+import { type Address, type Hex } from 'viem';
+import { DEFAULT_POLICY_ADDRESSES } from './policies/addresses.js';
+import type { Session, SessionData, SessionDefinition } from './types.js';
+export declare const SMART_SESSIONS_FALLBACK_TARGET_FLAG: Address;
+export declare const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG: Hex;
+export declare const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION: "0x00000002";
+export declare const DUMMY_PRECLAIMOP_TARGET: "0x0000000000000000000000000000000000000420";
+export declare const DUMMY_PRECLAIMOP_SELECTOR: "0x69123456";
+export interface ResolveSessionOptions {
+    readonly environment?: 'production' | 'development';
+    readonly wrappedNativeToken?: Address;
+}
+export declare function resolveSessionData(definition: SessionDefinition, options?: ResolveSessionOptions): SessionData;
+export declare function toSession(definition: SessionDefinition, options?: ResolveSessionOptions): Session;
+export { DEFAULT_POLICY_ADDRESSES };
+//# sourceMappingURL=resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../../modules/validators/smart-sessions/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,GAAG,EAAgC,MAAM,MAAM,CAAA;AAU3E,OAAO,EACL,wBAAwB,EAEzB,MAAM,sBAAsB,CAAA;AAM7B,OAAO,KAAK,EAEV,OAAO,EAEP,WAAW,EACX,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,mCAAmC,EAAE,OACJ,CAAA;AAC9C,eAAO,MAAM,4CAA4C,EAAE,GAAkB,CAAA;AAC7E,eAAO,MAAM,2EAA2E,EACtF,YAAqB,CAAA;AACvB,eAAO,MAAM,uBAAuB,EAClC,4CAAqD,CAAA;AACvD,eAAO,MAAM,yBAAyB,EAAG,YAAqB,CAAA;AAU9D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,YAAY,GAAG,aAAa,CAAA;IAGnD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CACtC;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,iBAAiB,EAC7B,OAAO,GAAE,qBAA0B,GAClC,WAAW,CA0Fb;AAED,wBAAgB,SAAS,CACvB,UAAU,EAAE,iBAAiB,EAC7B,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAyBT;AAED,OAAO,EAAE,wBAAwB,EAAE,CAAA"}

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

@@ -0,0 +1,120 @@
+import { toFunctionSelector, zeroHash } from 'viem';
+import { defineValidator } from '../definition.js';
+import { resolvePermissions } from '../permissions.js';
+import { encodePermit2ClaimPolicyInitData, PERMIT2_CLAIM_POLICY_ADDRESS, } from '../policies/claim/permit2.js';
+import { resolveValidator } from '../resolve.js';
+import { resolveCrossChainPermission } from './cross-chain-permits.js';
+import { getPermissionIdFromData } from './digest.js';
+import { DEFAULT_POLICY_ADDRESSES, resolvePolicyAddresses, } from './policies/addresses.js';
+import { expandCrossChainPermit, resolvePermit2ClaimPolicy, } from './policies/claim.js';
+import { encodeSessionPolicy } from './policies/encode.js';
+export const SMART_SESSIONS_FALLBACK_TARGET_FLAG = '0x0000000000000000000000000000000000000001';
+export const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = '0x00000001';
+export const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = '0x00000002';
+export const DUMMY_PRECLAIMOP_TARGET = '0x0000000000000000000000000000000000000420';
+export const DUMMY_PRECLAIMOP_SELECTOR = '0x69123456';
+function usesEns(definition) {
+    return (definition.type === 'ens' ||
+        (definition.type === 'multi-factor' &&
+            definition.validators.some((validator) => validator.type === 'ens')));
+}
+export function resolveSessionData(definition, options = {}) {
+    if (usesEns(definition.owners)) {
+        throw new Error('ENS owners are not supported for smart sessions');
+    }
+    const environment = options.environment ?? 'production';
+    const addresses = resolvePolicyAddresses(definition.policyAddresses);
+    const validator = resolveValidator(defineValidator(definition.owners, 'session-validator'));
+    const sudoAction = {
+        actionTargetSelector: SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
+        actionTarget: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
+        actionPolicies: [{ policy: addresses.sudo, initData: '0x' }],
+    };
+    const userActions = definition.permissions?.length
+        ? resolvePermissions(definition.permissions)
+        : [];
+    const expandedPermits = (definition.crossChainPermits ?? []).map((input) => expandCrossChainPermit(resolveCrossChainPermission(input), environment));
+    const permitFallbackPolicies = expandedPermits.flatMap(({ fallbackPolicies }) => fallbackPolicies);
+    const injectedActions = [
+        // Native-wrap `deposit()` is only permitted when the caller supplies the
+        // chain's wrapped-native token (e.g. via `RhinestoneSDK.createSession`,
+        // which resolves it from `/chains`).
+        ...(options.wrappedNativeToken
+            ? [
+                {
+                    target: options.wrappedNativeToken,
+                    selector: toFunctionSelector({
+                        type: 'function',
+                        name: 'deposit',
+                        inputs: [],
+                        outputs: [],
+                        stateMutability: 'payable',
+                    }),
+                },
+            ]
+            : []),
+        {
+            policies: [{ type: 'intent-execution' }, ...permitFallbackPolicies],
+        },
+        {
+            target: DUMMY_PRECLAIMOP_TARGET,
+            selector: DUMMY_PRECLAIMOP_SELECTOR,
+            policies: [{ type: 'sudo' }],
+        },
+    ];
+    const actions = userActions.length || permitFallbackPolicies.length
+        ? [...userActions, ...injectedActions].map((action) => ({
+            actionTargetSelector: 'selector' in action
+                ? action.selector
+                : SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
+            actionTarget: 'target' in action
+                ? action.target
+                : SMART_SESSIONS_FALLBACK_TARGET_FLAG,
+            actionPolicies: action.policies?.map((policy) => encodeSessionPolicy(policy, environment, addresses)) ?? [{ policy: addresses.sudo, initData: '0x' }],
+        }))
+        : [sudoAction];
+    const claimPolicies = [
+        ...(definition.claimPolicies ?? []),
+        ...expandedPermits.map(({ claim }) => claim),
+    ].map((policy) => ({
+        policy: PERMIT2_CLAIM_POLICY_ADDRESS,
+        initData: encodePermit2ClaimPolicyInitData(resolvePermit2ClaimPolicy(policy)),
+    }));
+    return {
+        sessionValidator: validator.address,
+        sessionValidatorInitData: validator.initData,
+        salt: zeroHash,
+        erc7739Policies: {
+            allowedERC7739Content: [
+                { contentNames: [''], appDomainSeparator: zeroHash },
+            ],
+            erc1271Policies: [{ policy: addresses.sudo, initData: '0x' }],
+        },
+        actions,
+        claimPolicies,
+    };
+}
+export function toSession(definition, options = {}) {
+    const environment = options.environment ?? 'production';
+    const data = resolveSessionData(definition, {
+        environment,
+        ...(options.wrappedNativeToken
+            ? { wrappedNativeToken: options.wrappedNativeToken }
+            : {}),
+    });
+    const expandedClaims = (definition.crossChainPermits ?? []).map((input) => expandCrossChainPermit(resolveCrossChainPermission(input), environment)
+        .claim);
+    return {
+        chain: definition.chain,
+        owners: definition.owners,
+        hasExplicitPermissions: Boolean(definition.permissions?.length),
+        permissionId: getPermissionIdFromData(data),
+        sessionValidator: data.sessionValidator,
+        sessionValidatorInitData: data.sessionValidatorInitData,
+        salt: data.salt,
+        erc7739Policies: data.erc7739Policies,
+        actions: data.actions,
+        claimPolicies: [...(definition.claimPolicies ?? []), ...expandedClaims],
+    };
+}
+export { DEFAULT_POLICY_ADDRESSES };