@rhinestone/sdk 0.2.0 → 0.3.0

package/dist/execution/smart-session.js

@@ -0,0 +1,83 @@
+import { http, createPublicClient, encodePacked, keccak256, encodeAbiParameters, } from 'viem';
+import { getSmartAccount, getAddress } from '../accounts';
+import { getBundlerClient } from '../accounts/utils';
+import { getPermissionId, isSessionEnabled, getSessionAllowedERC7739Content, getAccountEIP712Domain, getEnableSessionCall, } from '../modules/validators';
+import { getOrderBundleHash, hashMultichainCompactWithoutDomainSeparator, } from '../orchestrator/utils';
+async function enableSmartSession(chain, config, session) {
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(),
+    });
+    const address = await getAddress(config);
+    const isEnabled = await isSessionEnabled(publicClient, address, getPermissionId(session));
+    if (isEnabled) {
+        return;
+    }
+    const smartAccount = await getSmartAccount(config, publicClient, chain);
+    const bundlerClient = getBundlerClient(config, publicClient);
+    const enableSessionCall = await getEnableSessionCall(chain, session);
+    const opHash = await bundlerClient.sendUserOperation({
+        account: smartAccount,
+        calls: [enableSessionCall],
+    });
+    await bundlerClient.waitForUserOperationReceipt({
+        hash: opHash,
+    });
+}
+async function hashErc7739(sourceChain, orderPath, accountAddress) {
+    const publicClient = createPublicClient({
+        chain: sourceChain,
+        transport: http(),
+    });
+    const { appDomainSeparator, contentsType } = await getSessionAllowedERC7739Content(sourceChain);
+    const orderBundleHash = getOrderBundleHash(orderPath[0].orderBundle);
+    // Create hash following ERC-7739 TypedDataSign workflow
+    const typedDataSignTypehash = keccak256(encodePacked(['string'], [
+        'TypedDataSign(MultichainCompact contents,string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)'.concat(contentsType),
+    ]));
+    // Original struct hash
+    const structHash = hashMultichainCompactWithoutDomainSeparator(orderPath[0].orderBundle);
+    const { name, version, chainId, verifyingContract, salt } = await getAccountEIP712Domain(publicClient, accountAddress);
+    // Final hash according to ERC-7739
+    const hash = keccak256(encodePacked(['bytes2', 'bytes32', 'bytes32'], [
+        '0x1901',
+        appDomainSeparator,
+        keccak256(encodeAbiParameters([
+            { name: 'typedDataSignTypehash', type: 'bytes32' },
+            { name: 'structHash', type: 'bytes32' },
+            { name: 'name', type: 'bytes32' },
+            { name: 'version', type: 'bytes32' },
+            { name: 'chainId', type: 'uint256' },
+            { name: 'verifyingContract', type: 'address' },
+            { name: 'salt', type: 'bytes32' },
+        ], [
+            typedDataSignTypehash,
+            structHash,
+            keccak256(encodePacked(['string'], [name])),
+            keccak256(encodePacked(['string'], [version])),
+            BigInt(Number(chainId)),
+            verifyingContract,
+            salt,
+        ])),
+    ]));
+    return {
+        hash,
+        appDomainSeparator,
+        contentsType,
+        structHash,
+        orderBundleHash,
+    };
+}
+function getSessionSignature(signature, appDomainSeparator, structHash, contentsType, withSession) {
+    const erc7739Signature = encodePacked(['bytes', 'bytes32', 'bytes32', 'string', 'uint16'], [
+        signature,
+        appDomainSeparator,
+        structHash,
+        contentsType,
+        contentsType.length,
+    ]);
+    // Pack with permissionId for smart session
+    const wrappedSignature = encodePacked(['bytes32', 'bytes'], [getPermissionId(withSession), erc7739Signature]);
+    return wrappedSignature;
+}
+export { enableSmartSession, hashErc7739, getSessionSignature };

package/dist/index.d.ts

@@ -1,10 +1,21 @@
 import { RhinestoneAccountConfig, Transaction } from './types';
+import { type TransactionResult } from './execution';
 declare function createRhinestoneAccount(config: RhinestoneAccountConfig): Promise<{
     config: RhinestoneAccountConfig;
-    sendTransactions: (transaction: Transaction) => Promise<bigint>;
-    waitForExecution: ({ id }: {
-        id: bigint;
-    }) => Promise<import("./services/orchestrator").BundleResult>;
+    sendTransactions: (transaction: Transaction) => Promise<TransactionResult>;
+    waitForExecution: (result: TransactionResult) => Promise<import("./orchestrator").BundleResult | {
+        actualGasCost: bigint;
+        actualGasUsed: bigint;
+        entryPoint: import("abitype").Address;
+        logs: import("viem").Log<bigint, number, false>[];
+        nonce: bigint;
+        paymaster?: `0x${string}` | undefined;
+        reason?: string | undefined | undefined;
+        receipt: import("viem").TransactionReceipt<bigint, number, "success" | "reverted">;
+        sender: import("abitype").Address;
+        success: boolean;
+        userOpHash: import("viem").Hash;
+    }>;
     getAddress: () => Promise<`0x${string}`>;
 }>;
 export { createRhinestoneAccount };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAO9D,iBAAe,uBAAuB,CAAC,MAAM,EAAE,uBAAuB;;oCACvB,WAAW;+BAIhB;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE;;GAcvD;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAC9D,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,aAAa,CAAA;AAGpB,iBAAe,uBAAuB,CAAC,MAAM,EAAE,uBAAuB;;oCAC7B,WAAW;+BAIhB,iBAAiB;;;;;;;;;;;;;;GAcpD;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/index.js

@@ -1,15 +1,15 @@
-import { sendTransactions as sendTransactionsInternal, waitForExecution as waitForExecutionInternal, } from './services/transaction';
-import { getAddress as getAddressInternal } from './services/account';
+import { sendTransaction as sendTransactionInternal, waitForExecution as waitForExecutionInternal, } from './execution';
+import { getAddress as getAddressInternal } from './accounts';
 async function createRhinestoneAccount(config) {
-    const sendTransactions = async (transaction) => {
-        return await sendTransactionsInternal(config, transaction);
-    };
-    const waitForExecution = async ({ id }) => {
-        return await waitForExecutionInternal(config, id);
-    };
-    const getAddress = async () => {
-        return await getAddressInternal(config);
-    };
+    function sendTransactions(transaction) {
+        return sendTransactionInternal(config, transaction);
+    }
+    function waitForExecution(result) {
+        return waitForExecutionInternal(config, result);
+    }
+    function getAddress() {
+        return getAddressInternal(config);
+    }
     return {
         config,
         sendTransactions,

package/dist/modules/abi/smart-sessions.d.ts

@@ -0,0 +1,42 @@
+declare const enableSessionsAbi: {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+        components: ({
+            name: string;
+            type: string;
+            internalType: string;
+            components?: undefined;
+        } | {
+            name: string;
+            type: string;
+            internalType: string;
+            components: ({
+                name: string;
+                type: string;
+                internalType: string;
+                components?: undefined;
+            } | {
+                name: string;
+                type: string;
+                internalType: string;
+                components: {
+                    name: string;
+                    type: string;
+                    internalType: string;
+                }[];
+            })[];
+        })[];
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+}[];
+export { enableSessionsAbi };
+//# sourceMappingURL=smart-sessions.d.ts.map

package/dist/modules/abi/smart-sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../modules/abi/smart-sessions.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8HtB,CAAA;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/modules/abi/smart-sessions.js

@@ -0,0 +1,128 @@
+const enableSessionsAbi = [
+    {
+        type: 'function',
+        name: 'enableSessions',
+        inputs: [
+            {
+                name: 'sessions',
+                type: 'tuple[]',
+                internalType: 'struct Session[]',
+                components: [
+                    {
+                        name: 'sessionValidator',
+                        type: 'address',
+                        internalType: 'contract ISessionValidator',
+                    },
+                    {
+                        name: 'sessionValidatorInitData',
+                        type: 'bytes',
+                        internalType: 'bytes',
+                    },
+                    { name: 'salt', type: 'bytes32', internalType: 'bytes32' },
+                    {
+                        name: 'userOpPolicies',
+                        type: 'tuple[]',
+                        internalType: 'struct PolicyData[]',
+                        components: [
+                            {
+                                name: 'policy',
+                                type: 'address',
+                                internalType: 'address',
+                            },
+                            { name: 'initData', type: 'bytes', internalType: 'bytes' },
+                        ],
+                    },
+                    {
+                        name: 'erc7739Policies',
+                        type: 'tuple',
+                        internalType: 'struct ERC7739Data',
+                        components: [
+                            {
+                                name: 'allowedERC7739Content',
+                                type: 'tuple[]',
+                                internalType: 'struct ERC7739Context[]',
+                                components: [
+                                    {
+                                        name: 'appDomainSeparator',
+                                        type: 'bytes32',
+                                        internalType: 'bytes32',
+                                    },
+                                    {
+                                        name: 'contentName',
+                                        type: 'string[]',
+                                        internalType: 'string[]',
+                                    },
+                                ],
+                            },
+                            {
+                                name: 'erc1271Policies',
+                                type: 'tuple[]',
+                                internalType: 'struct PolicyData[]',
+                                components: [
+                                    {
+                                        name: 'policy',
+                                        type: 'address',
+                                        internalType: 'address',
+                                    },
+                                    {
+                                        name: 'initData',
+                                        type: 'bytes',
+                                        internalType: 'bytes',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        name: 'actions',
+                        type: 'tuple[]',
+                        internalType: 'struct ActionData[]',
+                        components: [
+                            {
+                                name: 'actionTargetSelector',
+                                type: 'bytes4',
+                                internalType: 'bytes4',
+                            },
+                            {
+                                name: 'actionTarget',
+                                type: 'address',
+                                internalType: 'address',
+                            },
+                            {
+                                name: 'actionPolicies',
+                                type: 'tuple[]',
+                                internalType: 'struct PolicyData[]',
+                                components: [
+                                    {
+                                        name: 'policy',
+                                        type: 'address',
+                                        internalType: 'address',
+                                    },
+                                    {
+                                        name: 'initData',
+                                        type: 'bytes',
+                                        internalType: 'bytes',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        name: 'permitERC4337Paymaster',
+                        type: 'bool',
+                        internalType: 'bool',
+                    },
+                ],
+            },
+        ],
+        outputs: [
+            {
+                name: 'permissionIds',
+                type: 'bytes32[]',
+                internalType: 'PermissionId[]',
+            },
+        ],
+        stateMutability: 'nonpayable',
+    },
+];
+export { enableSessionsAbi };

package/dist/modules/common.d.ts

@@ -0,0 +1,16 @@
+import { Address, Hex } from 'viem';
+type ModuleType = typeof MODULE_TYPE_ID_VALIDATOR | typeof MODULE_TYPE_ID_EXECUTOR | typeof MODULE_TYPE_ID_FALLBACK | typeof MODULE_TYPE_ID_HOOK;
+interface Module {
+    address: Address;
+    initData: Hex;
+    deInitData: Hex;
+    additionalContext: Hex;
+    type: ModuleType;
+}
+declare const MODULE_TYPE_ID_VALIDATOR = 1n;
+declare const MODULE_TYPE_ID_EXECUTOR = 2n;
+declare const MODULE_TYPE_ID_FALLBACK = 3n;
+declare const MODULE_TYPE_ID_HOOK = 4n;
+export { MODULE_TYPE_ID_VALIDATOR, MODULE_TYPE_ID_EXECUTOR, MODULE_TYPE_ID_FALLBACK, MODULE_TYPE_ID_HOOK, };
+export type { Module, ModuleType };
+//# sourceMappingURL=common.d.ts.map

package/dist/modules/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../modules/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAEnC,KAAK,UAAU,GACX,OAAO,wBAAwB,GAC/B,OAAO,uBAAuB,GAC9B,OAAO,uBAAuB,GAC9B,OAAO,mBAAmB,CAAA;AAE9B,UAAU,MAAM;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,GAAG,CAAA;IACb,UAAU,EAAE,GAAG,CAAA;IACf,iBAAiB,EAAE,GAAG,CAAA;IACtB,IAAI,EAAE,UAAU,CAAA;CACjB;AAED,QAAA,MAAM,wBAAwB,KAAK,CAAA;AACnC,QAAA,MAAM,uBAAuB,KAAK,CAAA;AAClC,QAAA,MAAM,uBAAuB,KAAK,CAAA;AAClC,QAAA,MAAM,mBAAmB,KAAK,CAAA;AAE9B,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,mBAAmB,GACpB,CAAA;AACD,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,CAAA"}

package/dist/modules/common.js

@@ -0,0 +1,5 @@
+const MODULE_TYPE_ID_VALIDATOR = 1n;
+const MODULE_TYPE_ID_EXECUTOR = 2n;
+const MODULE_TYPE_ID_FALLBACK = 3n;
+const MODULE_TYPE_ID_HOOK = 4n;
+export { MODULE_TYPE_ID_VALIDATOR, MODULE_TYPE_ID_EXECUTOR, MODULE_TYPE_ID_FALLBACK, MODULE_TYPE_ID_HOOK, };

package/dist/modules/index.d.ts

@@ -0,0 +1,33 @@
+import { Address, Chain, Hex } from 'viem';
+import { RhinestoneAccountConfig } from '../types';
+import { Module } from './common';
+import { HOOK_ADDRESS } from './omni-account';
+import { getOwnerValidator } from './validators';
+interface WebAuthnData {
+    authenticatorData: Hex;
+    clientDataJSON: string;
+    typeIndex: number | bigint;
+}
+interface WebauthnValidatorSignature {
+    webauthn: WebAuthnData;
+    signature: WebauthnSignature | Hex | Uint8Array;
+    usePrecompiled?: boolean;
+}
+interface WebauthnSignature {
+    r: bigint;
+    s: bigint;
+}
+interface ModeleSetup {
+    validators: Module[];
+    executors: Module[];
+    fallbacks: Module[];
+    hooks: Module[];
+    registry: Address;
+    attesters: Address[];
+    threshold: number;
+}
+declare function getSetup(config: RhinestoneAccountConfig): Promise<ModeleSetup>;
+declare function getWebauthnValidatorSignature({ webauthn, signature, usePrecompiled, }: WebauthnValidatorSignature): `0x${string}`;
+declare function isRip7212SupportedNetwork(chain: Chain): boolean;
+export { HOOK_ADDRESS, getSetup, getOwnerValidator, getWebauthnValidatorSignature, isRip7212SupportedNetwork, };
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAEP,KAAK,EAEL,GAAG,EAEJ,MAAM,MAAM,CAAA;AAYb,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAElD,OAAO,EACL,MAAM,EAGP,MAAM,UAAU,CAAA;AACjB,OAAO,EAIL,YAAY,EAGb,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,iBAAiB,EAA4B,MAAM,cAAc,CAAA;AAE1E,UAAU,YAAY;IACpB,iBAAiB,EAAE,GAAG,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;CAC3B;AAED,UAAU,0BAA0B;IAClC,QAAQ,EAAE,YAAY,CAAA;IACtB,SAAS,EAAE,iBAAiB,GAAG,GAAG,GAAG,UAAU,CAAA;IAC/C,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,UAAU,iBAAiB;IACzB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,UAAU,WAAW;IACnB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,OAAO,EAAE,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,iBAAe,QAAQ,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,WAAW,CAAC,CAgE7E;AAED,iBAAS,6BAA6B,CAAC,EACrC,QAAQ,EACR,SAAS,EACT,cAAsB,GACvB,EAAE,0BAA0B,iBA6C5B;AAED,iBAAS,yBAAyB,CAAC,KAAK,EAAE,KAAK,WAa9C;AAaD,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,iBAAiB,EACjB,6BAA6B,EAC7B,yBAAyB,GAC1B,CAAA"}

package/dist/modules/index.js

@@ -0,0 +1,129 @@
+import { bytesToHex, encodeAbiParameters, hexToBytes, } from 'viem';
+import { arbitrum, arbitrumSepolia, base, baseSepolia, optimism, optimismSepolia, polygon, polygonAmoy, } from 'viem/chains';
+import { MODULE_TYPE_ID_EXECUTOR, MODULE_TYPE_ID_FALLBACK, } from './common';
+import { OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS, RHINESTONE_MODULE_REGISTRY_ADDRESS, RHINESTONE_ATTESTER_ADDRESS, HOOK_ADDRESS, TARGET_MODULE_ADDRESS, SAME_CHAIN_MODULE_ADDRESS, } from './omni-account';
+import { getOwnerValidator, getSmartSessionValidator } from './validators';
+async function getSetup(config) {
+    const ownerValidator = getOwnerValidator(config);
+    const smartSessionValidator = getSmartSessionValidator(config);
+    const validators = [ownerValidator];
+    if (smartSessionValidator) {
+        validators.push(smartSessionValidator);
+    }
+    const executors = [
+        {
+            address: SAME_CHAIN_MODULE_ADDRESS,
+            initData: '0x',
+            deInitData: '0x',
+            additionalContext: '0x',
+            type: MODULE_TYPE_ID_EXECUTOR,
+        },
+        {
+            address: TARGET_MODULE_ADDRESS,
+            initData: '0x',
+            deInitData: '0x',
+            additionalContext: '0x',
+            type: MODULE_TYPE_ID_EXECUTOR,
+        },
+        {
+            address: HOOK_ADDRESS,
+            initData: '0x',
+            deInitData: '0x',
+            additionalContext: '0x',
+            type: MODULE_TYPE_ID_EXECUTOR,
+        },
+    ];
+    const fallbacks = [
+        {
+            address: TARGET_MODULE_ADDRESS,
+            initData: encodeAbiParameters([
+                { name: 'selector', type: 'bytes4' },
+                { name: 'flags', type: 'bytes1' },
+                { name: 'data', type: 'bytes' },
+            ], ['0x3a5be8cb', '0x00', '0x']),
+            deInitData: '0x',
+            additionalContext: '0x',
+            type: MODULE_TYPE_ID_FALLBACK,
+        },
+    ];
+    const hooks = [];
+    return {
+        validators,
+        executors,
+        fallbacks,
+        hooks,
+        registry: RHINESTONE_MODULE_REGISTRY_ADDRESS,
+        attesters: [
+            RHINESTONE_ATTESTER_ADDRESS,
+            OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS,
+        ],
+        threshold: 1,
+    };
+}
+function getWebauthnValidatorSignature({ webauthn, signature, usePrecompiled = false, }) {
+    const { authenticatorData, clientDataJSON, typeIndex } = webauthn;
+    let r;
+    let s;
+    if (typeof signature === 'string' || signature instanceof Uint8Array) {
+        const parsedSignature = parseSignature(signature);
+        r = parsedSignature.r;
+        s = parsedSignature.s;
+    }
+    else {
+        r = signature.r;
+        s = signature.s;
+    }
+    return encodeAbiParameters([
+        { type: 'bytes', name: 'authenticatorData' },
+        {
+            type: 'string',
+            name: 'clientDataJSON',
+        },
+        {
+            type: 'uint256',
+            name: 'responseTypeLocation',
+        },
+        {
+            type: 'uint256',
+            name: 'r',
+        },
+        {
+            type: 'uint256',
+            name: 's',
+        },
+        {
+            type: 'bool',
+            name: 'usePrecompiled',
+        },
+    ], [
+        authenticatorData,
+        clientDataJSON,
+        typeof typeIndex === 'bigint' ? typeIndex : BigInt(typeIndex),
+        r,
+        s,
+        usePrecompiled,
+    ]);
+}
+function isRip7212SupportedNetwork(chain) {
+    const supportedChains = [
+        optimism,
+        optimismSepolia,
+        polygon,
+        polygonAmoy,
+        base,
+        baseSepolia,
+        arbitrum,
+        arbitrumSepolia,
+    ];
+    return supportedChains.includes(chain);
+}
+function parseSignature(signature) {
+    const bytes = typeof signature === 'string' ? hexToBytes(signature) : signature;
+    const r = bytes.slice(0, 32);
+    const s = bytes.slice(32, 64);
+    return {
+        r: BigInt(bytesToHex(r)),
+        s: BigInt(bytesToHex(s)),
+    };
+}
+export { HOOK_ADDRESS, getSetup, getOwnerValidator, getWebauthnValidatorSignature, isRip7212SupportedNetwork, };

package/dist/modules/omni-account.d.ts

@@ -0,0 +1,9 @@
+import { Address } from 'viem';
+declare const OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS: Address;
+declare const RHINESTONE_MODULE_REGISTRY_ADDRESS: Address;
+declare const RHINESTONE_ATTESTER_ADDRESS: Address;
+declare const HOOK_ADDRESS: Address;
+declare const TARGET_MODULE_ADDRESS: Address;
+declare const SAME_CHAIN_MODULE_ADDRESS: Address;
+export { OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS, RHINESTONE_MODULE_REGISTRY_ADDRESS, RHINESTONE_ATTESTER_ADDRESS, HOOK_ADDRESS, TARGET_MODULE_ADDRESS, SAME_CHAIN_MODULE_ADDRESS, };
+//# sourceMappingURL=omni-account.d.ts.map

package/dist/modules/omni-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omni-account.d.ts","sourceRoot":"","sources":["../../modules/omni-account.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAE9B,QAAA,MAAM,kCAAkC,EAAE,OACI,CAAA;AAE9C,QAAA,MAAM,kCAAkC,EAAE,OACI,CAAA;AAC9C,QAAA,MAAM,2BAA2B,EAAE,OACW,CAAA;AAE9C,QAAA,MAAM,YAAY,EAAE,OAAsD,CAAA;AAC1E,QAAA,MAAM,qBAAqB,EAAE,OACiB,CAAA;AAC9C,QAAA,MAAM,yBAAyB,EAAE,OACa,CAAA;AAE9C,OAAO,EACL,kCAAkC,EAClC,kCAAkC,EAClC,2BAA2B,EAC3B,YAAY,EACZ,qBAAqB,EACrB,yBAAyB,GAC1B,CAAA"}

package/dist/modules/omni-account.js

@@ -0,0 +1,7 @@
+const OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS = '0x6D0515e8E499468DCe9583626f0cA15b887f9d03';
+const RHINESTONE_MODULE_REGISTRY_ADDRESS = '0x000000000069e2a187aeffb852bf3ccdc95151b2';
+const RHINESTONE_ATTESTER_ADDRESS = '0x000000333034E9f539ce08819E12c1b8Cb29084d';
+const HOOK_ADDRESS = '0x0000000000f6Ed8Be424d673c63eeFF8b9267420';
+const TARGET_MODULE_ADDRESS = '0x0000000000E5a37279A001301A837a91b5de1D5E';
+const SAME_CHAIN_MODULE_ADDRESS = '0x000000000043ff16d5776c7F0f65Ec485C17Ca04';
+export { OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS, RHINESTONE_MODULE_REGISTRY_ADDRESS, RHINESTONE_ATTESTER_ADDRESS, HOOK_ADDRESS, TARGET_MODULE_ADDRESS, SAME_CHAIN_MODULE_ADDRESS, };

package/dist/modules/validators.d.ts

@@ -0,0 +1,31 @@
+import { Address, Chain, Hex, PublicClient } from 'viem';
+import { OwnerSet, RhinestoneAccountConfig, Session } from '../types';
+import { Module } from './common';
+type SmartSessionModeType = typeof SMART_SESSION_MODE_USE | typeof SMART_SESSION_MODE_ENABLE | typeof SMART_SESSION_MODE_UNSAFE_ENABLE;
+declare const SMART_SESSIONS_VALIDATOR_ADDRESS: Address;
+declare const SMART_SESSION_MODE_USE = "0x00";
+declare const SMART_SESSION_MODE_ENABLE = "0x01";
+declare const SMART_SESSION_MODE_UNSAFE_ENABLE = "0x02";
+declare function getOwnerValidator(config: RhinestoneAccountConfig): Module;
+declare function getEnableSessionCall(chain: Chain, session: Session): Promise<{
+    to: `0x${string}`;
+    data: `0x${string}`;
+}>;
+declare function getSessionAllowedERC7739Content(chain: Chain): Promise<{
+    appDomainSeparator: `0x${string}`;
+    contentsType: string;
+}>;
+declare function getSmartSessionValidator(config: RhinestoneAccountConfig): Module | null;
+declare function isSessionEnabled(client: PublicClient, address: Address, permissionId: Hex): Promise<boolean>;
+declare function encodeSmartSessionSignature(mode: SmartSessionModeType, permissionId: Hex, signature: Hex): `0x${string}`;
+declare function getPermissionId(session: Session): `0x${string}`;
+declare function getMockSinature(ownerSet: OwnerSet): Hex;
+declare function getAccountEIP712Domain(client: PublicClient, account: Address): Promise<{
+    name: string;
+    version: string;
+    chainId: bigint;
+    verifyingContract: `0x${string}`;
+    salt: `0x${string}`;
+}>;
+export { SMART_SESSION_MODE_USE, SMART_SESSION_MODE_ENABLE, SMART_SESSIONS_VALIDATOR_ADDRESS, getOwnerValidator, getSmartSessionValidator, getEnableSessionCall, encodeSmartSessionSignature, getPermissionId, getMockSinature, getAccountEIP712Domain, isSessionEnabled, getSessionAllowedERC7739Content, };
+//# sourceMappingURL=validators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../modules/validators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,KAAK,EAOL,GAAG,EAKH,YAAY,EAKb,MAAM,MAAM,CAAA;AAEb,OAAO,EACL,QAAQ,EAER,uBAAuB,EACvB,OAAO,EAER,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,MAAM,EAA4B,MAAM,UAAU,CAAA;AAwE3D,KAAK,oBAAoB,GACrB,OAAO,sBAAsB,GAC7B,OAAO,yBAAyB,GAChC,OAAO,gCAAgC,CAAA;AAM3C,QAAA,MAAM,gCAAgC,EAAE,OACM,CAAA;AAE9C,QAAA,MAAM,sBAAsB,SAAS,CAAA;AACrC,QAAA,MAAM,yBAAyB,SAAS,CAAA;AACxC,QAAA,MAAM,gCAAgC,SAAS,CAAA;AA8B/C,iBAAS,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,UAEzD;AAED,iBAAe,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO;;;GAsBjE;AA6BD,iBAAe,+BAA+B,CAAC,KAAK,EAAE,KAAK;;;GAgB1D;AAyDD,iBAAS,wBAAwB,CAC/B,MAAM,EAAE,uBAAuB,GAC9B,MAAM,GAAG,IAAI,CAWf;AA0RD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,GAAG,oBAiClB;AAED,iBAAS,2BAA2B,CAClC,IAAI,EAAE,oBAAoB,EAC1B,YAAY,EAAE,GAAG,EACjB,SAAS,EAAE,GAAG,iBAcf;AAED,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO,iBAyBxC;AAED,iBAAS,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAUhD;AAED,iBAAe,sBAAsB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO;;;;;;GAoD3E;AAED,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,gCAAgC,EAChC,iBAAiB,EACjB,wBAAwB,EACxB,oBAAoB,EACpB,2BAA2B,EAC3B,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,+BAA+B,GAChC,CAAA"}