@imtbl/sdk 0.3.0 → 0.3.1-alpha

package/dist/passport.d.ts

@@ -10352,14 +10352,14 @@ declare class ImmutableXClient {
      * @returns a promise that resolves with the requested Order
      * @throws {@link index.IMXError}
      */
-    getOrder(request: OrdersApiGetOrderRequest): Promise<Order>;
+    getOrder(request: OrdersApiGetOrderRequest): Promise<OrderV3>;
     /**
      * Get a list of Orders
      * @param request - optional object containing the parameters to be provided in the API request
      * @returns a promise that resolves with the requested list of Orders
      * @throws {@link index.IMXError}
      */
-    listOrders(request?: OrdersApiListOrdersRequest): Promise<ListOrdersResponse>;
+    listOrders(request?: OrdersApiListOrdersRequest): Promise<ListOrdersResponseV3>;
     /**
      * Get details of a Trade with the given ID
      * @param request - the request object containing the parameters to be provided in the API request
@@ -10509,19 +10509,27 @@ type DeviceTokenResponse = {
     expires_in: number;
 };
 
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ */
+declare enum ProviderErrorCode {
+    USER_REJECTED_REQUEST = 4001,
+    UNAUTHORIZED = 4100,
+    UNSUPPORTED_METHOD = 4200,
+    DISCONNECTED = 4900
+}
 declare enum RpcErrorCode {
     RPC_SERVER_ERROR = -32000,
     INVALID_REQUEST = -32600,
     METHOD_NOT_FOUND = -32601,
     INVALID_PARAMS = -32602,
     INTERNAL_ERROR = -32603,
-    UNAUTHORIZED = -32604,
     PARSE_ERROR = -32700
 }
 declare class JsonRpcError extends Error {
     readonly message: string;
-    readonly code: RpcErrorCode;
-    constructor(code: RpcErrorCode, message: string);
+    readonly code: ProviderErrorCode | RpcErrorCode;
+    constructor(code: ProviderErrorCode | RpcErrorCode, message: string);
 }
 
 interface RequestArguments {
@@ -10545,7 +10553,13 @@ type Provider = {
     request: (request: RequestArguments) => Promise<any>;
     sendAsync: (request: JsonRpcRequestPayload | JsonRpcRequestPayload[], callback: JsonRpcRequestCallback) => void;
     send: (request: string | JsonRpcRequestPayload | JsonRpcRequestPayload[], callbackOrParams?: JsonRpcRequestCallback | Array<any>, callback?: JsonRpcRequestCallback) => void;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+    removeListener: (event: string, listener: (...args: any[]) => void) => void;
 };
+declare enum ProviderEvent {
+    ACCOUNTS_CHANGED = "accountsChanged"
+}
+type AccountsChangedEvent = Array<string>;
 
 declare class Passport {
     private readonly authManager;
@@ -10580,4 +10594,4 @@ declare class Passport {
     getAccessToken(): Promise<string | undefined>;
 }
 
-export { DeviceConnectResponse, DeviceTokenResponse, JsonRpcRequestCallback, JsonRpcRequestPayload, JsonRpcResponsePayload, Networks, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, Provider, RequestArguments, UserProfile };
+export { AccountsChangedEvent, DeviceConnectResponse, DeviceTokenResponse, JsonRpcError, JsonRpcRequestCallback, JsonRpcRequestPayload, JsonRpcResponsePayload, Networks, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, Provider, ProviderErrorCode, ProviderEvent, RequestArguments, RpcErrorCode, UserProfile };

package/dist/passport.js

@@ -7,6 +7,7 @@ import { OpenIdExtension } from '@magic-ext/oidc';
 import BN from 'bn.js';
 import * as encUtils from 'enc-utils';
 import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers';
+import { EventEmitter } from 'events';
 import { ethers, BigNumber } from 'ethers';
 import { walletContracts } from '@0xsequence/abi';
 import { encodeSignature } from '@0xsequence/config';
@@ -4606,7 +4607,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.0.0' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.3.1-alpha' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -4662,7 +4663,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.0.0',
+    sdkVersion: 'ts-immutable-sdk-0.3.1-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -8386,6 +8387,8 @@ var globalAxios = axios;
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+// Some imports not used depending on template conditions
+// @ts-ignore
 const BASE_PATH = "https://guardian.sandbox.imtbl.com".replace(/\/+$/, "");
 /**
  *
@@ -8413,10 +8416,10 @@ class BaseAPI {
  */
 class RequiredError extends Error {
     field;
+    name = "RequiredError";
     constructor(field, msg) {
         super(msg);
         this.field = field;
-        this.name = "RequiredError";
     }
 }
 
@@ -8461,8 +8464,6 @@ const setBearerAuthToObject = async function (object, configuration) {
     }
 };
 function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
-    if (parameter == null)
-        return;
     if (typeof parameter === "object") {
         if (Array.isArray(parameter)) {
             parameter.forEach(item => setFlattenedQueryParams(urlSearchParams, item, key));
@@ -8618,7 +8619,7 @@ const TransactionsApiAxiosParamCreator = function (configuration) {
          * @summary Info for a specific transaction
          * @param {string} transactionID The id of the starkex transaction to retrieve
          * @param {'starkex' | 'evm'} chainType roll up type
-         * @param {number} [chainID] ID of evm chain
+         * @param {string} [chainID] ID of evm chain
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -8693,7 +8694,7 @@ const TransactionsApiFp = function (configuration) {
          * @summary Info for a specific transaction
          * @param {string} transactionID The id of the starkex transaction to retrieve
          * @param {'starkex' | 'evm'} chainType roll up type
-         * @param {number} [chainID] ID of evm chain
+         * @param {string} [chainID] ID of evm chain
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -9371,6 +9372,7 @@ async function createOrder({ starkSigner, user, request, ordersApi, guardianClie
             amount_sell: amountSell,
             token_sell: convertToSignableToken(request.sell),
             fees: request.fees,
+            split_fees: true,
             expiration_timestamp: request.expiration_timestamp,
         };
         const getSignableOrderResponse = await ordersApi.getSignableOrder({
@@ -9884,7 +9886,7 @@ class PassportConfiguration {
                     this.imxPublicApiDomain = 'https://api.immutable.com';
                     this.zkEvmRpcUrl = ''; // TODO: ID-785 Update once mainnet has been deployed
                     this.zkEvmChainId = ''; // TODO: ID-785 Update once mainnet has been deployed
-                    this.relayerUrl = 'https://relayer.immutable.com'; // TODO: ID-784 Update once we have added Relayer URL to config
+                    this.relayerUrl = 'https://api.immutable.com/relayer-mr';
                     this.multiRollupConfig = multiRollupConfig.getProduction();
                     break;
                 }
@@ -9898,7 +9900,7 @@ class PassportConfiguration {
                     this.imxPublicApiDomain = 'https://api.sandbox.immutable.com';
                     this.zkEvmRpcUrl = 'https://zkevm-rpc.sandbox.x.immutable.com';
                     this.zkEvmChainId = 'eip155:13392';
-                    this.relayerUrl = 'https://evm-relayer.sandbox.imtbl.com'; // TODO: ID-784 Update once we have added Relayer URL to config
+                    this.relayerUrl = 'https://api.sandbox.immutable.com/relayer-mr';
                     this.multiRollupConfig = multiRollupConfig.getSandbox();
                     break;
                 }
@@ -10060,6 +10062,169 @@ class ConfirmationScreen {
     }
 }
 
+var RelayerTransactionStatus;
+(function (RelayerTransactionStatus) {
+    RelayerTransactionStatus["PENDING"] = "PENDING";
+    RelayerTransactionStatus["SUBMITTED"] = "SUBMITTED";
+    RelayerTransactionStatus["SUCCESSFUL"] = "SUCCESSFUL";
+    RelayerTransactionStatus["REVERTED"] = "REVERTED";
+    RelayerTransactionStatus["FAILED"] = "FAILED";
+})(RelayerTransactionStatus || (RelayerTransactionStatus = {}));
+var ProviderEvent;
+(function (ProviderEvent) {
+    ProviderEvent["ACCOUNTS_CHANGED"] = "accountsChanged";
+})(ProviderEvent || (ProviderEvent = {}));
+
+class TypedEventEmitter {
+    emitter = new EventEmitter();
+    emit(eventName, ...eventArg) {
+        this.emitter.emit(eventName, ...eventArg);
+    }
+    on(eventName, handler) {
+        this.emitter.on(eventName, handler);
+    }
+    removeListener(eventName, handler) {
+        this.emitter.removeListener(eventName, handler);
+    }
+}
+
+class RelayerClient {
+    config;
+    constructor({ config }) {
+        this.config = config;
+    }
+    async postToRelayer(request) {
+        const body = {
+            id: 1,
+            jsonrpc: '2.0',
+            ...request,
+        };
+        const response = await fetch(`${this.config.relayerUrl}/v1/transactions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        const jsonResponse = await response.json();
+        if (jsonResponse.error) {
+            throw jsonResponse.error;
+        }
+        return jsonResponse;
+    }
+    async ethSendTransaction(to, data) {
+        const payload = {
+            method: 'eth_sendTransaction',
+            params: [{
+                    to,
+                    data,
+                    chainId: this.config.zkEvmChainId.toString(),
+                }],
+        };
+        const { result } = await this.postToRelayer(payload);
+        return result;
+    }
+    async imGetTransactionByHash(hash) {
+        const payload = {
+            method: 'im_getTransactionByHash',
+            params: [hash],
+        };
+        const { result } = await this.postToRelayer(payload);
+        return result;
+    }
+    async imGetFeeOptions(userAddress, data) {
+        const payload = {
+            method: 'im_getFeeOptions',
+            params: [{
+                    userAddress,
+                    data,
+                    chainId: this.config.zkEvmChainId.toString(),
+                }],
+        };
+        const { result } = await this.postToRelayer(payload);
+        return result;
+    }
+}
+
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ */
+var ProviderErrorCode;
+(function (ProviderErrorCode) {
+    ProviderErrorCode[ProviderErrorCode["USER_REJECTED_REQUEST"] = 4001] = "USER_REJECTED_REQUEST";
+    ProviderErrorCode[ProviderErrorCode["UNAUTHORIZED"] = 4100] = "UNAUTHORIZED";
+    ProviderErrorCode[ProviderErrorCode["UNSUPPORTED_METHOD"] = 4200] = "UNSUPPORTED_METHOD";
+    ProviderErrorCode[ProviderErrorCode["DISCONNECTED"] = 4900] = "DISCONNECTED";
+})(ProviderErrorCode || (ProviderErrorCode = {}));
+var RpcErrorCode;
+(function (RpcErrorCode) {
+    RpcErrorCode[RpcErrorCode["RPC_SERVER_ERROR"] = -32000] = "RPC_SERVER_ERROR";
+    RpcErrorCode[RpcErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    RpcErrorCode[RpcErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    RpcErrorCode[RpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    RpcErrorCode[RpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+    RpcErrorCode[RpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+})(RpcErrorCode || (RpcErrorCode = {}));
+class JsonRpcError extends Error {
+    message;
+    code;
+    constructor(code, message) {
+        super(message);
+        this.message = message;
+        this.code = code;
+    }
+}
+
+const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
+async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiClients, accessToken, }) {
+    const web3Provider = new Web3Provider(magicProvider);
+    const ethSigner = web3Provider.getSigner();
+    const ethereumAddress = await ethSigner.getAddress();
+    const ethereumSignature = await signRaw(MESSAGE_TO_SIGN, ethSigner);
+    const headers = { Authorization: `Bearer ${accessToken}` };
+    try {
+        await multiRollupApiClients.passportApi.createCounterfactualAddress({
+            createCounterfactualAddressRequest: {
+                ethereumAddress,
+                ethereumSignature,
+            },
+        }, { headers });
+    }
+    catch (error) {
+        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
+    }
+    const user = await authManager.loginSilent();
+    if (!user?.zkEvm) {
+        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Failed to refresh user details');
+    }
+    return user;
+}
+
+const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupApiClients, }) => {
+    const user = await authManager.getUser() || await authManager.login();
+    if (!user.idToken) {
+        throw new Error('User is missing idToken');
+    }
+    const magicProvider = await magicAdapter.login(user.idToken, config.network);
+    if (!user.zkEvm) {
+        // Generate counterfactual address and retrieve updated Auth0 user
+        const userZkevm = await registerZkEvmUser({
+            authManager,
+            magicProvider,
+            multiRollupApiClients,
+            accessToken: user.accessToken,
+        });
+        return {
+            user: userZkevm,
+            magicProvider,
+        };
+    }
+    return {
+        user: user,
+        magicProvider,
+    };
+};
+
 // These are ignored by the Relayer but for consistency we set them to the
 // appropriate values for a 1/1 wallet.
 //
@@ -10092,7 +10257,7 @@ function digestOfTransactionsAndNonce(nonce, normalisedTransactions) {
     return ethers.utils.keccak256(packMetaTransactionsNonceData);
 }
 const getNonce = async (jsonRpcProvider, smartContractWalletAddress) => {
-    const code = await jsonRpcProvider.send('eth_getCode', [smartContractWalletAddress]);
+    const code = await jsonRpcProvider.send('eth_getCode', [smartContractWalletAddress, 'latest']);
     if (code && code !== '0x') {
         const contract = new ethers.Contract(smartContractWalletAddress, walletContracts.mainModule.abi, jsonRpcProvider);
         return contract.nonce();
@@ -10135,38 +10300,48 @@ const chainIdNumber = (chainId) => {
     return BigNumber.from(caip2Components[1]);
 };
 
-var RelayerTransactionStatus;
-(function (RelayerTransactionStatus) {
-    RelayerTransactionStatus["PENDING"] = "PENDING";
-    RelayerTransactionStatus["SUBMITTED"] = "SUBMITTED";
-    RelayerTransactionStatus["SUCCESSFUL"] = "SUCCESSFUL";
-    RelayerTransactionStatus["REVERTED"] = "REVERTED";
-    RelayerTransactionStatus["FAILED"] = "FAILED";
-})(RelayerTransactionStatus || (RelayerTransactionStatus = {}));
-
-var RpcErrorCode;
-(function (RpcErrorCode) {
-    RpcErrorCode[RpcErrorCode["RPC_SERVER_ERROR"] = -32000] = "RPC_SERVER_ERROR";
-    RpcErrorCode[RpcErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
-    RpcErrorCode[RpcErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
-    RpcErrorCode[RpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
-    RpcErrorCode[RpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-    RpcErrorCode[RpcErrorCode["UNAUTHORIZED"] = -32604] = "UNAUTHORIZED";
-    RpcErrorCode[RpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-})(RpcErrorCode || (RpcErrorCode = {}));
-class JsonRpcError extends Error {
-    message;
-    code;
-    constructor(code, message) {
-        super(message);
-        this.message = message;
-        this.code = code;
-    }
-}
-
 const MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES = 30;
 const TRANSACTION_HASH_RETRIEVAL_WAIT = 1000;
-const ethSendTransaction = async ({ params, magicProvider, jsonRpcProvider, relayerClient, config, user, }) => {
+const converBigNumberishToNumber = (value) => BigNumber.from(value).toNumber();
+const transformGardianTransactions = (txs) => {
+    try {
+        return txs.map((t) => ({
+            delegateCall: t.delegateCall === true,
+            revertOnError: t.revertOnError === true,
+            gasLimit: t.gasLimit ? converBigNumberishToNumber(t.gasLimit).toString() : '0',
+            target: t.to ?? ethers.constants.AddressZero,
+            value: t.value ? converBigNumberishToNumber(t.value).toString() : '0',
+            data: t.data ? t.data.toString() : '0x00',
+        }));
+    }
+    catch (error) {
+        const errorMessage = (error instanceof Error) ? error.message : String(error);
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Transaction failed to parsing: ${errorMessage}`);
+    }
+};
+const guardianValidation = async ({ transactionAPI, chainId, nonce, user, metaTransactions, }) => {
+    const headers = { Authorization: `Bearer ${user.accessToken}` };
+    const guardianTransactions = transformGardianTransactions(metaTransactions);
+    try {
+        await transactionAPI.evaluateTransaction({
+            id: 'evm',
+            transactionEvaluationRequest: {
+                chainType: 'evm',
+                chainId,
+                transactionData: {
+                    nonce,
+                    userAddress: user.zkEvm.ethAddress,
+                    metaTransactions: guardianTransactions,
+                },
+            },
+        }, { headers });
+    }
+    catch (error) {
+        const errorMessage = (error instanceof Error) ? error.message : String(error);
+        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Transaction failed to validate with error: ${errorMessage}`);
+    }
+};
+const sendTransaction = async ({ params, magicProvider, jsonRpcProvider, relayerClient, transactionAPI, config, user, }) => {
     const transactionRequest = params[0];
     if (!transactionRequest.to) {
         throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
@@ -10204,6 +10379,13 @@ const ethSendTransaction = async ({ params, magicProvider, jsonRpcProvider, rela
         value: imxFeeOption.tokenPrice,
         revertOnError: true,
     };
+    await guardianValidation({
+        transactionAPI,
+        chainId: config.zkEvmChainId,
+        nonce: converBigNumberishToNumber(nonce),
+        user,
+        metaTransactions: [metaTransaction, feeMetaTransaction],
+    });
     // NOTE: We sign again because we now are adding the fee transaction, so the
     // whole payload is different and needs a new signature.
     const signedTransactions = await getSignedMetaTransactions([metaTransaction, feeMetaTransaction], nonce, chainId, user.zkEvm.ethAddress, signer);
@@ -10231,122 +10413,16 @@ const ethSendTransaction = async ({ params, magicProvider, jsonRpcProvider, rela
     return relayerTransaction.hash;
 };
 
-class RelayerClient {
-    config;
-    constructor({ config }) {
-        this.config = config;
-    }
-    async postToRelayer(request) {
-        const body = {
-            id: 1,
-            jsonrpc: '2.0',
-            ...request,
-        };
-        const response = await fetch(`${this.config.relayerUrl}/v1/transactions`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(body),
-        });
-        const jsonResponse = await response.json();
-        if (jsonResponse.error) {
-            throw jsonResponse.error;
-        }
-        return jsonResponse;
-    }
-    async ethSendTransaction(to, data) {
-        const payload = {
-            method: 'eth_sendTransaction',
-            params: [{
-                    to,
-                    data,
-                    chainId: this.config.zkEvmChainId.toString(),
-                }],
-        };
-        const { result } = await this.postToRelayer(payload);
-        return result;
-    }
-    async imGetTransactionByHash(hash) {
-        const payload = {
-            method: 'im_getTransactionByHash',
-            params: [hash],
-        };
-        const { result } = await this.postToRelayer(payload);
-        return result;
-    }
-    async imGetFeeOptions(userAddress, data) {
-        const payload = {
-            method: 'im_getFeeOptions',
-            params: [{
-                    userAddress,
-                    data,
-                    chainId: this.config.zkEvmChainId.toString(),
-                }],
-        };
-        const { result } = await this.postToRelayer(payload);
-        return result;
-    }
-}
-
-const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
-async function createCounterfactualAddress({ authManager, magicProvider, multiRollupApiClients, accessToken, }) {
-    const web3Provider = new Web3Provider(magicProvider);
-    const ethSigner = web3Provider.getSigner();
-    const ethereumAddress = await ethSigner.getAddress();
-    const ethereumSignature = await signRaw(MESSAGE_TO_SIGN, ethSigner);
-    const headers = { Authorization: `Bearer ${accessToken}` };
-    try {
-        await multiRollupApiClients.passportApi.createCounterfactualAddress({
-            createCounterfactualAddressRequest: {
-                ethereumAddress,
-                ethereumSignature,
-            },
-        }, { headers });
-    }
-    catch (error) {
-        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
-    }
-    const user = await authManager.loginSilent();
-    if (!user?.zkEvm) {
-        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Failed to refresh user details');
-    }
-    return user;
-}
-
-const registerZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupApiClients, }) => {
-    const user = await authManager.getUser() || await authManager.login();
-    if (!user.idToken) {
-        throw new Error('User is missing idToken');
-    }
-    const magicProvider = await magicAdapter.login(user.idToken, config.network);
-    if (!user.zkEvm) {
-        // Generate counterfactual address and retrieve updated Auth0 user
-        const userZkevm = await createCounterfactualAddress({
-            authManager,
-            magicProvider,
-            multiRollupApiClients,
-            accessToken: user.accessToken,
-        });
-        return {
-            user: userZkevm,
-            magicProvider,
-        };
-    }
-    return {
-        user: user,
-        magicProvider,
-    };
-};
-
 class ZkEvmProvider {
     authManager;
     config;
     confirmationScreen;
     magicAdapter;
     relayerClient;
+    transactionAPI;
     multiRollupApiClients;
-    jsonRpcProvider; // Used for read operations
+    jsonRpcProvider; // Used for read
+    eventEmitter;
     magicProvider; // Used for signing
     user;
     constructor({ authManager, magicAdapter, config, confirmationScreen, multiRollupApiClients, }) {
@@ -10355,32 +10431,23 @@ class ZkEvmProvider {
         this.config = config;
         this.confirmationScreen = confirmationScreen;
         this.relayerClient = new RelayerClient({ config });
+        this.transactionAPI = new TransactionsApi(new Configuration({
+            basePath: this.config.imxPublicApiDomain,
+        }));
         this.jsonRpcProvider = new JsonRpcProvider(this.config.zkEvmRpcUrl);
         this.multiRollupApiClients = multiRollupApiClients;
+        this.eventEmitter = new TypedEventEmitter();
     }
     isLoggedIn() {
         return this.magicProvider !== undefined && this.user !== undefined;
     }
     async performRequest(request) {
-        const authWrapper = (fn) => {
-            if (!this.isLoggedIn()) {
-                throw new JsonRpcError(RpcErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
-            }
-            return fn({
-                params: request.params || [],
-                magicProvider: this.magicProvider,
-                jsonRpcProvider: this.jsonRpcProvider,
-                config: this.config,
-                relayerClient: this.relayerClient,
-                user: this.user,
-            });
-        };
         switch (request.method) {
             case 'eth_requestAccounts': {
                 if (this.isLoggedIn()) {
                     return [this.user.zkEvm.ethAddress];
                 }
-                const { magicProvider, user } = await registerZkEvmUser({
+                const { magicProvider, user } = await loginZkEvmUser({
                     authManager: this.authManager,
                     config: this.config,
                     magicAdapter: this.magicAdapter,
@@ -10388,10 +10455,22 @@ class ZkEvmProvider {
                 });
                 this.user = user;
                 this.magicProvider = magicProvider;
+                this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [this.user.zkEvm.ethAddress]);
                 return [this.user.zkEvm.ethAddress];
             }
             case 'eth_sendTransaction': {
-                return authWrapper(ethSendTransaction);
+                if (!this.isLoggedIn()) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
+                }
+                return sendTransaction({
+                    params: request.params || [],
+                    magicProvider: this.magicProvider,
+                    transactionAPI: this.transactionAPI,
+                    jsonRpcProvider: this.jsonRpcProvider,
+                    config: this.config,
+                    relayerClient: this.relayerClient,
+                    user: this.user,
+                });
             }
             case 'eth_accounts': {
                 return this.isLoggedIn() ? [this.user.zkEvm.ethAddress] : [];
@@ -10412,7 +10491,7 @@ class ZkEvmProvider {
                 return this.jsonRpcProvider.send(request.method, request.params || []);
             }
             default: {
-                throw new JsonRpcError(RpcErrorCode.METHOD_NOT_FOUND, 'Method not supported');
+                throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
             }
         }
     }
@@ -10506,6 +10585,12 @@ class ZkEvmProvider {
         }
         throw new JsonRpcError(RpcErrorCode.INVALID_REQUEST, 'Invalid request');
     }
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    removeListener(event, listener) {
+        this.eventEmitter.removeListener(event, listener);
+    }
 }
 
 class Passport {
@@ -10599,4 +10684,4 @@ class Passport {
     }
 }
 
-export { Networks, Passport, PassportError };
+export { JsonRpcError, Networks, Passport, PassportError, ProviderErrorCode, ProviderEvent, RpcErrorCode };