@charterlabs/rhinestone-sdk 0.1.12 → 0.2.0

package/README.md

@@ -1,107 +1,214 @@
-# @charterlabs/rhinestone-sdk
+# Rhinestone SDK
 
-A production-ready fork of the Rhinestone SDK with enhanced WebAuthn support for Charter Labs.
+End-to-end chain abstraction and modularity toolkit
 
-## 🚀 Enhanced Features
+## Usage
 
-### Superior WebAuthn Implementation
-- **Multi-credential support** - Register multiple WebAuthn devices per account
-- **Threshold signatures** - M-of-N security model for enterprise use
-- **User verification control** - Configurable UV requirements per credential
-- **WebAuthn standard compliance** - Proper credential ID handling
-- **Production-ready** - Handles real-world multi-device scenarios
+### Installation
 
-### Key Improvements Over Upstream
-- ✅ **Multi-device support** vs single credential limitation
-- ✅ **WebAuthn standard compliance** vs non-standard hashing
-- ✅ **Security flexibility** vs fixed UV policies
-- ✅ **Enterprise features** vs demo/MVP approach
+```bash
+npm install viem @rhinestone/sdk
+```
 
-## Installation
+```bash
+pnpm install viem @rhinestone/sdk
+```
 
 ```bash
-npm install @charterlabs/rhinestone-sdk viem
-# or
-bun add @charterlabs/rhinestone-sdk viem
+yarn add viem @rhinestone/sdk
 ```
 
-## Quick Start
+```bash
+bun install viem @rhinestone/sdk
+```
+
+## Quickstart
+
+You'll need a Rhinestone API key, as well as an existing account with some testnet ETH on the source chain.
+
+### Creating a Wallet
 
-```typescript
-import { createRhinestoneAccount } from '@charterlabs/rhinestone-sdk'
+Let's create a smart account with a single owner:
+
+```ts
+import { createRhinestoneAccount } from '@rhinestone/sdk'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+import { baseSepolia, arbitrumSepolia, optimismSepolia } from 'viem/chains'
+import {
+  Chain,
+  createPublicClient,
+  createWalletClient,
+  encodeFunctionData,
+  erc20Abi,
+  Hex,
+  http,
+  parseEther,
+} from 'viem'
+
+const fundingPrivateKey = process.env.FUNDING_PRIVATE_KEY
+if (!fundingPrivateKey) {
+  throw new Error('FUNDING_PRIVATE_KEY is not set')
+}
+
+const rhinestoneApiKey = process.env.RHINESTONE_API_KEY
+if (!rhinestoneApiKey) {
+  throw new Error('RHINESTONE_API_KEY is not set')
+}
+
+const sourceChain = baseSepolia
+const targetChain = arbitrumSepolia
+
+// You can use an existing PK here
+const privateKey = generatePrivateKey()
+console.info(`Owner private key: ${privateKey}`)
+const account = privateKeyToAccount(privateKey)
 
-// Create account with WebAuthn support
 const rhinestoneAccount = await createRhinestoneAccount({
   owners: {
-    type: 'passkey',
-    account: webAuthnAccount, // Your WebAuthn account
-    credentialIds: ['0x...', '0x...'] // Multiple credential IDs
-  },
-  rhinestoneApiKey: 'your-api-key'
+    type: 'ecdsa',
+    accounts: [account],
+  }
+  rhinestoneApiKey,
 })
+const address = await rhinestoneAccount.getAddress()
+console.info(`Smart account address: ${address}`)
 ```
 
-## WebAuthn Features
+### Funding the Account
+
+We will send some ETH from the funding account to the created smart account. The Orchestrator will use some of that ETH to deploy the account on the target chain, as well as to convert it to USDC for a transfer transaction.
+
+```ts
+const publicClient = createPublicClient({
+  chain: sourceChain,
+  transport: http(),
+});
+const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex);
+const fundingClient = createWalletClient({
+  account: fundingAccount,
+  chain: sourceChain,
+  transport: http(),
+});
+
+const txHash = await fundingClient.sendTransaction({
+  to: address,
+  value: parseEther('0.001'),
+});
+await publicClient.waitForTransactionReceipt({ hash: txHash });
+```
 
-### Multi-Credential Support
-```typescript
-// Register multiple devices
-const config = {
-  owners: {
-    type: 'passkey',
-    account: webAuthnAccount,
-    credentialIds: [
-      '0x1234...', // Phone
-      '0x5678...', // Laptop
-      '0x9abc...'  // Security key
-    ]
-  }
-}
+### Sending a Cross-chain Transaction
+
+Finally, let's make a cross-chain token transfer:
+
+```ts
+const usdcTarget = '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d';
+const usdcAmount = 1n;
+
+const transaction = await rhinestoneAccount.sendTransaction({
+  sourceChain,
+  targetChain,
+  calls: [
+    {
+      to: usdcTarget,
+      value: 0n,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'transfer',
+        args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', usdcAmount],
+      }),
+    },
+  ],
+  tokenRequests: [
+    {
+      address: usdcTarget,
+      amount: usdcAmount,
+    },
+  ],
+});
+console.info('Transaction', transaction);
+
+const transactionResult = await rhinestoneAccount.waitForExecution(transaction);
+console.info('Result', transactionResult);
 ```
 
-### Threshold Signatures
-```typescript
-// Require 2-of-3 signatures
-const config = {
+After running that, you will get a smart account deployed on both Base Sepolia and Arbitrum Sepolia, and make a cross-chain USDC transfer.
+
+### Using Smart Sessions
+
+First, define a session you want to use:
+
+```ts
+const session: Session = {
   owners: {
-    type: 'multi-factor',
-    validators: [phoneValidator, laptopValidator, securityKeyValidator],
-    threshold: 2
-  }
+    type: 'ecdsa',
+    accounts: [sessionOwner],
+  },
+  actions: [
+    {
+      target: wethAddress,
+      selector: toFunctionSelector(
+        getAbiItem({
+          abi: wethAbi,
+          name: 'deposit',
+        }),
+      ),
+    },
+    {
+      target: wethAddress,
+      selector: toFunctionSelector(
+        getAbiItem({
+          abi: wethAbi,
+          name: 'transfer',
+        }),
+      ),
+      policies: [
+        {
+          type: 'universal-action',
+          rules: [
+            {
+              condition: 'equal',
+              calldataOffset: 0n,
+              referenceValue: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
+            },
+          ],
+        },
+      ],
+    },
+  ],
 }
 ```
 
-### User Verification Control
-```typescript
-// Configure UV requirements per credential
-const validator = getWebAuthnValidator({
-  pubKey: publicKey,
-  authenticatorId: 'device-id',
-  requireUV: true // Require user verification
+During account initialization, provide the session you've just created. Make sure to also provide a bundler configuration.
+
+```ts
+const rhinestoneAccount = await createRhinestoneAccount({
+  // …
+  sessions: [session],
+  bundler: {
+    // …
+  },
 })
 ```
 
-## Development
-
-```bash
-# Install dependencies
-bun install
+When making a transaction, specify the `signers` object to sign it with the session key:
 
-# Build
-bun run build
+```ts
+const transactionResult = await rhinestoneAccount.sendTransaction({
+  // …
+  signers: {
+    type: 'session',
+    session: session,
+  },
+})
+```
 
-# Test
-bun run test
+## Migrating from Orchestrator SDK
 
-# Create changeset
-bun run changeset
+To migrate from the [Orchestrator SDK](https://github.com/rhinestonewtf/orchestrator-sdk), replace all imports of `@rhinestone/orchestrator-sdk` with `@rhinestone/sdk/orchestrator`.
 
-# Version and publish
-bun run changeset:version
-bun run changeset:release
-```
+Let us know if you encounter any issues!
 
-## License
+## Contributing
 
-MIT - Charter Labs
+For feature or change requests, feel free to open a PR, start a discussion or get in touch with us.

package/dist/src/accounts/index.d.ts

@@ -1,4 +1,4 @@
-import { type Account, type Address, type Chain, type Hex, type PublicClient } from 'viem';
+import { type Chain, type HashTypedDataParameters, type Hex, type PublicClient, type TypedData } from 'viem';
 import type { Module } from '../modules/common';
 import type { EnableSessionData } from '../modules/validators/smart-sessions';
 import type { AccountProviderConfig, Call, OwnerSet, RhinestoneAccountConfig, Session, SignerSet } from '../types';
@@ -17,12 +17,13 @@ declare function getModuleInstallationCalls(config: RhinestoneAccountConfig, mod
 declare function getModuleUninstallationCalls(config: RhinestoneAccountConfig, module: Module): Call[];
 declare function getAddress(config: RhinestoneAccountConfig): `0x${string}`;
 declare function getPackedSignature(config: RhinestoneAccountConfig, signers: SignerSet | undefined, chain: Chain, validator: ValidatorConfig, hash: Hex, transformSignature?: (signature: Hex) => Hex): Promise<`0x${string}`>;
-declare function isDeployed(chain: Chain, config: RhinestoneAccountConfig): Promise<boolean>;
+declare function getTypedDataPackedSignature<typedData extends TypedData | Record<string, unknown> = TypedData, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData>(config: RhinestoneAccountConfig, signers: SignerSet | undefined, chain: Chain, validator: ValidatorConfig, parameters: HashTypedDataParameters<typedData, primaryType>, transformSignature?: (signature: Hex) => Hex): Promise<`0x${string}`>;
+declare function isDeployed(config: RhinestoneAccountConfig, chain: Chain): Promise<boolean>;
 declare function deploy(config: RhinestoneAccountConfig, chain: Chain, session?: Session): Promise<void>;
-declare function deployStandaloneWithEoa(chain: Chain, config: RhinestoneAccountConfig, deployer: Account): Promise<Address>;
-declare function getSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
-declare function getSmartSessionSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain, session: Session, enableData: EnableSessionData | null): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
-declare function getGuardianSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain, guardians: OwnerSet): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
+declare function toErc6492Signature(config: RhinestoneAccountConfig, signature: Hex, chain: Chain): Promise<Hex>;
+declare function getSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain): Promise<import("viem/_types/account-abstraction").SmartAccount<import("viem/_types/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
+declare function getSmartSessionSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain, session: Session, enableData: EnableSessionData | null): Promise<import("viem/_types/account-abstraction").SmartAccount<import("viem/_types/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
+declare function getGuardianSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain, guardians: OwnerSet): Promise<import("viem/_types/account-abstraction").SmartAccount<import("viem/_types/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
 declare function getAccountProvider(config: RhinestoneAccountConfig): AccountProviderConfig;
-export { getModuleInstallationCalls, getModuleUninstallationCalls, getAddress, getAccountProvider, getInitCode, signEip7702InitData, getEip7702InitCall, isDeployed, deploy, getSmartAccount, getSmartSessionSmartAccount, getGuardianSmartAccount, getPackedSignature, deployStandaloneWithEoa, isAccountError, AccountError, Eip7702AccountMustHaveEoaError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, SmartSessionsNotEnabledError, SigningNotSupportedForAccountError, SignMessageNotSupportedByAccountError, Eip7702NotSupportedForAccountError, };
+export { getModuleInstallationCalls, getModuleUninstallationCalls, getAddress, getAccountProvider, getInitCode, signEip7702InitData, getEip7702InitCall, isDeployed, deploy, toErc6492Signature, getSmartAccount, getSmartSessionSmartAccount, getGuardianSmartAccount, getPackedSignature, getTypedDataPackedSignature, isAccountError, AccountError, Eip7702AccountMustHaveEoaError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, SmartSessionsNotEnabledError, SigningNotSupportedForAccountError, SignMessageNotSupportedByAccountError, Eip7702NotSupportedForAccountError, };
 //# sourceMappingURL=index.d.ts.map

package/dist/src/accounts/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../accounts/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../accounts/index.ts"],"names":[],"mappings":"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"}

package/dist/src/accounts/index.js

@@ -10,15 +10,15 @@ exports.signEip7702InitData = signEip7702InitData;
 exports.getEip7702InitCall = getEip7702InitCall;
 exports.isDeployed = isDeployed;
 exports.deploy = deploy;
+exports.toErc6492Signature = toErc6492Signature;
 exports.getSmartAccount = getSmartAccount;
 exports.getSmartSessionSmartAccount = getSmartSessionSmartAccount;
 exports.getGuardianSmartAccount = getGuardianSmartAccount;
 exports.getPackedSignature = getPackedSignature;
-exports.deployStandaloneWithEoa = deployStandaloneWithEoa;
+exports.getTypedDataPackedSignature = getTypedDataPackedSignature;
 const viem_1 = require("viem");
 const execution_1 = require("../execution");
 const smart_session_1 = require("../execution/smart-session");
-const modules_1 = require("../modules");
 const validators_1 = require("../modules/validators");
 const core_1 = require("../modules/validators/core");
 const error_1 = require("./error");
@@ -34,6 +34,9 @@ Object.defineProperty(exports, "SmartSessionsNotEnabledError", { enumerable: tru
 const kernel_1 = require("./kernel");
 const nexus_1 = require("./nexus");
 const safe_1 = require("./safe");
+const common_1 = require("./signing/common");
+const message_1 = require("./signing/message");
+const typedData_1 = require("./signing/typedData");
 const startale_1 = require("./startale");
 const utils_1 = require("./utils");
 function getDeployArgs(config) {
@@ -179,26 +182,56 @@ function getAddress(config) {
 }
 // Signs and packs a signature to be EIP-1271 compatible
 async function getPackedSignature(config, signers, chain, validator, hash, transformSignature = (signature) => signature) {
-    signers = signers ?? convertOwnerSetToSignerSet(config.owners);
-    const signFn = (hash) => sign(signers, chain, hash);
+    signers = signers ?? (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, hash);
     const account = getAccountProvider(config);
     const address = getAddress(config);
     switch (account.type) {
         case 'safe': {
-            return (0, safe_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+            const signature = await signFn(hash);
+            return (0, safe_1.packSignature)(signature, validator, transformSignature);
         }
         case 'nexus': {
-            return (0, nexus_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+            const signature = await signFn(hash);
+            return (0, nexus_1.packSignature)(signature, validator, transformSignature);
         }
         case 'kernel': {
-            return (0, kernel_1.getPackedSignature)(signFn, hash, validator, address, transformSignature);
+            const signature = await signFn((0, kernel_1.wrapMessageHash)(hash, address));
+            return (0, kernel_1.packSignature)(signature, validator, transformSignature);
         }
         case 'startale': {
-            return (0, startale_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+            const signature = await signFn(hash);
+            return (0, startale_1.packSignature)(signature, validator, transformSignature);
         }
     }
 }
-async function isDeployed(chain, config) {
+// Signs and packs a signature to be EIP-1271 compatible
+async function getTypedDataPackedSignature(config, signers, chain, validator, parameters, transformSignature = (signature) => signature) {
+    signers = signers ?? (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const signFn = (parameters) => (0, typedData_1.sign)(signers, chain, parameters);
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'safe': {
+            const signature = await signFn(parameters);
+            return (0, safe_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'nexus': {
+            const signature = await signFn(parameters);
+            return (0, nexus_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'kernel': {
+            const address = getAddress(config);
+            const signMessageFn = (hash) => (0, message_1.sign)(signers, chain, hash);
+            const signature = await signMessageFn((0, kernel_1.wrapMessageHash)((0, viem_1.hashTypedData)(parameters), address));
+            return (0, kernel_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'startale': {
+            const signature = await signFn(parameters);
+            return (0, startale_1.packSignature)(signature, validator, transformSignature);
+        }
+    }
+}
+async function isDeployed(config, chain) {
     const publicClient = (0, viem_1.createPublicClient)({
         chain: chain,
         transport: (0, utils_1.createTransport)(chain, config.provider),
@@ -233,7 +266,7 @@ async function deployWithIntent(chain, config) {
         // Already deployed
         return;
     }
-    await (0, execution_1.sendTransaction)(config, {
+    const result = await (0, execution_1.sendTransaction)(config, {
         targetChain: chain,
         calls: [
             {
@@ -242,42 +275,35 @@ async function deployWithIntent(chain, config) {
             },
         ],
     });
+    await (0, execution_1.waitForExecution)(config, result, true);
 }
-async function deployStandaloneWithEoa(chain, config, deployer) {
-    if (is7702(config)) {
-        throw new Error('deployStandaloneWithEoa is only for factory-based accounts. Remove config.eoa to use this method.');
+async function toErc6492Signature(config, signature, chain) {
+    const deployed = await isDeployed(config, chain);
+    if (deployed) {
+        return signature;
     }
-    const address = getAddress(config);
-    const alreadyDeployed = await isDeployed(chain, config);
-    if (alreadyDeployed) {
-        return address;
-    }
-    const { factory, factoryData } = getDeployArgs(config);
-    if (!factory || !factoryData) {
+    // Account is not deployed, use ERC-6492
+    const initCode = getInitCode(config);
+    if (!initCode) {
         throw new error_1.FactoryArgsNotAvailableError();
     }
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
-    });
-    const walletClient = (0, viem_1.createWalletClient)({
-        account: deployer,
-        chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
-    });
-    const hash = await walletClient.sendTransaction({
-        to: factory,
-        data: factoryData,
-    });
-    await publicClient.waitForTransactionReceipt({ hash });
-    return address;
+    const { factory, factoryData } = initCode;
+    const magicBytes = '0x6492649264926492649264926492649264926492649264926492649264926492';
+    return (0, viem_1.concat)([
+        (0, viem_1.encodeAbiParameters)([
+            { name: 'create2Factory', type: 'address' },
+            { name: 'factoryCalldata', type: 'bytes' },
+            { name: 'originalERC1271Signature', type: 'bytes' },
+        ], [factory, factoryData, signature]),
+        magicBytes,
+    ]);
 }
 async function getSmartAccount(config, client, chain) {
     const account = getAccountProvider(config);
     const address = getAddress(config);
     const ownerValidator = (0, validators_1.getOwnerValidator)(config);
-    const signers = convertOwnerSetToSignerSet(config.owners);
-    const signFn = (hash) => sign(signers, chain, hash);
+    const signers = (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, hash);
     switch (account.type) {
         case 'safe': {
             return (0, safe_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn);
@@ -304,7 +330,7 @@ async function getSmartSessionSmartAccount(config, client, chain, session, enabl
         session,
         enableData: enableData || undefined,
     };
-    const signFn = (hash) => sign(signers, chain, hash);
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, hash);
     const account = getAccountProvider(config);
     switch (account.type) {
         case 'safe': {
@@ -332,7 +358,7 @@ async function getGuardianSmartAccount(config, client, chain, guardians) {
         type: 'guardians',
         guardians: accounts,
     };
-    const signFn = (hash) => sign(signers, chain, hash);
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, hash);
     const account = getAccountProvider(config);
     switch (account.type) {
         case 'safe': {
@@ -349,102 +375,6 @@ async function getGuardianSmartAccount(config, client, chain, guardians) {
         }
     }
 }
-async function sign(signers, chain, hash) {
-    switch (signers.type) {
-        case 'owner': {
-            switch (signers.kind) {
-                case 'ecdsa': {
-                    const signatures = await Promise.all(signers.accounts.map((account) => signEcdsa(account, hash)));
-                    return (0, viem_1.concat)(signatures);
-                }
-                case 'passkey': {
-                    // Convert OwnerSignerSet to WebauthnValidatorConfig
-                    const webAuthnConfig = {
-                        type: 'passkey',
-                        account: signers.account,
-                        credentialIds: signers.credentialIds
-                    };
-                    return await signPasskey(webAuthnConfig, chain, hash);
-                }
-                case 'multi-factor': {
-                    const signatures = await Promise.all(signers.validators.map(async (validator) => {
-                        if (validator === null) {
-                            return '0x';
-                        }
-                        // Convert to proper validator format
-                        const validatorConfig = validator.type === 'ecdsa'
-                            ? { type: 'ecdsa', accounts: validator.accounts, threshold: 1 }
-                            : { type: 'passkey', account: validator.account, credentialIds: validator.credentialIds };
-                        const validatorSigners = convertOwnerSetToSignerSet(validatorConfig);
-                        return sign(validatorSigners, chain, hash);
-                    }));
-                    const data = (0, viem_1.encodeAbiParameters)([
-                        {
-                            components: [
-                                {
-                                    internalType: 'bytes32',
-                                    name: 'packedValidatorAndId',
-                                    type: 'bytes32',
-                                },
-                                { internalType: 'bytes', name: 'data', type: 'bytes' },
-                            ],
-                            name: 'validators',
-                            type: 'tuple[]',
-                        },
-                    ], [
-                        signers.validators.map((validator, index) => {
-                            // Convert to proper validator format for getValidator
-                            const validatorConfig = validator.type === 'ecdsa'
-                                ? { type: 'ecdsa', accounts: validator.accounts, threshold: 1 }
-                                : { type: 'passkey', account: validator.account, credentialIds: validator.credentialIds };
-                            const validatorModule = (0, core_1.getValidator)(validatorConfig);
-                            return {
-                                packedValidatorAndId: (0, viem_1.concat)([
-                                    (0, viem_1.pad)((0, viem_1.toHex)(validator.id), { size: 12 }),
-                                    validatorModule.address,
-                                ]),
-                                data: signatures[index],
-                            };
-                        }),
-                    ]);
-                    return data;
-                }
-                default: {
-                    throw new Error('Unsupported owner kind');
-                }
-            }
-        }
-        case 'session': {
-            const sessionSigners = convertOwnerSetToSignerSet(signers.session.owners);
-            return sign(sessionSigners, chain, hash);
-        }
-        case 'guardians': {
-            const signatures = await Promise.all(signers.guardians.map((account) => signEcdsa(account, hash)));
-            return (0, viem_1.concat)(signatures);
-        }
-    }
-}
-async function signEcdsa(account, hash) {
-    if (!account.signMessage) {
-        throw new error_1.SigningNotSupportedForAccountError();
-    }
-    return await account.signMessage({ message: { raw: hash } });
-}
-async function signPasskey(validators, chain, hash) {
-    const { account, credentialIds } = validators;
-    console.log('credentialIds in the signPasskey', credentialIds);
-    const { webauthn: rawWebauthn, signature } = await account.sign({ hash });
-    console.log('rawWebauthn in the signPasskey', rawWebauthn);
-    console.log('signature in the signPasskey', signature);
-    const { authenticatorData, clientDataJSON, challengeIndex, typeIndex } = rawWebauthn;
-    const usePrecompiled = (0, modules_1.isRip7212SupportedNetwork)(chain);
-    return (0, modules_1.getWebauthnValidatorSignature)({
-        credentialIds,
-        usePrecompiled,
-        webauthn: { authenticatorData, clientDataJSON, challengeIndex, typeIndex },
-        signature,
-    });
-}
 function is7702(config) {
     return config.eoa !== undefined;
 }
@@ -456,40 +386,3 @@ function getAccountProvider(config) {
         type: 'nexus',
     };
 }
-function convertOwnerSetToSignerSet(owners) {
-    switch (owners.type) {
-        case 'ecdsa': {
-            return {
-                type: 'owner',
-                kind: 'ecdsa',
-                accounts: owners.accounts,
-            };
-        }
-        case 'passkey': {
-            const { account, credentialIds } = owners;
-            return {
-                type: 'owner',
-                kind: 'passkey',
-                account,
-                credentialIds,
-            };
-        }
-        case 'multi-factor': {
-            // Filter out null entries and propagate credentialIds
-            const mf = owners;
-            const validValidators = mf.validators.filter((v) => v !== null);
-            return {
-                type: 'owner',
-                kind: 'multi-factor',
-                validators: validValidators.map((validator, index) => {
-                    if (validator.type === 'ecdsa') {
-                        return { type: 'ecdsa', id: index, accounts: validator.accounts };
-                    }
-                    else {
-                        return { type: 'passkey', id: index, account: validator.account, credentialIds: validator.credentialIds };
-                    }
-                }),
-            };
-        }
-    }
-}