@dynamic-labs/ethereum-aa-zksync 4.14.0

package/src/connector/ZKsyncConnector.cjs

@@ -0,0 +1,520 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var viem = require('viem');
+var zksync = require('viem/zksync');
+var passkey = require('zksync-sso/client/passkey');
+var utils$1 = require('zksync-sso/utils');
+var client = require('zksync-sso/client');
+var ecdsa = require('zksync-sso/client/ecdsa');
+var ethereumCore = require('@dynamic-labs/ethereum-core');
+var utils = require('@dynamic-labs/utils');
+var ethereumAaCore = require('@dynamic-labs/ethereum-aa-core');
+var getSalt = require('../utils/getSalt.cjs');
+var passkeys = require('../utils/passkeys.cjs');
+var deployment = require('../utils/deployment.cjs');
+var network = require('../utils/network.cjs');
+
+class ZKsyncConnector extends ethereumAaCore.AccountAbstractionBaseConnector {
+    constructor(props) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        super(props);
+        // Core wallet properties
+        this.ChainWallet = ethereumCore.EthereumWallet;
+        this.name = 'ZKsync';
+        this.overrideKey = 'zksync';
+        // Chain configuration
+        this.connectedChain = 'EVM';
+        this.evmNetworks = [];
+        this.supportedChains = ['ETH', 'EVM'];
+        this._isSmartAccountDeployed = false;
+        this.enablePasskeys = true;
+        this.enableEIP7702Mode = false;
+        this.walletFallback = {
+            brand: {
+                alt: 'Smart Wallet',
+                spriteId: 'smartwallet',
+            },
+            name: 'ZKsync',
+        };
+        this._walletUiUtils = props.walletUiUtils;
+        this.providersConfig = (_a = props.providersConfig) !== null && _a !== void 0 ? _a : {};
+        this.chainId = (_b = props.apiProviders.zksync) === null || _b === void 0 ? void 0 : _b.defaultChainId;
+        this.evmNetworks = utils.parseEvmNetworks(props.evmNetworks).filter((network) => network.chainId === this.chainId);
+        this.factoryAddress = (_c = props.apiProviders.zksync) === null || _c === void 0 ? void 0 : _c.factoryAddress; // Fallback if not provided
+        this.paymasterAddress = (_d = props.apiProviders.zksync) === null || _d === void 0 ? void 0 : _d.paymasterAddress; // Fallback if not provided
+        this.passkeyAddress = (_e = props.apiProviders.zksync) === null || _e === void 0 ? void 0 : _e.passkeyAddress; // Fallback if not provided
+        this.sessionKeyAddress = (_f = props.apiProviders.zksync) === null || _f === void 0 ? void 0 : _f.sessionAddress; // Fallback if not provided
+        this.saltText = (_g = props.apiProviders.zksync) === null || _g === void 0 ? void 0 : _g.salt;
+        this.enablePasskeys =
+            (_j = (_h = props.settings.sdk.accountAbstraction) === null || _h === void 0 ? void 0 : _h.enablePasskeys) !== null && _j !== void 0 ? _j : false;
+    }
+    getEnabledNetworks() {
+        return this.evmNetworks;
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = this.initializedDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            return [this.smartAccountAddress];
+        });
+    }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = this.initializedDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            return this.chainId;
+        });
+    }
+    getPublicClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return viem.createPublicClient({
+                chain: ethereumCore.getOrMapViemChain(this.evmNetworks[0]),
+                transport: viem.http(),
+            });
+        });
+    }
+    canSponsorTransactionGas() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    getAccountAbstractionProvider() {
+        return this.smartAccount;
+    }
+    getWalletClient(chainId) {
+        const smartAccountClient = this.smartAccount;
+        if (!smartAccountClient) {
+            return undefined;
+        }
+        const transport = this.getWalletClientTransport(smartAccountClient);
+        return viem.createWalletClient({
+            account: smartAccountClient.account,
+            chain: chainId ? ethereumCore.chainsMap[chainId] : smartAccountClient.chain,
+            transport,
+        });
+    }
+    getWalletClientTransport(smartAccountClient) {
+        return viem.custom({
+            request: (_a) => _tslib.__awaiter(this, [_a], void 0, function* ({ method, params, }) {
+                const handleRequest = () => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    var _b;
+                    switch (method) {
+                        case 'personal_sign':
+                            // Delegate signing to the smart account client instance
+                            return smartAccountClient.signMessage({ message: params[0] });
+                        case 'eth_signTypedData_v4': {
+                            // Delegate typed data signing to the smart account client instance
+                            // Note: ZKsync usually expects JSON string for EIP712, but viem standard passes object.
+                            // The smartAccountClient's signTypedData should handle the expected format internally.
+                            const signTypedDataParams = params[1]; // Assuming standard viem format
+                            return smartAccountClient.signTypedData(signTypedDataParams);
+                        }
+                        case 'eth_sendTransaction':
+                            // Delegate transaction sending to the smart account client instance.
+                            // This ensures deployment checks, paymaster logic, etc., are handled.
+                            return smartAccountClient.sendTransaction(params[0]);
+                        case 'eth_accounts':
+                        case 'eth_requestAccounts':
+                            // Return the smart account address
+                            return ((_b = smartAccountClient.account) === null || _b === void 0 ? void 0 : _b.address)
+                                ? [smartAccountClient.account.address]
+                                : [];
+                        case 'eth_chainId': {
+                            // Return chainId from the smart account client
+                            const chainId = yield smartAccountClient.getChainId();
+                            return viem.toHex(chainId);
+                        }
+                        default: {
+                            // For other read-only methods, delegate to a basic public client transport.
+                            // Avoid creating a new client/transport on every call if possible,
+                            // but for simplicity here, we create it transiently.
+                            // Consider caching the provided client if performance becomes an issue.
+                            return smartAccountClient.request({ method, params });
+                        }
+                    }
+                });
+                // The internal confirmationTransport used by smartAccountClient via its 'owner'
+                // should handle the UI prompts. We don't need to add extra prompts here.
+                return handleRequest();
+            }),
+        });
+    }
+    getTransport(provider) {
+        const transport = ethereumCore.confirmationTransport({
+            getAccounts: () => _tslib.__awaiter(this, void 0, void 0, function* () { return [provider.account.address]; }),
+            onPersonalSign: (_a) => _tslib.__awaiter(this, [_a], void 0, function* ({ message }) {
+                this._walletUiUtils.disabledConfirmationOnce();
+                if (!this._isSmartAccountDeployed) {
+                    yield this.deploySmartAccount({
+                        withPaymaster: true,
+                    });
+                }
+                this._walletUiUtils.disabledConfirmationOnce();
+                return provider.signMessage({
+                    message,
+                });
+            }),
+            onSignTypedData: (_b) => _tslib.__awaiter(this, [_b], void 0, function* ({ message }) {
+                this._walletUiUtils.disabledConfirmationOnce();
+                const signTypedData = JSON.parse(message);
+                if (!this._isSmartAccountDeployed) {
+                    yield this.deploySmartAccount({
+                        withPaymaster: true,
+                    });
+                }
+                this._walletUiUtils.disabledConfirmationOnce();
+                return provider.signTypedData({
+                    domain: signTypedData.domain,
+                    message: signTypedData.message,
+                    primaryType: signTypedData.primaryType,
+                    types: signTypedData.types,
+                });
+            }),
+            provider: provider.extend(viem.publicActions),
+            transport: viem.custom(provider, this.providersConfig.httpTransportConfig),
+            walletConnector: this,
+            walletUiUtils: this._walletUiUtils,
+        });
+        return transport;
+    }
+    createEcdsaClient(eoaConnector) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const eoaSigner = yield (eoaConnector === null || eoaConnector === void 0 ? void 0 : eoaConnector.getSigner());
+            if (!eoaSigner) {
+                throw new Error('EOA wallet client not found');
+            }
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const transport = this.getTransport(eoaSigner);
+            const ownerWithTransport = viem.createWalletClient(Object.assign(Object.assign({}, eoaSigner), { transport }));
+            const walletClient = yield ecdsa.createZksyncEcdsaClient({
+                address: this.smartAccountAddress,
+                chain: ethereumCore.getOrMapViemChain(this.evmNetworks[0]),
+                contracts: {
+                    accountFactory: this.factoryAddress,
+                    session: this.sessionKeyAddress,
+                },
+                owner: ownerWithTransport,
+                transport: viem.custom(ownerWithTransport),
+            });
+            return walletClient;
+        });
+    }
+    /**
+     * Implementation of the interface method required by IAccountAbstractionWalletConnector
+     * @param eoaConnector - The EOA connector to use for signing transactions
+     * @param smartAccountAddress - The address of the smart account
+     */
+    initialize(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ eoaConnector, smartWalletAddress, }) {
+            this.initializedDeferredPromise = this.initializedDeferredPromise
+                ? this.initializedDeferredPromise
+                : new utils.DeferredPromise();
+            this.eoaConnector = eoaConnector;
+            this.eoaAddress = (yield eoaConnector.getAddress());
+            this.smartAccountAddress = smartWalletAddress;
+            this.smartAccount = (yield this.createEcdsaClient(eoaConnector));
+            yield this.checkIsDeployed();
+            this.initializedDeferredPromise.resolve();
+        });
+    }
+    createSessionClient(sessionKey, sessionConfig) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            if (!this.sessionKeyAddress) {
+                throw new Error('Session key address is not initialized');
+            }
+            return client.createZksyncSessionClient({
+                address: this.smartAccountAddress,
+                chain: ethereumCore.getOrMapViemChain(this.evmNetworks[0]),
+                contracts: {
+                    session: this.sessionKeyAddress,
+                },
+                sessionConfig,
+                sessionKey,
+                transport: viem.http(),
+            });
+        });
+    }
+    /**
+     * Creates a passkey client for ZKsync authentication
+     *
+     * This method initializes a passkey client using stored credentials and
+     * configures it with the necessary contract addresses and chain information.
+     *
+     */
+    createPasskeyClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            if (!this.passkeyAddress) {
+                throw new Error('Passkey address is not initialized');
+            }
+            const storedCredentialPublicKey = utils.StorageService.getItem('credentialPublicKey');
+            if (!storedCredentialPublicKey) {
+                throw new Error('Credential public key not found');
+            }
+            const credentialPublicKey = new Uint8Array(Object.values(storedCredentialPublicKey));
+            const publicClient = yield this.getTypedPublicClient();
+            const { chain } = publicClient;
+            if (!chain) {
+                throw new Error('Chain information not available');
+            }
+            const contractAddresses = {
+                accountFactory: this.factoryAddress,
+                passkey: this.passkeyAddress,
+                recovery: this.recoveryAddress,
+                session: this.sessionKeyAddress,
+            };
+            this.passkeyClient = passkey.createZksyncPasskeyClient({
+                address: this.smartAccountAddress,
+                chain,
+                contracts: contractAddresses,
+                credentialPublicKey,
+                transport: viem.http(),
+                userDisplayName: this.smartAccountAddress,
+                userName: this.smartAccountAddress,
+            });
+        });
+    }
+    registerPasskeyAndDeploy() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const { credentialPublicKey, credentialId } = yield passkey.registerNewPasskey({
+                attestationType: 'none',
+                authenticatorSelection: {
+                    authenticatorAttachment: 'platform',
+                    requireResidentKey: false,
+                    userVerification: 'required',
+                },
+                userDisplayName: this.smartAccountAddress,
+                userName: this.smartAccountAddress,
+            });
+            utils.StorageService.setItem('credentialPublicKey', credentialPublicKey);
+            utils.StorageService.setItem('credentialId', credentialId);
+            yield this.deploySmartAccount({
+                withPaymaster: true,
+            });
+        });
+    }
+    deploySmartAccount(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ withPaymaster, }) {
+            if (!this.chainId) {
+                throw new Error('Chain ID is not initialized');
+            }
+            if (!this.eoaConnector) {
+                throw new Error('EOA connector is not initialized');
+            }
+            yield network.ensureEoaConnectorNetwork(this.eoaConnector, this.chainId);
+            if (withPaymaster && this.paymasterAddress) {
+                yield this.deploySmartAccountWithPaymaster();
+            }
+            else {
+                yield this.deploySmartAccountWithoutPaymaster();
+            }
+        });
+    }
+    deploySmartAccountWithPaymaster() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.paymasterAddress) {
+                throw new Error('Paymaster address is not initialized');
+            }
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            if (!this.eoaAddress) {
+                throw new Error('EOA address is not initialized');
+            }
+            const paymaster = this.paymasterAddress;
+            const publicClient = yield this.getTypedPublicClient();
+            const walletClient = yield this.getTypedWalletClient();
+            const deploymentParams = yield deployment.getDeploymentParameters({
+                enablePasskeys: this.enablePasskeys,
+                eoaAddress: this.eoaAddress,
+                passkeyAddress: this.passkeyAddress,
+                saltText: this.saltText,
+                sessionKeyAddress: this.sessionKeyAddress,
+            });
+            const { request } = yield deployment.simulateAccountDeployment(publicClient, walletClient, deploymentParams, this.factoryAddress, false);
+            const paymasterInput = zksync.getGeneralPaymasterInput({
+                innerInput: new Uint8Array(),
+            });
+            const requestWithPaymaster = Object.assign(Object.assign({}, request), { paymaster,
+                paymasterInput });
+            yield deployment.executeAccountDeployment(walletClient, publicClient, requestWithPaymaster, this.smartAccountAddress);
+            this._isSmartAccountDeployed = true;
+        });
+    }
+    /**
+     * Deploys a new smart account contract
+     * @throws {ZkSyncConnectorError} If deployment fails
+     * @testable This method can be mocked in tests
+     */
+    deploySmartAccountWithoutPaymaster() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.eoaConnector) {
+                throw new Error('EOA connector is not initialized');
+            }
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const walletClient = yield this.getTypedWalletClient();
+            const publicClient = yield this.getTypedPublicClient();
+            const deploymentParams = yield this.getDeploymentParameters();
+            // Simulate the contract deployment first
+            const { request } = yield deployment.simulateAccountDeployment(publicClient, walletClient, deploymentParams, this.factoryAddress, false);
+            // Execute the deployment transaction
+            yield deployment.executeAccountDeployment(walletClient, publicClient, request, this.smartAccountAddress);
+        });
+    }
+    /**
+     * Gets typed public client from EOA connector
+     * @throws {ZkSyncConnectorError} If public client cannot be obtained
+     * @testable This method can be mocked in tests
+     */
+    getTypedPublicClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.eoaConnector) {
+                throw new Error('EOA connector is not initialized');
+            }
+            const publicClient = yield this.eoaConnector.getPublicClient();
+            if (!publicClient) {
+                throw new Error('Failed to get public client from EOA connector');
+            }
+            return publicClient;
+        });
+    }
+    /**
+     * Gets typed wallet client from EOA connector on the correct chain
+     * @throws {ZkSyncConnectorError} If wallet client cannot be obtained
+     * @testable This method can be mocked in tests
+     */
+    getTypedWalletClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.eoaConnector) {
+                throw new Error('EOA connector is not initialized');
+            }
+            const walletClient = yield this.eoaConnector.getWalletClient();
+            if (!walletClient) {
+                throw new Error('Failed to get wallet client from EOA connector');
+            }
+            return walletClient
+                .extend(viem.publicActions)
+                .extend(viem.walletActions)
+                .extend(zksync.eip712WalletActions())
+                .extend(ecdsa.zksyncSsoEcdsaWalletActions);
+        });
+    }
+    /**
+     * Returns the parameters needed for deploying the smart account
+     * @returns Deployment parameters object
+     * @testable This method can be overridden in tests
+     */
+    getDeploymentParameters() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.eoaAddress) {
+                throw new Error('EOA address is not initialized');
+            }
+            const initialValidators = [];
+            const initialK1Owners = [this.eoaAddress];
+            // TODO: revisit this logic, maybe we should always add the passkey module data,
+            //  otherwise if people active passkeys later, old accounts will not be able to use passkey module
+            if (this.enablePasskeys && this.passkeyAddress) {
+                const encodedPasskeyModuleData = yield passkeys.getEncodedPasskeyModuleData({
+                    passkeyAddress: this.passkeyAddress,
+                });
+                initialValidators.push(encodedPasskeyModuleData);
+            }
+            if (this.sessionKeyAddress) {
+                const encodedSessionKeyModuleData = utils$1.encodeModuleData({
+                    address: this.sessionKeyAddress,
+                    parameters: '0x',
+                });
+                initialValidators.push(encodedSessionKeyModuleData);
+            }
+            return {
+                initialK1Owners,
+                initialValidators,
+                salt: getSalt.getSalt(this.saltText),
+            };
+        });
+    }
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const walletClient = this.getWalletClient();
+            if (!walletClient) {
+                throw new Error('Error fetching signer');
+            }
+            return walletClient.signMessage({
+                account: walletClient.account,
+                message,
+            });
+        });
+    }
+    /**
+     * Checks if a smart account is deployed
+     * @throws {ZkSyncConnectorError} If the check fails
+     * @returns Promise that resolves when the check is complete
+     */
+    checkIsDeployed() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const client = yield this.getPublicClient();
+            if (!client) {
+                throw new Error('Failed to get public client from EOA connector');
+            }
+            const code = yield client.getCode({
+                address: this.smartAccountAddress,
+            });
+            const isDeployed = Boolean(code);
+            this._isSmartAccountDeployed = isDeployed;
+            return isDeployed;
+        });
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = this.initializedDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            return this.smartAccountAddress;
+        });
+    }
+    validateActiveWallet(expectedAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const currentAddress = yield this.getAddress();
+            if (currentAddress !== expectedAddress) {
+                throw new utils.DynamicError('Invalid active wallet');
+            }
+        });
+    }
+    isSmartAccountDeployed() {
+        return _tslib.__awaiter(this, arguments, void 0, function* (refetch = false) {
+            if (refetch) {
+                yield this.checkIsDeployed();
+            }
+            return this._isSmartAccountDeployed;
+        });
+    }
+}
+
+exports.ZKsyncConnector = ZKsyncConnector;