@rhinestone/sdk 1.5.0 → 2.0.0-beta.0

package/dist/src/accounts/safe.js

@@ -1,20 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEip712Domain = getEip712Domain;
-exports.getInstallData = getInstallData;
-exports.getAddress = getAddress;
-exports.packSignature = packSignature;
-exports.getDeployArgs = getDeployArgs;
-exports.getV0DeployArgs = getV0DeployArgs;
-exports.getSmartAccount = getSmartAccount;
-exports.getGuardianSmartAccount = getGuardianSmartAccount;
-const viem_1 = require("viem");
-const account_abstraction_1 = require("viem/account-abstraction");
-const modules_1 = require("../modules");
-const legacy_1 = require("../modules/legacy");
-const validators_1 = require("../modules/validators");
-const error_1 = require("./error");
-const utils_1 = require("./utils");
+import { concat, decodeFunctionData, encodeAbiParameters, encodeFunctionData, encodePacked, getContractAddress, keccak256, parseAbi, parseAbiParameters, zeroAddress, zeroHash, } from 'viem';
+import { entryPoint07Abi, entryPoint07Address, getUserOperationHash, toSmartAccount, } from 'viem/account-abstraction';
+import { getSetup as getModuleSetup } from '../modules/index.js';
+import { getV0Attesters, getV0Setup as getV0ModuleSetup, } from '../modules/legacy.js';
+import { getMockSignature } from '../modules/validators/index.js';
+import { AccountConfigurationNotSupportedError, Eip712DomainNotAvailableError, OwnersFieldRequiredError, } from './error.js';
+import { encode7579Calls, getAccountNonce } from './utils.js';
 const SAFE_7579_LAUNCHPAD_V2_ADDRESS = '0x75798463024bda64d83c94a64bc7d7eab41300ef';
 const SAFE_7579_ADAPTER_V2_ADDRESS = '0x7579f2ad53b01c3d8779fe17928e0d48885b0003';
 const SAFE_7579_LAUNCHPAD_V1_ADDRESS = '0x7579011ab74c46090561ea277ba79d510c6c00ff';
@@ -28,19 +18,19 @@ function getDeployArgs(config) {
         if (!('factory' in config.initData)) {
             return null;
         }
-        const factoryData = (0, viem_1.decodeFunctionData)({
-            abi: (0, viem_1.parseAbi)([
+        const factoryData = decodeFunctionData({
+            abi: parseAbi([
                 'function createProxyWithNonce(address singleton,bytes calldata initializer,uint256 saltNonce) external payable returns (address)',
             ]),
             data: config.initData.factoryData,
         });
         if (factoryData.functionName !== 'createProxyWithNonce') {
-            throw new error_1.AccountConfigurationNotSupportedError('Invalid factory data', 'safe');
+            throw new AccountConfigurationNotSupportedError('Invalid factory data', 'safe');
         }
         const implementation = factoryData.args[0];
         const initData = factoryData.args[1];
         const saltNonce = factoryData.args[2];
-        const salt = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes32', 'uint256'], [(0, viem_1.keccak256)(initData), saltNonce]));
+        const salt = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initData), saltNonce]));
         return {
             factory: config.initData.factory,
             factoryData: config.initData.factoryData,
@@ -51,7 +41,7 @@ function getDeployArgs(config) {
     }
     const owners = getOwners(config);
     const threshold = getThreshold(config);
-    const moduleSetup = (0, modules_1.getSetup)(config);
+    const moduleSetup = getModuleSetup(config);
     const modules = [
         ...moduleSetup.validators,
         ...moduleSetup.executors,
@@ -60,8 +50,8 @@ function getDeployArgs(config) {
     ];
     const adapter = SAFE_7579_ADAPTER_V2_ADDRESS;
     const launchpad = SAFE_7579_LAUNCHPAD_V2_ADDRESS;
-    const calldata = (0, viem_1.encodeFunctionData)({
-        abi: (0, viem_1.parseAbi)([
+    const calldata = encodeFunctionData({
+        abi: parseAbi([
             'struct ModuleInit {address module;bytes initData;uint256 moduleType}',
             'function addSafe7579(address safe7579,ModuleInit[] calldata modules,address[] calldata attesters,uint8 threshold) external',
         ]),
@@ -77,8 +67,8 @@ function getDeployArgs(config) {
             0,
         ],
     });
-    const initData = (0, viem_1.encodeFunctionData)({
-        abi: (0, viem_1.parseAbi)([
+    const initData = encodeFunctionData({
+        abi: parseAbi([
             'function setup(address[] calldata _owners,uint256 _threshold,address to,bytes calldata data,address fallbackHandler,address paymentToken,uint256 payment, address paymentReceiver) external',
         ]),
         functionName: 'setup',
@@ -88,21 +78,21 @@ function getDeployArgs(config) {
             launchpad,
             calldata,
             adapter,
-            viem_1.zeroAddress,
+            zeroAddress,
             BigInt(0),
-            viem_1.zeroAddress,
+            zeroAddress,
         ],
     });
     const account = config.account;
     const saltNonce = account?.nonce ?? 0n;
-    const factoryData = (0, viem_1.encodeFunctionData)({
-        abi: (0, viem_1.parseAbi)([
+    const factoryData = encodeFunctionData({
+        abi: parseAbi([
             'function createProxyWithNonce(address singleton,bytes calldata initializer,uint256 saltNonce) external payable returns (address)',
         ]),
         functionName: 'createProxyWithNonce',
         args: [SAFE_SINGLETON_ADDRESS, initData, saltNonce],
     });
-    const salt = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes32', 'uint256'], [(0, viem_1.keccak256)(initData), saltNonce]));
+    const salt = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initData), saltNonce]));
     return {
         factory: SAFE_PROXY_FACTORY_ADDRESS,
         factoryData,
@@ -113,16 +103,16 @@ function getDeployArgs(config) {
 }
 function getV0DeployArgs(config) {
     if (config.initData) {
-        throw new error_1.AccountConfigurationNotSupportedError('Custom V0 accounts are not supported', 'safe');
+        throw new AccountConfigurationNotSupportedError('Custom V0 accounts are not supported', 'safe');
     }
     const owners = getOwners(config);
     const threshold = getThreshold(config);
-    const attesters = (0, legacy_1.getV0Attesters)();
-    const moduleSetup = (0, legacy_1.getV0Setup)(config);
+    const attesters = getV0Attesters();
+    const moduleSetup = getV0ModuleSetup(config);
     const adapter = SAFE_7579_ADAPTER_V1_ADDRESS;
     const launchpad = SAFE_7579_LAUNCHPAD_V1_ADDRESS;
-    const calldata = (0, viem_1.encodeFunctionData)({
-        abi: (0, viem_1.parseAbi)([
+    const calldata = encodeFunctionData({
+        abi: parseAbi([
             'struct ModuleInit {address module;bytes initData;}',
             'function addSafe7579(address safe7579,ModuleInit[] calldata validators,ModuleInit[] calldata executors,ModuleInit[] calldata fallbacks, ModuleInit[] calldata hooks,address[] calldata attesters,uint8 threshold) external',
         ]),
@@ -149,8 +139,8 @@ function getV0DeployArgs(config) {
             attesters.threshold,
         ],
     });
-    const initData = (0, viem_1.encodeFunctionData)({
-        abi: (0, viem_1.parseAbi)([
+    const initData = encodeFunctionData({
+        abi: parseAbi([
             'function setup(address[] calldata _owners,uint256 _threshold,address to,bytes calldata data,address fallbackHandler,address paymentToken,uint256 payment, address paymentReceiver) external',
         ]),
         functionName: 'setup',
@@ -160,21 +150,21 @@ function getV0DeployArgs(config) {
             launchpad,
             calldata,
             adapter,
-            viem_1.zeroAddress,
+            zeroAddress,
             BigInt(0),
-            viem_1.zeroAddress,
+            zeroAddress,
         ],
     });
     const account = config.account;
     const saltNonce = account?.nonce ?? 0n;
-    const factoryData = (0, viem_1.encodeFunctionData)({
-        abi: (0, viem_1.parseAbi)([
+    const factoryData = encodeFunctionData({
+        abi: parseAbi([
             'function createProxyWithNonce(address singleton,bytes calldata initializer,uint256 saltNonce) external payable returns (address)',
         ]),
         functionName: 'createProxyWithNonce',
         args: [SAFE_SINGLETON_ADDRESS, initData, saltNonce],
     });
-    const salt = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes32', 'uint256'], [(0, viem_1.keccak256)(initData), saltNonce]));
+    const salt = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initData), saltNonce]));
     return {
         factory: SAFE_PROXY_FACTORY_ADDRESS,
         factoryData,
@@ -192,29 +182,29 @@ function getAddress(config) {
         throw new Error('Cannot derive address: deploy args not available');
     }
     const { factory, implementation, salt } = deployArgs;
-    const constructorArgs = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)('address singleton'), [implementation]);
-    const address = (0, viem_1.getContractAddress)({
+    const constructorArgs = encodeAbiParameters(parseAbiParameters('address singleton'), [implementation]);
+    const address = getContractAddress({
         opcode: 'CREATE2',
         from: factory,
         salt,
-        bytecode: (0, viem_1.concat)([SAFE_PROXY_INIT_CODE, constructorArgs]),
+        bytecode: concat([SAFE_PROXY_INIT_CODE, constructorArgs]),
     });
     return address;
 }
 function getEip712Domain(config, chain) {
     if (config.initData && !('factory' in config.initData)) {
-        throw new error_1.Eip712DomainNotAvailableError('Existing Safe-7579 accounts are not yet supported');
+        throw new Eip712DomainNotAvailableError('Existing Safe-7579 accounts are not yet supported');
     }
     return {
         name: 'rhinestone safe7579',
         version: 'v1.0.0',
         chainId: chain.id,
         verifyingContract: getAddress(config),
-        salt: viem_1.zeroHash,
+        salt: zeroHash,
     };
 }
 function getInstallData(module) {
-    return (0, viem_1.encodeFunctionData)({
+    return encodeFunctionData({
         abi: [
             {
                 type: 'function',
@@ -242,33 +232,33 @@ function getInstallData(module) {
     });
 }
 async function packSignature(signature, validator, transformSignature = (signature) => signature) {
-    return (0, viem_1.encodePacked)(['address', 'bytes'], [validator.address, transformSignature(signature)]);
+    return encodePacked(['address', 'bytes'], [validator.address, transformSignature(signature)]);
 }
 async function getSmartAccount(client, address, owners, validatorAddress, sign) {
     return getBaseSmartAccount(address, client, validatorAddress, async () => {
-        return (0, validators_1.getMockSignature)(owners);
+        return getMockSignature(owners);
     }, sign);
 }
 async function getGuardianSmartAccount(client, address, guardians, validatorAddress, sign) {
     return await getBaseSmartAccount(address, client, validatorAddress, async () => {
-        return (0, validators_1.getMockSignature)(guardians);
+        return getMockSignature(guardians);
     }, async (hash) => {
         return await sign(hash);
     });
 }
 async function getBaseSmartAccount(address, client, validatorAddress, getStubSignature, signUserOperation) {
-    return await (0, account_abstraction_1.toSmartAccount)({
+    return await toSmartAccount({
         client,
         entryPoint: {
-            abi: account_abstraction_1.entryPoint07Abi,
-            address: account_abstraction_1.entryPoint07Address,
+            abi: entryPoint07Abi,
+            address: entryPoint07Address,
             version: '0.7',
         },
         async decodeCalls() {
             throw new Error('Not implemented');
         },
         async encodeCalls(calls) {
-            return (0, utils_1.encode7579Calls)({
+            return encode7579Calls({
                 mode: {
                     type: calls.length > 1 ? 'batchcall' : 'call',
                     revertOnError: false,
@@ -285,10 +275,10 @@ async function getBaseSmartAccount(address, client, validatorAddress, getStubSig
             return {};
         },
         async getNonce() {
-            const key = (0, viem_1.concat)([validatorAddress, '0x00000000']);
-            const nonce = await (0, utils_1.getAccountNonce)(client, {
+            const key = concat([validatorAddress, '0x00000000']);
+            const nonce = await getAccountNonce(client, {
                 address,
-                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                entryPointAddress: entryPoint07Address,
                 key: BigInt(key),
             });
             return nonce;
@@ -306,13 +296,13 @@ async function getBaseSmartAccount(address, client, validatorAddress, getStubSig
             const { chainId = client.chain?.id, ...userOperation } = parameters;
             if (!chainId)
                 throw new Error('Chain id not found');
-            const hash = (0, account_abstraction_1.getUserOperationHash)({
+            const hash = getUserOperationHash({
                 userOperation: {
                     ...userOperation,
                     sender: userOperation.sender ?? (await this.getAddress()),
                     signature: '0x',
                 },
-                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                entryPointAddress: entryPoint07Address,
                 entryPointVersion: '0.7',
                 chainId: chainId,
             });
@@ -322,7 +312,7 @@ async function getBaseSmartAccount(address, client, validatorAddress, getStubSig
 }
 function getOwners(config) {
     if (!config.owners) {
-        throw new error_1.OwnersFieldRequiredError();
+        throw new OwnersFieldRequiredError();
     }
     const ownerSet = config.owners;
     switch (ownerSet.type) {
@@ -337,7 +327,7 @@ function getOwners(config) {
 }
 function getThreshold(config) {
     if (!config.owners) {
-        throw new error_1.OwnersFieldRequiredError();
+        throw new OwnersFieldRequiredError();
     }
     const ownerSet = config.owners;
     switch (ownerSet.type) {
@@ -350,3 +340,4 @@ function getThreshold(config) {
             return 1n;
     }
 }
+export { getEip712Domain, getInstallData, getAddress, packSignature, getDeployArgs, getV0DeployArgs, getSmartAccount, getGuardianSmartAccount, };

package/dist/src/accounts/signing/common.d.ts

@@ -1,7 +1,7 @@
 import { type Account, type Address, type Chain, type Hex } from 'viem';
 import type { WebAuthnAccount } from 'viem/account-abstraction';
-import { type ResolvedSessionSignerSet } from '../../modules/validators/smart-sessions';
-import type { OwnerSet, SignerSet } from '../../types';
+import { type ResolvedSessionSignerSet } from '../../modules/validators/smart-sessions.js';
+import type { OwnerSet, SignerSet } from '../../types.js';
 declare function convertOwnerSetToSignerSet(owners: OwnerSet): SignerSet;
 type WebAuthnSignMetadata = {
     authenticatorData: Hex;

package/dist/src/accounts/signing/common.js

@@ -1,15 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertOwnerSetToSignerSet = convertOwnerSetToSignerSet;
-exports.signWithMultiFactorAuth = signWithMultiFactorAuth;
-exports.signWithSession = signWithSession;
-exports.signWithGuardians = signWithGuardians;
-exports.signWithOwners = signWithOwners;
-const viem_1 = require("viem");
-const modules_1 = require("../../modules");
-const core_1 = require("../../modules/validators/core");
-const smart_sessions_1 = require("../../modules/validators/smart-sessions");
-const passkeys_1 = require("./passkeys");
+import { concat, createWalletClient, custom, encodeAbiParameters, encodePacked, hashMessage, pad, padHex, toHex, } from 'viem';
+import { isRip7212SupportedNetwork } from '../../modules/index.js';
+import { ENS_VALIDATOR_ADDRESS, getValidator, OWNABLE_VALIDATOR_ADDRESS, WEBAUTHN_V0_VALIDATOR_ADDRESS, } from '../../modules/validators/core.js';
+import { packSignature as packSmartSessionSignature, } from '../../modules/validators/smart-sessions.js';
+import { generateCredentialId, packSignature as packPasskeySignature, packSignatureV0 as packPasskeySignatureV0, parsePublicKey, parseSignature, } from './passkeys.js';
 function convertOwnerSetToSignerSet(owners) {
     switch (owners.type) {
         case 'ecdsa': {
@@ -17,7 +10,7 @@ function convertOwnerSetToSignerSet(owners) {
                 type: 'owner',
                 kind: 'ecdsa',
                 accounts: owners.accounts,
-                module: owners.module ?? core_1.OWNABLE_VALIDATOR_ADDRESS,
+                module: owners.module ?? OWNABLE_VALIDATOR_ADDRESS,
             };
         }
         case 'ens': {
@@ -25,7 +18,7 @@ function convertOwnerSetToSignerSet(owners) {
                 type: 'owner',
                 kind: 'ecdsa',
                 accounts: owners.accounts,
-                module: owners.module ?? core_1.ENS_VALIDATOR_ADDRESS,
+                module: owners.module ?? ENS_VALIDATOR_ADDRESS,
             };
         }
         case 'passkey': {
@@ -47,7 +40,7 @@ function convertOwnerSetToSignerSet(owners) {
                                 type: validator.type,
                                 id: index,
                                 accounts: validator.accounts,
-                                module: validator.module ?? core_1.OWNABLE_VALIDATOR_ADDRESS,
+                                module: validator.module ?? OWNABLE_VALIDATOR_ADDRESS,
                             };
                         }
                         case 'ens': {
@@ -55,7 +48,7 @@ function convertOwnerSetToSignerSet(owners) {
                                 type: 'ecdsa',
                                 id: index,
                                 accounts: validator.accounts,
-                                module: validator.module ?? core_1.ENS_VALIDATOR_ADDRESS,
+                                module: validator.module ?? ENS_VALIDATOR_ADDRESS,
                             };
                         }
                         case 'passkey': {
@@ -83,7 +76,7 @@ async function signWithMultiFactorAuth(signers, chain, address, params, isUserOp
         const validatorSigners = convertOwnerSetToSignerSet(validator);
         return signMain(validatorSigners, chain, address, params, isUserOpHash);
     }));
-    const data = (0, viem_1.encodeAbiParameters)([
+    const data = encodeAbiParameters([
         {
             components: [
                 {
@@ -98,10 +91,10 @@ async function signWithMultiFactorAuth(signers, chain, address, params, isUserOp
         },
     ], [
         signers.validators.map((validator, index) => {
-            const validatorModule = (0, core_1.getValidator)(validator);
+            const validatorModule = getValidator(validator);
             return {
-                packedValidatorAndId: (0, viem_1.concat)([
-                    (0, viem_1.pad)((0, viem_1.toHex)(validator.id), {
+                packedValidatorAndId: concat([
+                    pad(toHex(validator.id), {
                         size: 12,
                     }),
                     validatorModule.address,
@@ -116,15 +109,15 @@ async function signWithSession(signers, chain, address, hash, signMain) {
     const sessionSigners = convertOwnerSetToSignerSet(signers.session.owners);
     const signedHash = signers.verifyExecutions
         ? hash
-        : (0, viem_1.hashMessage)({
-            raw: (0, viem_1.encodePacked)(['bytes32', 'bytes32'], [(0, viem_1.padHex)(address), hash]),
+        : hashMessage({
+            raw: encodePacked(['bytes32', 'bytes32'], [padHex(address), hash]),
         });
     const validatorSignature = await signMain(sessionSigners, chain, address, signedHash, false);
-    return (0, smart_sessions_1.packSignature)(signers, validatorSignature);
+    return packSmartSessionSignature(signers, validatorSignature);
 }
 async function signWithGuardians(signers, params, signingFunctions) {
     const signatures = await Promise.all(signers.guardians.map((account) => signingFunctions.signEcdsa(account, params, false)));
-    return (0, viem_1.concat)(signatures);
+    return concat(signatures);
 }
 async function signWithOwners(signers, chain, address, params, signingFunctions, isUserOpHash, signMain) {
     async function signEcdsWithChain(account, params, updateV, chain) {
@@ -132,9 +125,9 @@ async function signWithOwners(signers, chain, address, params, signingFunctions,
         const transport = client?.transport;
         if (transport) {
             // Switch chain
-            const walletClient = (0, viem_1.createWalletClient)({
+            const walletClient = createWalletClient({
                 chain,
-                transport: (0, viem_1.custom)(transport),
+                transport: custom(transport),
                 account,
             });
             await walletClient.switchChain({
@@ -150,22 +143,22 @@ async function signWithOwners(signers, chain, address, params, signingFunctions,
             // ENS validator (based on Ownable) also uses the same signature format
             // This is not needed for UserOps
             const isOwnableOrENS = !signers.module ||
-                signers.module?.toLowerCase() === core_1.OWNABLE_VALIDATOR_ADDRESS ||
-                signers.module?.toLowerCase() === core_1.ENS_VALIDATOR_ADDRESS;
+                signers.module?.toLowerCase() === OWNABLE_VALIDATOR_ADDRESS ||
+                signers.module?.toLowerCase() === ENS_VALIDATOR_ADDRESS;
             const updateV = isOwnableOrENS && !isUserOpHash;
             const signatures = await Promise.all(signers.accounts.map((account) => signEcdsWithChain(account, params, updateV, chain)));
-            return (0, viem_1.concat)(signatures);
+            return concat(signatures);
         }
         case 'passkey': {
             const signatures = await Promise.all(signers.accounts.map((account) => signingFunctions.signPasskey(account, params)));
-            const usePrecompile = (0, modules_1.isRip7212SupportedNetwork)(chain);
+            const usePrecompile = isRip7212SupportedNetwork(chain);
             const credIds = signers.accounts.map((account) => {
                 const publicKey = account.publicKey;
-                const { x, y } = (0, passkeys_1.parsePublicKey)(publicKey);
-                return (0, passkeys_1.generateCredentialId)(x, y, address);
+                const { x, y } = parsePublicKey(publicKey);
+                return generateCredentialId(x, y, address);
             });
             const webAuthns = signatures.map((signature) => {
-                const { r, s } = (0, passkeys_1.parseSignature)(signature.signature);
+                const { r, s } = parseSignature(signature.signature);
                 return {
                     authenticatorData: signature.webauthn.authenticatorData,
                     clientDataJSON: signature.webauthn.clientDataJSON,
@@ -175,10 +168,10 @@ async function signWithOwners(signers, chain, address, params, signingFunctions,
                     s,
                 };
             });
-            if (signers.module?.toLowerCase() === core_1.WEBAUTHN_V0_VALIDATOR_ADDRESS) {
-                return (0, passkeys_1.packSignatureV0)(webAuthns[0], usePrecompile);
+            if (signers.module?.toLowerCase() === WEBAUTHN_V0_VALIDATOR_ADDRESS) {
+                return packPasskeySignatureV0(webAuthns[0], usePrecompile);
             }
-            return (0, passkeys_1.packSignature)(credIds, usePrecompile, webAuthns);
+            return packPasskeySignature(credIds, usePrecompile, webAuthns);
         }
         case 'multi-factor': {
             return signWithMultiFactorAuth(signers, chain, address, params, isUserOpHash, signMain);
@@ -188,3 +181,4 @@ async function signWithOwners(signers, chain, address, params, signingFunctions,
         }
     }
 }
+export { convertOwnerSetToSignerSet, signWithMultiFactorAuth, signWithSession, signWithGuardians, signWithOwners, };

package/dist/src/accounts/signing/message.d.ts

@@ -1,6 +1,6 @@
 import { type Address, type Chain, type Hex } from 'viem';
-import type { ResolvedSessionSignerSet } from '../../modules/validators/smart-sessions';
-import type { SignerSet } from '../../types';
+import type { ResolvedSessionSignerSet } from '../../modules/validators/smart-sessions.js';
+import type { SignerSet } from '../../types.js';
 type InternalSignerSet = SignerSet | ResolvedSessionSignerSet;
 declare function sign(signers: InternalSignerSet, chain: Chain, address: Address, hash: Hex, isUserOpHash: boolean): Promise<Hex>;
 export { sign };

package/dist/src/accounts/signing/message.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sign = sign;
-const viem_1 = require("viem");
-const error_1 = require("../error");
-const common_1 = require("./common");
+import { concat, parseSignature, toHex, } from 'viem';
+import { SigningNotSupportedForAccountError } from '../error.js';
+import { signWithGuardians, signWithOwners, signWithSession, } from './common.js';
 async function sign(signers, chain, address, hash, isUserOpHash) {
     const signingFunctions = {
         signEcdsa: (account, hash, updateV) => signEcdsa(account, hash, updateV),
@@ -11,31 +8,31 @@ async function sign(signers, chain, address, hash, isUserOpHash) {
     };
     switch (signers.type) {
         case 'owner': {
-            return (0, common_1.signWithOwners)(signers, chain, address, hash, signingFunctions, isUserOpHash, sign);
+            return signWithOwners(signers, chain, address, hash, signingFunctions, isUserOpHash, sign);
         }
         case 'experimental_session': {
-            return (0, common_1.signWithSession)(signers, chain, address, hash, sign);
+            return signWithSession(signers, chain, address, hash, sign);
         }
         case 'guardians': {
-            return (0, common_1.signWithGuardians)(signers, hash, signingFunctions);
+            return signWithGuardians(signers, hash, signingFunctions);
         }
     }
 }
 async function signEcdsa(account, hash, updateV) {
     if (!account.signMessage) {
-        throw new error_1.SigningNotSupportedForAccountError();
+        throw new SigningNotSupportedForAccountError();
     }
     const originalSignature = await account.signMessage({
         message: { raw: hash },
     });
     // Manually tweak the `v` value to trigger the message prefixing onchain
     // https://github.com/rhinestonewtf/checknsignatures/blob/main/src/CheckNSignatures.sol#L53-L61
-    const { r, s, v } = (0, viem_1.parseSignature)(originalSignature);
+    const { r, s, v } = parseSignature(originalSignature);
     if (!v) {
         throw new Error('Invalid signature');
     }
     const newV = updateV ? v + 4n : v;
-    const newSignature = (0, viem_1.concat)([r, s, (0, viem_1.toHex)(newV)]);
+    const newSignature = concat([r, s, toHex(newV)]);
     return newSignature;
 }
 async function signPasskey(account, hash) {
@@ -45,3 +42,4 @@ async function signPasskey(account, hash) {
         signature,
     };
 }
+export { sign };

package/dist/src/accounts/signing/passkeys.js

@@ -1,32 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePublicKey = parsePublicKey;
-exports.parseSignature = parseSignature;
-exports.generateCredentialId = generateCredentialId;
-exports.packSignature = packSignature;
-exports.packSignatureV0 = packSignatureV0;
-const viem_1 = require("viem");
+import { bytesToHex, encodeAbiParameters, hexToBytes, keccak256, } from 'viem';
 function parsePublicKey(publicKey) {
-    const bytes = typeof publicKey === 'string' ? (0, viem_1.hexToBytes)(publicKey) : publicKey;
+    const bytes = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;
     const offset = bytes.length === 65 ? 1 : 0;
     const x = bytes.slice(offset, 32 + offset);
     const y = bytes.slice(32 + offset, 64 + offset);
     return {
-        x: BigInt((0, viem_1.bytesToHex)(x)),
-        y: BigInt((0, viem_1.bytesToHex)(y)),
+        x: BigInt(bytesToHex(x)),
+        y: BigInt(bytesToHex(y)),
     };
 }
 function parseSignature(signature) {
-    const bytes = typeof signature === 'string' ? (0, viem_1.hexToBytes)(signature) : signature;
+    const bytes = typeof signature === 'string' ? hexToBytes(signature) : signature;
     const r = bytes.slice(0, 32);
     const s = bytes.slice(32, 64);
     return {
-        r: BigInt((0, viem_1.bytesToHex)(r)),
-        s: BigInt((0, viem_1.bytesToHex)(s)),
+        r: BigInt(bytesToHex(r)),
+        s: BigInt(bytesToHex(s)),
     };
 }
 function generateCredentialId(pubKeyX, pubKeyY, account) {
-    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+    return keccak256(encodeAbiParameters([
         {
             type: 'uint256',
         },
@@ -48,7 +41,7 @@ function packSignature(credIds, usePrecompile, webAuthns) {
     credIds = credIdsAndWebAuthns.map(({ credId }) => credId);
     webAuthns = credIdsAndWebAuthns.map(({ webAuthn }) => webAuthn);
     // Encode
-    return (0, viem_1.encodeAbiParameters)([
+    return encodeAbiParameters([
         {
             type: 'bytes32[]',
             name: 'credIds',
@@ -90,7 +83,7 @@ function packSignature(credIds, usePrecompile, webAuthns) {
     ], [credIds, usePrecompile, webAuthns]);
 }
 function packSignatureV0(webauthn, usePrecompiled) {
-    return (0, viem_1.encodeAbiParameters)([
+    return encodeAbiParameters([
         { type: 'bytes', name: 'authenticatorData' },
         {
             type: 'string',
@@ -123,3 +116,4 @@ function packSignatureV0(webauthn, usePrecompiled) {
         usePrecompiled,
     ]);
 }
+export { parsePublicKey, parseSignature, generateCredentialId, packSignature, packSignatureV0, };

package/dist/src/accounts/signing/typedData.d.ts

@@ -1,5 +1,5 @@
 import type { Address, Chain, HashTypedDataParameters, Hex, TypedData } from 'viem';
-import type { SignerSet } from '../../types';
+import type { SignerSet } from '../../types.js';
 declare function sign<typedData extends TypedData | Record<string, unknown> = TypedData, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData>(signers: SignerSet, chain: Chain, address: Address, parameters: HashTypedDataParameters<typedData, primaryType>): Promise<Hex>;
 export { sign };
 //# sourceMappingURL=typedData.d.ts.map

package/dist/src/accounts/signing/typedData.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sign = sign;
-const error_1 = require("../error");
-const common_1 = require("./common");
+import { SigningNotSupportedForAccountError } from '../error.js';
+import { signWithGuardians, signWithOwners, } from './common.js';
 async function sign(signers, chain, address, parameters) {
     const signingFunctions = {
         signEcdsa: (account, params) => signEcdsa(account, params),
@@ -10,10 +7,10 @@ async function sign(signers, chain, address, parameters) {
     };
     switch (signers.type) {
         case 'owner': {
-            return (0, common_1.signWithOwners)(signers, chain, address, parameters, signingFunctions, false, sign);
+            return signWithOwners(signers, chain, address, parameters, signingFunctions, false, sign);
         }
         case 'guardians': {
-            return (0, common_1.signWithGuardians)(signers, parameters, signingFunctions);
+            return signWithGuardians(signers, parameters, signingFunctions);
         }
         case 'experimental_session': {
             throw new Error('Not supported');
@@ -22,7 +19,7 @@ async function sign(signers, chain, address, parameters) {
 }
 async function signEcdsa(account, parameters) {
     if (!account.signTypedData) {
-        throw new error_1.SigningNotSupportedForAccountError();
+        throw new SigningNotSupportedForAccountError();
     }
     return await account.signTypedData(parameters);
 }
@@ -33,3 +30,4 @@ async function signPasskey(account, parameters) {
         signature,
     };
 }
+export { sign };

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

@@ -1,7 +1,7 @@
 import type { Address, Chain, Hex, PublicClient } from 'viem';
-import type { Module } from '../modules/common';
-import type { OwnerSet, RhinestoneAccountConfig } from '../types';
-import type { ValidatorConfig } from './utils';
+import type { Module } from '../modules/common.js';
+import type { OwnerSet, RhinestoneAccountConfig } from '../types.js';
+import type { ValidatorConfig } from './utils.js';
 declare const K1_DEFAULT_VALIDATOR_ADDRESS: Address;
 declare function getDeployArgs(config: RhinestoneAccountConfig): {
     factory: `0x${string}`;