@rhinestone/sdk 2.0.0-beta.9 → 2.1.0

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 };

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

@@ -0,0 +1,14 @@
+import { type Hex } from 'viem';
+import type { SmartSessionEnableContributionData } from '../smart-session-signature-types.js';
+import type { ResolvedSessionSignerSet } from './types.js';
+export declare const SMART_SESSION_MODE_USE: "0x00";
+export declare const SMART_SESSION_MODE_ENABLE: "0x01";
+export declare function encodeSmartSessionSignature(signers: ResolvedSessionSignerSet, validatorSignature: Hex): Hex;
+export declare function encodeSmartSessionContribution(input: {
+    readonly mode: 'use' | 'enable-and-use' | 'pre-claim' | 'notarized';
+    readonly permissionId: Hex;
+    readonly signature: Hex;
+    readonly claimPolicyData?: Hex;
+    readonly enableData?: SmartSessionEnableContributionData;
+}): Hex;
+//# sourceMappingURL=signature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../../../modules/validators/smart-sessions/signature.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,GAAG,EAKT,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,kCAAkC,CAAA;AAE1F,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAIvD,eAAO,MAAM,sBAAsB,EAAG,MAAe,CAAA;AACrD,eAAO,MAAM,yBAAyB,EAAG,MAAe,CAAA;AAExD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,wBAAwB,EACjC,kBAAkB,EAAE,GAAG,GACtB,GAAG,CA4BL;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,gBAAgB,GAAG,WAAW,GAAG,WAAW,CAAA;IACnE,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;IACvB,QAAQ,CAAC,eAAe,CAAC,EAAE,GAAG,CAAA;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,kCAAkC,CAAA;CACzD,GAAG,GAAG,CAgJN"}

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

@@ -0,0 +1,167 @@
+import { LibZip } from 'solady';
+import { encodeAbiParameters, encodePacked, maxUint256, size, zeroAddress, zeroHash, } from 'viem';
+import { getPermissionId, getSessionData } from './digest.js';
+const SCOPE_MULTICHAIN = 0;
+const RESET_PERIOD_ONE_WEEK = 6;
+export const SMART_SESSION_MODE_USE = '0x00';
+export const SMART_SESSION_MODE_ENABLE = '0x01';
+export function encodeSmartSessionSignature(signers, validatorSignature) {
+    const permissionId = getPermissionId(signers.session);
+    if (!signers.verifyExecutions) {
+        return encodeSmartSessionContribution({
+            mode: 'notarized',
+            permissionId,
+            signature: validatorSignature,
+            ...(signers.claimPolicyData
+                ? { claimPolicyData: signers.claimPolicyData }
+                : {}),
+        });
+    }
+    if (!signers.enableData) {
+        return encodeSmartSessionContribution({
+            mode: 'use',
+            permissionId,
+            signature: validatorSignature,
+        });
+    }
+    return encodeSmartSessionContribution({
+        mode: 'enable-and-use',
+        permissionId,
+        signature: validatorSignature,
+        enableData: {
+            ...signers.enableData,
+            session: getSessionData(signers.session),
+        },
+    });
+}
+export function encodeSmartSessionContribution(input) {
+    if (input.mode !== 'enable-and-use') {
+        if (input.mode === 'notarized') {
+            return encodePacked(['bytes1', 'bytes32', 'uint256', 'bytes', 'bytes'], [
+                SMART_SESSION_MODE_USE,
+                input.permissionId,
+                BigInt(64 + size(input.signature)),
+                input.signature,
+                input.claimPolicyData ?? '0x',
+            ]);
+        }
+        return encodePacked(['bytes1', 'bytes32', 'bytes'], [SMART_SESSION_MODE_USE, input.permissionId, input.signature]);
+    }
+    if (!input.enableData) {
+        throw new Error('Enable-and-use signatures require enable data');
+    }
+    const compressed = LibZip.flzCompress(encodeAbiParameters([
+        {
+            type: 'tuple',
+            name: 'enableData',
+            components: [
+                { type: 'bytes', name: 'allocatorSig' },
+                { type: 'bytes', name: 'userSig' },
+                { type: 'uint256', name: 'expires' },
+                {
+                    type: 'tuple',
+                    name: 'enableSession',
+                    components: [
+                        { type: 'uint8', name: 'chainDigestIndex' },
+                        {
+                            type: 'tuple[]',
+                            name: 'hashesAndChainIds',
+                            components: [
+                                { type: 'uint64', name: 'chainId' },
+                                { type: 'bytes32', name: 'sessionDigest' },
+                            ],
+                        },
+                        {
+                            type: 'tuple',
+                            name: 'session',
+                            components: [
+                                { type: 'address', name: 'sessionValidator' },
+                                { type: 'bytes', name: 'sessionValidatorInitData' },
+                                { type: 'bytes32', name: 'salt' },
+                                {
+                                    type: 'tuple[]',
+                                    name: 'actions',
+                                    components: [
+                                        { type: 'bytes4', name: 'actionTargetSelector' },
+                                        { type: 'address', name: 'actionTarget' },
+                                        {
+                                            type: 'tuple[]',
+                                            name: 'actionPolicies',
+                                            components: [
+                                                { type: 'address', name: 'policy' },
+                                                { type: 'bytes', name: 'initData' },
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    type: 'tuple[]',
+                                    name: 'claimPolicies',
+                                    components: [
+                                        { type: 'address', name: 'policy' },
+                                        { type: 'bytes', name: 'initData' },
+                                    ],
+                                },
+                                {
+                                    type: 'tuple',
+                                    name: 'erc7739Policies',
+                                    components: [
+                                        {
+                                            type: 'tuple[]',
+                                            name: 'allowedERC7739Content',
+                                            components: [
+                                                {
+                                                    type: 'bytes32',
+                                                    name: 'appDomainSeparator',
+                                                },
+                                                { type: 'string[]', name: 'contentNames' },
+                                            ],
+                                        },
+                                        {
+                                            type: 'tuple[]',
+                                            name: 'erc1271Policies',
+                                            components: [
+                                                { type: 'address', name: 'policy' },
+                                                { type: 'bytes', name: 'initData' },
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            type: 'tuple',
+            name: 'config',
+            components: [
+                { type: 'uint8', name: 'scope' },
+                { type: 'uint8', name: 'resetPeriod' },
+                { type: 'address', name: 'allocator' },
+                { type: 'bytes32', name: 'permissionId' },
+            ],
+        },
+        { type: 'bytes' },
+    ], [
+        {
+            allocatorSig: zeroHash,
+            userSig: input.enableData.userSignature,
+            expires: maxUint256,
+            enableSession: {
+                chainDigestIndex: input.enableData.sessionToEnableIndex,
+                hashesAndChainIds: [...input.enableData.hashesAndChainIds],
+                session: input.enableData.session,
+            },
+        },
+        {
+            scope: SCOPE_MULTICHAIN,
+            resetPeriod: RESET_PERIOD_ONE_WEEK,
+            allocator: zeroAddress,
+            permissionId: input.permissionId,
+        },
+        input.signature,
+    ]));
+    return encodePacked(['bytes1', 'bytes'], [SMART_SESSION_MODE_ENABLE, compressed]);
+}

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

@@ -0,0 +1,19 @@
+import type { Address, Hex } from 'viem';
+import type { EvmChainReference } from '../../../chains/types.js';
+import type { RpcReadPort } from '../../../clients/rpc/port.js';
+import type { Session } from './types.js';
+export declare function readSessionEnabled(input: {
+    readonly rpc: RpcReadPort;
+    readonly chain: EvmChainReference;
+    readonly account: Address;
+    readonly session: Session;
+    readonly environment: 'production' | 'development';
+}): Promise<boolean>;
+export declare function readSessionNonce(input: {
+    readonly rpc: RpcReadPort;
+    readonly chain: EvmChainReference;
+    readonly account: Address;
+    readonly lockTag: Hex;
+    readonly environment: 'production' | 'development';
+}): Promise<bigint>;
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../modules/validators/smart-sessions/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAG5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AA4BtC,wBAAsB,kBAAkB,CAAC,KAAK,EAAE;IAC9C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,CAAA;CACnD,GAAG,OAAO,CAAC,OAAO,CAAC,CAUnB;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC5C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,CAAA;CACnD,GAAG,OAAO,CAAC,MAAM,CAAC,CAUlB"}

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

@@ -0,0 +1,42 @@
+import { getPermissionId } from './digest.js';
+import { getSmartSessionEmissaryAddress } from './module.js';
+const permissionEnabledAbi = [
+    {
+        type: 'function',
+        name: 'isPermissionEnabled',
+        inputs: [
+            { name: 'account', type: 'address' },
+            { name: 'permissionId', type: 'bytes32' },
+        ],
+        outputs: [{ name: 'isEnabled', type: 'bool' }],
+        stateMutability: 'view',
+    },
+];
+const nonceAbi = [
+    {
+        type: 'function',
+        name: 'getNonce',
+        inputs: [
+            { name: 'sponsor', type: 'address' },
+            { name: 'lockTag', type: 'bytes12' },
+        ],
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view',
+    },
+];
+export async function readSessionEnabled(input) {
+    return input.rpc.readContract({ chain: input.chain }, {
+        address: getSmartSessionEmissaryAddress(input.environment),
+        abi: permissionEnabledAbi,
+        functionName: 'isPermissionEnabled',
+        args: [input.account, getPermissionId(input.session)],
+    });
+}
+export async function readSessionNonce(input) {
+    return input.rpc.readContract({ chain: input.chain }, {
+        address: getSmartSessionEmissaryAddress(input.environment),
+        abi: nonceAbi,
+        functionName: 'getNonce',
+        args: [input.account, input.lockTag],
+    });
+}