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

package/dist/src/accounts/safe.js

@@ -1,337 +0,0 @@
-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';
-const SAFE_7579_ADAPTER_V1_ADDRESS = '0x7579ee8307284f293b1927136486880611f20002';
-const SAFE_SINGLETON_ADDRESS = '0x29fcb43b46531bca003ddc8fcb67ffe91900c762';
-const SAFE_PROXY_FACTORY_ADDRESS = '0x4e1dcf7ad4e460cfd30791ccc4f9c8a4f820ec67';
-const NO_SAFE_OWNER_ADDRESS = '0xbabe99e62d8bcbd3acf5ccbcfcd4f64fe75e5e72';
-const SAFE_PROXY_INIT_CODE = '0x608060405234801561001057600080fd5b506040516101e63803806101e68339818101604052602081101561003357600080fd5b8101908080519060200190929190505050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156100ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806101c46022913960400191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505060ab806101196000396000f3fe608060405273ffffffffffffffffffffffffffffffffffffffff600054167fa619486e0000000000000000000000000000000000000000000000000000000060003514156050578060005260206000f35b3660008037600080366000845af43d6000803e60008114156070573d6000fd5b3d6000f3fea264697066735822122003d1488ee65e08fa41e58e888a9865554c535f2c77126a82cb4c0f917f31441364736f6c63430007060033496e76616c69642073696e676c65746f6e20616464726573732070726f7669646564';
-function getDeployArgs(config) {
-    if (config.initData) {
-        if (!('factory' in config.initData)) {
-            return null;
-        }
-        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 AccountConfigurationNotSupportedError('Invalid factory data', 'safe');
-        }
-        const implementation = factoryData.args[0];
-        const initData = factoryData.args[1];
-        const saltNonce = factoryData.args[2];
-        const salt = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initData), saltNonce]));
-        return {
-            factory: config.initData.factory,
-            factoryData: config.initData.factoryData,
-            salt,
-            implementation,
-            initializationCallData: null,
-        };
-    }
-    const owners = getOwners(config);
-    const threshold = getThreshold(config);
-    const moduleSetup = getModuleSetup(config);
-    const modules = [
-        ...moduleSetup.validators,
-        ...moduleSetup.executors,
-        ...moduleSetup.fallbacks,
-        ...moduleSetup.hooks,
-    ];
-    const adapter = SAFE_7579_ADAPTER_V2_ADDRESS;
-    const launchpad = SAFE_7579_LAUNCHPAD_V2_ADDRESS;
-    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',
-        ]),
-        functionName: 'addSafe7579',
-        args: [
-            adapter,
-            modules.map((m) => ({
-                module: m.address,
-                initData: m.initData,
-                moduleType: m.type,
-            })),
-            [],
-            0,
-        ],
-    });
-    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',
-        args: [
-            owners,
-            threshold,
-            launchpad,
-            calldata,
-            adapter,
-            zeroAddress,
-            BigInt(0),
-            zeroAddress,
-        ],
-    });
-    const account = config.account;
-    const saltNonce = account?.nonce ?? 0n;
-    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 = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initData), saltNonce]));
-    return {
-        factory: SAFE_PROXY_FACTORY_ADDRESS,
-        factoryData,
-        salt,
-        implementation: SAFE_SINGLETON_ADDRESS,
-        initializationCallData: null,
-    };
-}
-function getV0DeployArgs(config) {
-    if (config.initData) {
-        throw new AccountConfigurationNotSupportedError('Custom V0 accounts are not supported', 'safe');
-    }
-    const owners = getOwners(config);
-    const threshold = getThreshold(config);
-    const attesters = getV0Attesters();
-    const moduleSetup = getV0ModuleSetup(config);
-    const adapter = SAFE_7579_ADAPTER_V1_ADDRESS;
-    const launchpad = SAFE_7579_LAUNCHPAD_V1_ADDRESS;
-    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',
-        ]),
-        functionName: 'addSafe7579',
-        args: [
-            adapter,
-            moduleSetup.validators.map((v) => ({
-                module: v.address,
-                initData: v.initData,
-            })),
-            moduleSetup.executors.map((e) => ({
-                module: e.address,
-                initData: e.initData,
-            })),
-            moduleSetup.fallbacks.map((f) => ({
-                module: f.address,
-                initData: f.initData,
-            })),
-            moduleSetup.hooks.map((h) => ({
-                module: h.address,
-                initData: h.initData,
-            })),
-            attesters.addresses,
-            attesters.threshold,
-        ],
-    });
-    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',
-        args: [
-            owners,
-            threshold,
-            launchpad,
-            calldata,
-            adapter,
-            zeroAddress,
-            BigInt(0),
-            zeroAddress,
-        ],
-    });
-    const account = config.account;
-    const saltNonce = account?.nonce ?? 0n;
-    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 = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initData), saltNonce]));
-    return {
-        factory: SAFE_PROXY_FACTORY_ADDRESS,
-        factoryData,
-        salt,
-        implementation: SAFE_SINGLETON_ADDRESS,
-        initializationCallData: null,
-    };
-}
-function getAddress(config) {
-    const deployArgs = getDeployArgs(config);
-    if (!deployArgs) {
-        if (config.initData?.address) {
-            return config.initData.address;
-        }
-        throw new Error('Cannot derive address: deploy args not available');
-    }
-    const { factory, implementation, salt } = deployArgs;
-    const constructorArgs = encodeAbiParameters(parseAbiParameters('address singleton'), [implementation]);
-    const address = getContractAddress({
-        opcode: 'CREATE2',
-        from: factory,
-        salt,
-        bytecode: concat([SAFE_PROXY_INIT_CODE, constructorArgs]),
-    });
-    return address;
-}
-function getEip712Domain(config, chain) {
-    if (config.initData && !('factory' in config.initData)) {
-        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: zeroHash,
-    };
-}
-function getInstallData(module) {
-    return encodeFunctionData({
-        abi: [
-            {
-                type: 'function',
-                name: 'installModule',
-                inputs: [
-                    {
-                        type: 'uint256',
-                        name: 'moduleTypeId',
-                    },
-                    {
-                        type: 'address',
-                        name: 'module',
-                    },
-                    {
-                        type: 'bytes',
-                        name: 'initData',
-                    },
-                ],
-                outputs: [],
-                stateMutability: 'nonpayable',
-            },
-        ],
-        functionName: 'installModule',
-        args: [module.type, module.address, module.initData],
-    });
-}
-async function packSignature(signature, validator, transformSignature = (signature) => signature) {
-    return encodePacked(['address', 'bytes'], [validator.address, transformSignature(signature)]);
-}
-async function getSmartAccount(client, address, owners, validatorAddress, sign) {
-    return getBaseSmartAccount(address, client, validatorAddress, async () => {
-        return getMockSignature(owners);
-    }, sign);
-}
-async function getBaseSmartAccount(address, client, validatorAddress, getStubSignature, signUserOperation) {
-    return await toSmartAccount({
-        client,
-        entryPoint: {
-            abi: entryPoint07Abi,
-            address: entryPoint07Address,
-            version: '0.7',
-        },
-        async decodeCalls() {
-            throw new Error('Not implemented');
-        },
-        async encodeCalls(calls) {
-            return encode7579Calls({
-                mode: {
-                    type: calls.length > 1 ? 'batchcall' : 'call',
-                    revertOnError: false,
-                    selector: '0x',
-                    context: '0x',
-                },
-                callData: calls,
-            });
-        },
-        async getAddress() {
-            return address;
-        },
-        async getFactoryArgs() {
-            return {};
-        },
-        async getNonce() {
-            const key = concat([validatorAddress, '0x00000000']);
-            const nonce = await getAccountNonce(client, {
-                address,
-                entryPointAddress: entryPoint07Address,
-                key: BigInt(key),
-            });
-            return nonce;
-        },
-        async getStubSignature() {
-            return getStubSignature();
-        },
-        async signMessage() {
-            throw new Error('Not implemented');
-        },
-        async signTypedData() {
-            throw new Error('Not implemented');
-        },
-        async signUserOperation(parameters) {
-            const { chainId = client.chain?.id, ...userOperation } = parameters;
-            if (!chainId)
-                throw new Error('Chain id not found');
-            const hash = getUserOperationHash({
-                userOperation: {
-                    ...userOperation,
-                    sender: userOperation.sender ?? (await this.getAddress()),
-                    signature: '0x',
-                },
-                entryPointAddress: entryPoint07Address,
-                entryPointVersion: '0.7',
-                chainId: chainId,
-            });
-            return await signUserOperation(hash);
-        },
-    });
-}
-function getOwners(config) {
-    if (!config.owners) {
-        throw new OwnersFieldRequiredError();
-    }
-    const ownerSet = config.owners;
-    switch (ownerSet.type) {
-        case 'ecdsa':
-            return ownerSet.accounts.map((account) => account.address);
-        case 'ens':
-            return ownerSet.owners.map((o) => o.account.address);
-        case 'passkey':
-            return [NO_SAFE_OWNER_ADDRESS];
-        case 'multi-factor':
-            return [NO_SAFE_OWNER_ADDRESS];
-    }
-}
-function getThreshold(config) {
-    if (!config.owners) {
-        throw new OwnersFieldRequiredError();
-    }
-    const ownerSet = config.owners;
-    switch (ownerSet.type) {
-        case 'ecdsa':
-        case 'ens':
-            return ownerSet.threshold ? BigInt(ownerSet.threshold) : 1n;
-        case 'passkey':
-            return 1n;
-        case 'multi-factor':
-            return 1n;
-    }
-}
-export { getEip712Domain, getInstallData, getAddress, packSignature, getDeployArgs, getV0DeployArgs, getSmartAccount, };

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

@@ -1,38 +0,0 @@
-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.js';
-import type { OwnerSet, SignerSet } from '../../types.js';
-declare function convertOwnerSetToSignerSet(owners: OwnerSet): SignerSet;
-type WebAuthnSignMetadata = {
-    authenticatorData: Hex;
-    challengeIndex?: number | undefined;
-    clientDataJSON: string;
-    typeIndex?: number | undefined;
-    userVerificationRequired?: boolean | undefined;
-};
-type SigningFunctions<T> = {
-    signEcdsa: (account: Account, params: T, updateV: boolean) => Promise<Hex>;
-    signPasskey: (account: WebAuthnAccount, params: T) => Promise<{
-        webauthn: WebAuthnSignMetadata;
-        signature: Hex;
-    }>;
-};
-declare function signWithMultiFactorAuth<T>(signers: SignerSet & {
-    type: 'owner';
-    kind: 'multi-factor';
-}, chain: Chain, address: Address, params: T, isUserOpHash: boolean, signMain: (signers: SignerSet, chain: Chain, address: Address, params: T, isUserOpHash: boolean) => Promise<Hex>): Promise<Hex>;
-declare function packMultiFactorOwnerSignatures(entries: {
-    id: number | Hex;
-    validatorAddress: Address;
-    signature: Hex;
-}[]): Hex;
-declare function packPasskeyOwnerSignatures(chain: Chain, address: Address, publicKeys: Hex[], signatures: {
-    webauthn: WebAuthnSignMetadata;
-    signature: Hex;
-}[], module?: Address): Hex;
-declare function signWithSession(signers: ResolvedSessionSignerSet, chain: Chain, address: Address, hash: Hex, signMain: (signers: SignerSet, chain: Chain, address: Address, hash: Hex, isUserOpHash: boolean) => Promise<Hex>): Promise<Hex>;
-declare function signWithOwners<T>(signers: SignerSet & {
-    type: 'owner';
-}, chain: Chain, address: Address, params: T, signingFunctions: SigningFunctions<T>, isUserOpHash: boolean, signMain: (signers: SignerSet, chain: Chain, address: Address, params: T, isUserOpHash: boolean) => Promise<Hex>): Promise<Hex>;
-export { convertOwnerSetToSignerSet, packMultiFactorOwnerSignatures, packPasskeyOwnerSignatures, signWithMultiFactorAuth, signWithSession, signWithOwners, type SigningFunctions, };
-//# sourceMappingURL=common.d.ts.map

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

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

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

@@ -1,186 +0,0 @@
-import { concat, createWalletClient, custom, encodeAbiParameters, encodePacked, hashMessage, pad, padHex, toHex, } from 'viem';
-import { isRip7212SupportedNetwork } from '../../modules/index.js';
-import { ENS_HCA_MODULE, 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': {
-            return {
-                type: 'owner',
-                kind: 'ecdsa',
-                accounts: owners.accounts,
-                module: owners.module ?? OWNABLE_VALIDATOR_ADDRESS,
-            };
-        }
-        case 'ens': {
-            return {
-                type: 'owner',
-                kind: 'ecdsa',
-                accounts: owners.owners.map((o) => o.account),
-                module: ENS_HCA_MODULE,
-            };
-        }
-        case 'passkey': {
-            return {
-                type: 'owner',
-                kind: 'passkey',
-                accounts: owners.accounts,
-                module: owners.module,
-            };
-        }
-        case 'multi-factor': {
-            return {
-                type: 'owner',
-                kind: 'multi-factor',
-                validators: owners.validators.map((validator, index) => {
-                    switch (validator.type) {
-                        case 'ecdsa': {
-                            return {
-                                type: validator.type,
-                                id: index,
-                                accounts: validator.accounts,
-                                module: validator.module ?? OWNABLE_VALIDATOR_ADDRESS,
-                            };
-                        }
-                        case 'ens': {
-                            return {
-                                type: 'ecdsa',
-                                id: index,
-                                accounts: validator.owners.map((o) => o.account),
-                                module: ENS_HCA_MODULE,
-                            };
-                        }
-                        case 'passkey': {
-                            return {
-                                type: 'passkey',
-                                id: index,
-                                accounts: validator.accounts,
-                                module: validator.module,
-                            };
-                        }
-                        default: {
-                            throw new Error(`Unsupported validator type: ${validator.type}`);
-                        }
-                    }
-                }),
-                module: owners.module,
-            };
-        }
-    }
-}
-async function signWithMultiFactorAuth(signers, chain, address, params, isUserOpHash, signMain) {
-    const signatures = await Promise.all(signers.validators.map(async (validator) => {
-        if (validator === null) {
-            return '0x';
-        }
-        const validatorSigners = convertOwnerSetToSignerSet(validator);
-        return signMain(validatorSigners, chain, address, params, isUserOpHash);
-    }));
-    return packMultiFactorOwnerSignatures(signers.validators.map((validator, index) => ({
-        id: validator.id,
-        validatorAddress: getValidator(validator).address,
-        signature: signatures[index],
-    })));
-}
-function packMultiFactorOwnerSignatures(entries) {
-    return encodeAbiParameters([
-        {
-            components: [
-                {
-                    internalType: 'bytes32',
-                    name: 'packedValidatorAndId',
-                    type: 'bytes32',
-                },
-                { internalType: 'bytes', name: 'data', type: 'bytes' },
-            ],
-            name: 'validators',
-            type: 'tuple[]',
-        },
-    ], [
-        entries.map((entry) => ({
-            packedValidatorAndId: concat([
-                pad(toHex(entry.id), {
-                    size: 12,
-                }),
-                entry.validatorAddress,
-            ]),
-            data: entry.signature,
-        })),
-    ]);
-}
-function packPasskeyOwnerSignatures(chain, address, publicKeys, signatures, module) {
-    const usePrecompile = isRip7212SupportedNetwork(chain);
-    const credIds = publicKeys.map((publicKey) => {
-        const { x, y } = parsePublicKey(publicKey);
-        return generateCredentialId(x, y, address);
-    });
-    const webAuthns = signatures.map((signature) => {
-        const { r, s } = parseSignature(signature.signature);
-        return {
-            authenticatorData: signature.webauthn.authenticatorData,
-            clientDataJSON: signature.webauthn.clientDataJSON,
-            challengeIndex: BigInt(signature.webauthn.challengeIndex ?? 0),
-            typeIndex: BigInt(signature.webauthn.typeIndex ?? 0),
-            r,
-            s,
-        };
-    });
-    if (module?.toLowerCase() === WEBAUTHN_V0_VALIDATOR_ADDRESS) {
-        return packPasskeySignatureV0(webAuthns[0], usePrecompile);
-    }
-    return packPasskeySignature(credIds, usePrecompile, webAuthns);
-}
-async function signWithSession(signers, chain, address, hash, signMain) {
-    const sessionSigners = convertOwnerSetToSignerSet(signers.session.owners);
-    const signedHash = signers.verifyExecutions
-        ? hash
-        : hashMessage({
-            raw: encodePacked(['bytes32', 'bytes32'], [padHex(address), hash]),
-        });
-    const validatorSignature = await signMain(sessionSigners, chain, address, signedHash, false);
-    return packSmartSessionSignature(signers, validatorSignature);
-}
-async function signWithOwners(signers, chain, address, params, signingFunctions, isUserOpHash, signMain) {
-    async function signEcdsWithChain(account, params, updateV, chain) {
-        const client = account.client;
-        const transport = client?.transport;
-        if (transport) {
-            // Switch chain
-            const walletClient = createWalletClient({
-                chain,
-                transport: custom(transport),
-                account,
-            });
-            await walletClient.switchChain({
-                id: chain.id,
-            });
-        }
-        // Sign
-        return signingFunctions.signEcdsa(account, params, updateV);
-    }
-    switch (signers.kind) {
-        case 'ecdsa': {
-            // Ownable validator uses `v` value to determine which validation mode to use
-            // ENS validator (based on Ownable) also uses the same signature format
-            // This is not needed for UserOps
-            const isOwnableOrENS = !signers.module ||
-                signers.module?.toLowerCase() === OWNABLE_VALIDATOR_ADDRESS ||
-                signers.module?.toLowerCase() === ENS_HCA_MODULE;
-            const updateV = isOwnableOrENS && !isUserOpHash;
-            const signatures = await Promise.all(signers.accounts.map((account) => signEcdsWithChain(account, params, updateV, chain)));
-            return concat(signatures);
-        }
-        case 'passkey': {
-            const signatures = await Promise.all(signers.accounts.map((account) => signingFunctions.signPasskey(account, params)));
-            return packPasskeyOwnerSignatures(chain, address, signers.accounts.map((account) => account.publicKey), signatures, signers.module);
-        }
-        case 'multi-factor': {
-            return signWithMultiFactorAuth(signers, chain, address, params, isUserOpHash, signMain);
-        }
-        default: {
-            throw new Error('Unsupported owner kind');
-        }
-    }
-}
-export { convertOwnerSetToSignerSet, packMultiFactorOwnerSignatures, packPasskeyOwnerSignatures, signWithMultiFactorAuth, signWithSession, signWithOwners, };

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

@@ -1,7 +0,0 @@
-import { type Address, type Chain, type Hex } from 'viem';
-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 };
-//# sourceMappingURL=message.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../../../accounts/signing/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,OAAO,EACZ,KAAK,KAAK,EAEV,KAAK,GAAG,EAGT,MAAM,MAAM,CAAA;AAEb,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAA;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAQ5C,KAAK,iBAAiB,GAAG,SAAS,GAAG,wBAAwB,CAAA;AAE7D,iBAAe,IAAI,CACjB,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,GAAG,EACT,YAAY,EAAE,OAAO,GACpB,OAAO,CAAC,GAAG,CAAC,CA4Bd;AA4BD,OAAO,EAAE,IAAI,EAAE,CAAA"}

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

@@ -1,42 +0,0 @@
-import { concat, parseSignature, toHex, } from 'viem';
-import { SigningNotSupportedForAccountError } from '../error.js';
-import { signWithOwners, signWithSession, } from './common.js';
-async function sign(signers, chain, address, hash, isUserOpHash) {
-    const signingFunctions = {
-        signEcdsa: (account, hash, updateV) => signEcdsa(account, hash, updateV),
-        signPasskey: (account, hash) => signPasskey(account, hash),
-    };
-    switch (signers.type) {
-        case 'owner': {
-            return signWithOwners(signers, chain, address, hash, signingFunctions, isUserOpHash, sign);
-        }
-        case 'experimental_session': {
-            return signWithSession(signers, chain, address, hash, sign);
-        }
-    }
-}
-async function signEcdsa(account, hash, updateV) {
-    if (!account.signMessage) {
-        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 } = parseSignature(originalSignature);
-    if (!v) {
-        throw new Error('Invalid signature');
-    }
-    const newV = updateV ? v + 4n : v;
-    const newSignature = concat([r, s, toHex(newV)]);
-    return newSignature;
-}
-async function signPasskey(account, hash) {
-    const { webauthn, signature } = await account.sign({ hash });
-    return {
-        webauthn,
-        signature,
-    };
-}
-export { sign };

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

@@ -1,36 +0,0 @@
-import { type Address, type Hex } from 'viem';
-interface WebAuthnSignature {
-    authenticatorData: Hex;
-    clientDataJSON: string;
-    challengeIndex: bigint;
-    typeIndex: bigint;
-    r: bigint;
-    s: bigint;
-}
-declare function parsePublicKey(publicKey: Hex | Uint8Array): {
-    x: bigint;
-    y: bigint;
-};
-declare function parseSignature(signature: Hex | Uint8Array): {
-    r: bigint;
-    s: bigint;
-};
-declare function generateCredentialId(pubKeyX: bigint, pubKeyY: bigint, account: Address): `0x${string}`;
-declare function packSignature(credIds: Hex[], usePrecompile: boolean, webAuthns: {
-    authenticatorData: Hex;
-    clientDataJSON: string;
-    challengeIndex: bigint;
-    typeIndex: bigint;
-    r: bigint;
-    s: bigint;
-}[]): Hex;
-declare function packSignatureV0(webauthn: {
-    authenticatorData: Hex;
-    clientDataJSON: string;
-    typeIndex: number | bigint;
-    r: bigint;
-    s: bigint;
-}, usePrecompiled: boolean): `0x${string}`;
-export { parsePublicKey, parseSignature, generateCredentialId, packSignature, packSignatureV0, };
-export type { WebAuthnSignature };
-//# sourceMappingURL=passkeys.d.ts.map

package/dist/src/accounts/signing/passkeys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"passkeys.d.ts","sourceRoot":"","sources":["../../../../accounts/signing/passkeys.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,GAAG,EAGT,MAAM,MAAM,CAAA;AAEb,UAAU,iBAAiB;IACzB,iBAAiB,EAAE,GAAG,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,iBAAS,cAAc,CAAC,SAAS,EAAE,GAAG,GAAG,UAAU,GAAG;IACpD,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAUA;AAED,iBAAS,cAAc,CAAC,SAAS,EAAE,GAAG,GAAG,UAAU,GAAG;IACpD,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CASA;AAED,iBAAS,oBAAoB,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,iBAkBjB;AAED,iBAAS,aAAa,CACpB,OAAO,EAAE,GAAG,EAAE,EACd,aAAa,EAAE,OAAO,EACtB,SAAS,EAAE;IACT,iBAAiB,EAAE,GAAG,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,EAAE,GACF,GAAG,CAqDL;AAED,iBAAS,eAAe,CACtB,QAAQ,EAAE;IACR,iBAAiB,EAAE,GAAG,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,EACD,cAAc,EAAE,OAAO,iBAqCxB;AAED,OAAO,EACL,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,eAAe,GAChB,CAAA;AACD,YAAY,EAAE,iBAAiB,EAAE,CAAA"}