@dynamic-labs/ethereum-aa 4.10.3 → 4.10.4-preview.1

package/src/ZKsyncConnector.cjs

@@ -0,0 +1,536 @@
+'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$1 = require('zksync-sso/client');
+var ethereumCore = require('@dynamic-labs/ethereum-core');
+var utils = require('@dynamic-labs/utils');
+var AccountAbstractionConnector = require('./AccountAbstractionConnector.cjs');
+var abi = require('./utils/abi.cjs');
+var client = require('./ZKsync/client.cjs');
+var walletActions = require('./ZKsync/walletActions.cjs');
+
+class ZKsyncConnector extends AccountAbstractionConnector.AccountAbstractionConnector {
+    constructor(props) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        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.enablePasskeys =
+            (_h = (_g = props.settings.sdk.accountAbstraction) === null || _g === void 0 ? void 0 : _g.enablePasskeys) !== null && _h !== void 0 ? _h : 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;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getWalletClient() {
+        if (!this.smartAccount) {
+            return undefined;
+        }
+        return this.smartAccount;
+    }
+    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),
+            // TODO: remove this. We should not be passing references to wallet connectors
+            walletConnector: this,
+            walletUiUtils: this._walletUiUtils,
+        });
+        return transport;
+    }
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.getWalletClient();
+        });
+    }
+    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');
+            }
+            const transport = this.getTransport(eoaSigner);
+            const ownerWithTransport = viem.createWalletClient(Object.assign(Object.assign({}, eoaSigner), { transport }));
+            const walletClient = yield client.createZksyncEcdsaClient({
+                address: this.smartAccountAddress,
+                chain: ethereumCore.getOrMapViemChain(this.evmNetworks[0]),
+                contracts: {
+                    accountFactory: this.factoryAddress,
+                    session: this.sessionKeyAddress,
+                },
+                owner: ownerWithTransport,
+                transport: viem.http(),
+            });
+            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
+     */
+    initializeZksyncConnector(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ eoaConnector, smartAccountAddress, }) {
+            this.initializedDeferredPromise = this.initializedDeferredPromise
+                ? this.initializedDeferredPromise
+                : new utils.DeferredPromise();
+            this.eoaConnector = eoaConnector;
+            this.eoaAddress = yield eoaConnector.getAddress();
+            this.smartAccountAddress = smartAccountAddress;
+            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');
+            }
+            return client$1.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');
+            }
+            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,
+                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* () {
+            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 (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');
+            }
+            const paymaster = this.paymasterAddress;
+            const publicClient = yield this.getTypedPublicClient();
+            const walletClient = yield this.getTypedWalletClient();
+            const deploymentParams = yield this.getDeploymentParameters();
+            const { request } = yield this.simulateAccountDeployment(publicClient, walletClient, deploymentParams, false);
+            const paymasterInput = zksync.getGeneralPaymasterInput({
+                innerInput: new Uint8Array(),
+            });
+            const requestWithPaymaster = Object.assign(Object.assign({}, request), { paymaster,
+                paymasterInput });
+            yield this.executeAccountDeployment(walletClient, requestWithPaymaster);
+        });
+    }
+    /**
+     * 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');
+            }
+            const walletClient = yield this.getTypedWalletClient();
+            const publicClient = yield this.getTypedPublicClient();
+            const deploymentParams = yield this.getDeploymentParameters();
+            // Simulate the contract deployment first
+            const { request } = yield this.simulateAccountDeployment(publicClient, walletClient, deploymentParams, false);
+            // Execute the deployment transaction
+            yield this.executeAccountDeployment(walletClient, request);
+        });
+    }
+    /**
+     * 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
+     * @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(walletActions.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* () {
+            const salt = `0x${Buffer.from(viem.toBytes('DynamicLabs', { size: 32 })).toString('hex')}`;
+            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 this.getEncodedPasskeyModuleData();
+                initialValidators.push(encodedPasskeyModuleData);
+            }
+            if (this.sessionKeyAddress) {
+                const encodedSessionKeyModuleData = utils$1.encodeModuleData({
+                    address: this.sessionKeyAddress,
+                    parameters: '0x',
+                });
+                initialValidators.push(encodedSessionKeyModuleData);
+            }
+            return {
+                initialK1Owners,
+                initialValidators,
+                salt,
+            };
+        });
+    }
+    /**
+     * Retrieves and encodes passkey module data for smart account deployment
+     * @returns Encoded passkey module data as a hex string
+     * @throws {Error} If credential public key or ID is not found
+     * @private
+     */
+    getEncodedPasskeyModuleData() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const storedCredentialPublicKey = utils.StorageService.getItem('credentialPublicKey');
+            if (!storedCredentialPublicKey) {
+                throw new Error('Credential public key not found');
+            }
+            const credentialPublicKey = new Uint8Array(Object.values(storedCredentialPublicKey));
+            const credentialId = utils.StorageService.getItem('credentialId');
+            if (!credentialId) {
+                throw new Error('Credential ID not found');
+            }
+            const passkeyPublicKey = utils$1.getPublicKeyBytesFromPasskeySignature(credentialPublicKey);
+            const encodedPasskeyParameters = utils$1.encodePasskeyModuleParameters({
+                credentialId: credentialId,
+                expectedOrigin: window.location.origin, // TODO: how is this going to be set?
+                passkeyPublicKey,
+            });
+            return utils$1.encodeModuleData({
+                address: this.passkeyAddress,
+                parameters: encodedPasskeyParameters,
+            });
+        });
+    }
+    /**
+     * Simulates the smart account deployment
+     * @param publicClient - The public client to use for simulation
+     * @param walletClient - The wallet client to use for account information
+     * @param params - The deployment parameters
+     * @returns The simulation result
+     * @throws {ZkSyncConnectorError} If simulation fails
+     * @testable This method can be mocked in tests
+     */
+    simulateAccountDeployment(publicClient_1, walletClient_1, params_1) {
+        return _tslib.__awaiter(this, arguments, void 0, function* (publicClient, walletClient, params, checkBalance = true) {
+            var _a, _b, _c;
+            // this is to keep the same salt as calculated on zksync sso package
+            const salt = viem.keccak256(viem.toHex(params.salt));
+            const gasEstimate = yield publicClient.estimateContractGas({
+                abi: abi.AAFactoryABI,
+                account: (_a = walletClient.account) === null || _a === void 0 ? void 0 : _a.address,
+                address: this.factoryAddress,
+                args: [salt, params.initialValidators, params.initialK1Owners],
+                functionName: 'deployProxySsoAccount',
+            });
+            if (checkBalance) {
+                const balance = yield publicClient.getBalance({
+                    address: (_b = walletClient.account) === null || _b === void 0 ? void 0 : _b.address,
+                });
+                if (balance < gasEstimate) {
+                    throw new Error('Insufficient balance to deploy account');
+                }
+            }
+            // Simulate the contract call
+            return publicClient.simulateContract({
+                abi: abi.AAFactoryABI,
+                account: (_c = walletClient.account) === null || _c === void 0 ? void 0 : _c.address,
+                address: this.factoryAddress,
+                args: [salt, params.initialValidators, params.initialK1Owners],
+                functionName: 'deployProxySsoAccount',
+            });
+        });
+    }
+    /**
+     * Executes the smart account deployment transaction
+     * @param walletClient - The wallet client to use for transaction execution
+     * @param request - The deployment request object containing transaction parameters
+     * @returns Promise that resolves when the deployment transaction is confirmed
+     * @throws {DynamicError} If the smart account address is not initialized
+     * @throws {Error} If transaction execution or confirmation fails
+     */
+    executeAccountDeployment(walletClient, request) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const tx = yield walletClient.writeContract(request);
+            const publicClient = yield this.getPublicClient();
+            yield publicClient.waitForTransactionReceipt({ hash: tx });
+            this._isSmartAccountDeployed = true;
+        });
+    }
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const walletClient = this.getWalletClient();
+            if (!walletClient) {
+                throw new Error('Wallet client not found');
+            }
+            return yield 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* () {
+            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;
+        });
+    }
+    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');
+            }
+            return;
+        });
+    }
+    createUiTransaction(from) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const walletClient = this.getWalletClient();
+            const publicClient = yield this.getPublicClient();
+            if (!publicClient || !walletClient) {
+                throw new utils.DynamicError('No public client available');
+            }
+            return ethereumCore.createViemUiTransaction({
+                from: from,
+                publicClient: publicClient,
+                walletClient: walletClient,
+            });
+        });
+    }
+    isSmartAccountDeployed() {
+        return _tslib.__awaiter(this, arguments, void 0, function* (refetch = false) {
+            if (refetch) {
+                yield this.checkIsDeployed();
+            }
+            return this._isSmartAccountDeployed;
+        });
+    }
+    registerEoa(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ smartWalletAddress, eoaAddress, eoaConnector, shouldSetEoaConnector, }) {
+            throw new Error('Not implemented');
+        });
+    }
+}
+
+exports.ZKsyncConnector = ZKsyncConnector;