@imtbl/sdk 0.11.0-alpha → 0.12.0-alpha

package/dist/passport.js

@@ -1457,7 +1457,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.11.0-alpha' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.12.0-alpha' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -1513,7 +1513,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.11.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.12.0-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -6163,22 +6163,28 @@ class AuthManager {
 
 class MagicAdapter {
     config;
+    magicClient;
     constructor(config) {
         this.config = config;
     }
     async login(idToken, network) {
         return withPassportError(async () => {
-            const magicClient = new Magic(this.config.magicPublishableApiKey, {
+            this.magicClient = new Magic(this.config.magicPublishableApiKey, {
                 extensions: [new OpenIdExtension()],
                 network,
             });
-            await magicClient.openid.loginWithOIDC({
+            await this.magicClient.openid.loginWithOIDC({
                 jwt: idToken,
                 providerId: this.config.magicProviderId,
             });
-            return magicClient.rpcProvider;
+            return this.magicClient.rpcProvider;
         }, PassportErrorType.WALLET_CONNECTION_ERROR);
     }
+    async logout() {
+        if (this.magicClient?.user) {
+            await this.magicClient.user.logout();
+        }
+    }
 }
 
 const getStarkSigner = async (signer) => withPassportError(async () => {
@@ -6212,6 +6218,8 @@ const retryWithDelay = async (fn, options) => {
 
 /**
  * ProviderErrors should take priority over RpcErrorCodes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
  */
 var ProviderErrorCode;
 (function (ProviderErrorCode) {
@@ -6228,7 +6236,7 @@ var RpcErrorCode;
     RpcErrorCode[RpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
     RpcErrorCode[RpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
     RpcErrorCode[RpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-    RpcErrorCode[RpcErrorCode["USER_REJECTED_REQUEST"] = -32003] = "USER_REJECTED_REQUEST";
+    RpcErrorCode[RpcErrorCode["TRANSACTION_REJECTED"] = -32003] = "TRANSACTION_REJECTED";
 })(RpcErrorCode || (RpcErrorCode = {}));
 class JsonRpcError extends Error {
     message;
@@ -6240,6 +6248,8 @@ class JsonRpcError extends Error {
     }
 }
 
+const transactionRejectedCrossSdkBridgeError = 'Transaction requires confirmation but this functionality is not'
+    + ' supported in this environment. Please contact Immutable support if you need to enable this feature.';
 const convertBigNumberishToString = (value) => BigNumber.from(value).toString();
 const transformGuardianTransactions = (txs) => {
     try {
@@ -6262,13 +6272,15 @@ class GuardianClient {
     confirmationScreen;
     // TODO: ID-977, make this rollup agnostic
     imxEtherAddress;
-    constructor({ imxPublicApiDomain, accessToken, confirmationScreen, imxEtherAddress, }) {
+    crossSdkBridgeEnabled;
+    constructor({ accessToken, confirmationScreen, imxEtherAddress, config, }) {
         this.confirmationScreen = confirmationScreen;
         this.transactionAPI = new TransactionsApi(new Configuration({
             accessToken,
-            basePath: imxPublicApiDomain,
+            basePath: config.imxPublicApiDomain,
         }));
         this.imxEtherAddress = imxEtherAddress;
+        this.crossSdkBridgeEnabled = config.crossSdkBridgeEnabled;
     }
     /**
      * Open confirmation screen and close it automatically if the
@@ -6281,8 +6293,7 @@ class GuardianClient {
         return (task) => async () => {
             this.confirmationScreen.loading(popupWindowSize);
             try {
-                const result = await task();
-                return result;
+                return await task();
             }
             catch (err) {
                 this.confirmationScreen.closeWindow();
@@ -6312,7 +6323,10 @@ class GuardianClient {
         });
         const { confirmationRequired } = evaluateStarkexRes.data;
         if (confirmationRequired) {
-            const confirmationResult = await this.confirmationScreen.startGuardianTransaction(payloadHash, this.imxEtherAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
+            if (this.crossSdkBridgeEnabled) {
+                throw new Error(transactionRejectedCrossSdkBridgeError);
+            }
+            const confirmationResult = await this.confirmationScreen.requestConfirmation(payloadHash, this.imxEtherAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
             if (!confirmationResult.confirmed) {
                 throw new Error('Transaction rejected by user');
             }
@@ -6352,10 +6366,13 @@ class GuardianClient {
             metaTransactions,
         });
         const { confirmationRequired, transactionId } = transactionEvaluationResponse;
+        if (confirmationRequired && this.crossSdkBridgeEnabled) {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
+        }
         if (confirmationRequired && !!transactionId) {
-            const confirmationResult = await this.confirmationScreen.startGuardianTransaction(transactionId, this.imxEtherAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
+            const confirmationResult = await this.confirmationScreen.requestConfirmation(transactionId, this.imxEtherAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
             if (!confirmationResult.confirmed) {
-                throw new JsonRpcError(RpcErrorCode.USER_REJECTED_REQUEST, 'Transaction rejected by user ');
+                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Transaction rejected by user');
             }
         }
         else {
@@ -6364,6 +6381,16 @@ class GuardianClient {
     }
 }
 
+var PassportEvents;
+(function (PassportEvents) {
+    PassportEvents["LOGGED_OUT"] = "loggedOut";
+})(PassportEvents || (PassportEvents = {}));
+var Networks;
+(function (Networks) {
+    Networks["PRODUCTION"] = "mainnet";
+    Networks["SANDBOX"] = "goerli";
+})(Networks || (Networks = {}));
+
 async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
     return withPassportError(async () => {
         const { ethAddress } = user.imx;
@@ -6668,19 +6695,30 @@ class PassportImxProvider {
     immutableXClient;
     confirmationScreen;
     guardianClient;
-    constructor({ user, starkSigner, immutableXClient, imxPublicApiDomain, confirmationScreen, }) {
+    constructor({ user, starkSigner, immutableXClient, confirmationScreen, config, passportEventEmitter, }) {
         this.user = user;
         this.starkSigner = starkSigner;
         this.immutableXClient = immutableXClient;
         this.confirmationScreen = confirmationScreen;
         this.guardianClient = new GuardianClient({
-            imxPublicApiDomain,
             accessToken: user.accessToken,
             confirmationScreen,
             imxEtherAddress: user.imx.ethAddress,
+            config,
         });
+        passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.handleLogout);
+    }
+    handleLogout = () => {
+        this.user = undefined;
+        this.starkSigner = undefined;
+    };
+    checkIsLoggedIn() {
+        if (this.user === undefined || this.starkSigner === undefined) {
+            throw new PassportError('User has been logged out', PassportErrorType.NOT_LOGGED_IN_ERROR);
+        }
     }
     async transfer(request) {
+        this.checkIsLoggedIn();
         return transfer({
             request,
             user: this.user,
@@ -6700,6 +6738,7 @@ class PassportImxProvider {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     createOrder(request) {
+        this.checkIsLoggedIn();
         return createOrder({
             request,
             user: this.user,
@@ -6709,6 +6748,7 @@ class PassportImxProvider {
         });
     }
     cancelOrder(request) {
+        this.checkIsLoggedIn();
         return cancelOrder({
             request,
             user: this.user,
@@ -6718,6 +6758,7 @@ class PassportImxProvider {
         });
     }
     createTrade(request) {
+        this.checkIsLoggedIn();
         return createTrade({
             request,
             user: this.user,
@@ -6727,6 +6768,7 @@ class PassportImxProvider {
         });
     }
     batchNftTransfer(request) {
+        this.checkIsLoggedIn();
         return batchNftTransfer({
             request,
             user: this.user,
@@ -6736,6 +6778,7 @@ class PassportImxProvider {
         });
     }
     exchangeTransfer(request) {
+        this.checkIsLoggedIn();
         return exchangeTransfer({
             request,
             user: this.user,
@@ -6763,6 +6806,7 @@ class PassportImxProvider {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     getAddress() {
+        this.checkIsLoggedIn();
         return Promise.resolve(this.user.imx.ethAddress);
     }
 }
@@ -6773,12 +6817,14 @@ class PassportImxProviderFactory {
     confirmationScreen;
     immutableXClient;
     magicAdapter;
-    constructor({ authManager, config, confirmationScreen, immutableXClient, magicAdapter, }) {
+    passportEventEmitter;
+    constructor({ authManager, config, confirmationScreen, immutableXClient, magicAdapter, passportEventEmitter, }) {
         this.authManager = authManager;
         this.config = config;
         this.confirmationScreen = confirmationScreen;
         this.immutableXClient = immutableXClient;
         this.magicAdapter = magicAdapter;
+        this.passportEventEmitter = passportEventEmitter;
     }
     async getProvider() {
         const user = await this.authManager.login();
@@ -6820,16 +6866,18 @@ class PassportImxProviderFactory {
                 user: userImx,
                 starkSigner,
                 immutableXClient: this.immutableXClient,
-                imxPublicApiDomain: this.config.imxPublicApiDomain,
                 confirmationScreen: this.confirmationScreen,
+                config: this.config,
+                passportEventEmitter: this.passportEventEmitter,
             });
         }
         return new PassportImxProvider({
             user: user,
             starkSigner,
             immutableXClient: this.immutableXClient,
-            imxPublicApiDomain: this.config.imxPublicApiDomain,
             confirmationScreen: this.confirmationScreen,
+            config: this.config,
+            passportEventEmitter: this.passportEventEmitter,
         });
     }
     async registerStarkEx(userAdminKeySigner, starkSigner, jwt) {
@@ -6853,12 +6901,6 @@ class PassportImxProviderFactory {
     }
 }
 
-var Networks;
-(function (Networks) {
-    Networks["PRODUCTION"] = "mainnet";
-    Networks["SANDBOX"] = "goerli";
-})(Networks || (Networks = {}));
-
 const validateConfiguration = (configuration, requiredKeys, prefix) => {
     const missingKeys = requiredKeys
         .map((key) => !configuration[key] && key)
@@ -6880,11 +6922,11 @@ class PassportConfiguration {
     magicProviderId;
     oidcConfiguration;
     baseConfig;
-    zkEvmChainId;
     zkEvmRpcUrl;
     relayerUrl;
     multiRollupConfig;
-    constructor({ baseConfig, overrides, ...oidcConfiguration }) {
+    crossSdkBridgeEnabled;
+    constructor({ baseConfig, overrides, crossSdkBridgeEnabled, ...oidcConfiguration }) {
         validateConfiguration(oidcConfiguration, [
             'clientId',
             'logoutRedirectUri',
@@ -6892,6 +6934,7 @@ class PassportConfiguration {
         ]);
         this.oidcConfiguration = oidcConfiguration;
         this.baseConfig = baseConfig;
+        this.crossSdkBridgeEnabled = crossSdkBridgeEnabled || false;
         if (overrides) {
             validateConfiguration(overrides, [
                 'network',
@@ -6900,7 +6943,6 @@ class PassportConfiguration {
                 'magicPublishableApiKey',
                 'magicProviderId',
                 'zkEvmRpcUrl',
-                'zkEvmChainId',
                 'relayerUrl',
                 'imxPublicApiDomain',
                 'indexerMrBasePath',
@@ -6914,7 +6956,6 @@ class PassportConfiguration {
             this.magicPublishableApiKey = overrides.magicPublishableApiKey;
             this.magicProviderId = overrides.magicProviderId;
             this.zkEvmRpcUrl = overrides.zkEvmRpcUrl;
-            this.zkEvmChainId = overrides.zkEvmChainId;
             this.relayerUrl = overrides.relayerUrl;
             this.multiRollupConfig = {
                 indexer: createConfig({
@@ -6938,7 +6979,6 @@ class PassportConfiguration {
                     this.passportDomain = 'https://passport.immutable.com';
                     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://api.immutable.com/relayer-mr';
                     this.multiRollupConfig = multiRollupConfig.getProduction();
                     break;
@@ -6952,7 +6992,6 @@ class PassportConfiguration {
                     this.passportDomain = 'https://passport.sandbox.immutable.com';
                     this.imxPublicApiDomain = 'https://api.sandbox.immutable.com';
                     this.zkEvmRpcUrl = 'https://rpc.testnet.immutable.com';
-                    this.zkEvmChainId = 'eip155:13472';
                     this.relayerUrl = 'https://api.sandbox.immutable.com/relayer-mr';
                     this.multiRollupConfig = multiRollupConfig.getSandbox();
                     break;
@@ -6968,18 +7007,6 @@ var ReceiveMessage;
     ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
     ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
 })(ReceiveMessage || (ReceiveMessage = {}));
-var SendMessage;
-(function (SendMessage) {
-    SendMessage["TRANSACTION_START"] = "transaction_start";
-})(SendMessage || (SendMessage = {}));
-var TransactionTypes;
-(function (TransactionTypes) {
-    TransactionTypes["cancelOrder"] = "delete:v1/orders";
-    TransactionTypes["createOrder"] = "post:v1/orders";
-    TransactionTypes["createTrade"] = "post:v1/trades";
-    TransactionTypes["createTransfer"] = "post:v1/transfers";
-    TransactionTypes["createBatchTransfer"] = "post:v2/transfers";
-})(TransactionTypes || (TransactionTypes = {}));
 const PASSPORT_EVENT_TYPE = 'imx_passport_confirmation';
 
 const openPopupCenter = ({ url, title, width, height, }) => {
@@ -7009,60 +7036,7 @@ class ConfirmationScreen {
     constructor(config) {
         this.config = config;
     }
-    postMessage(destinationWindow, accessToken, message) {
-        destinationWindow.postMessage({
-            eventType: PASSPORT_EVENT_TYPE,
-            accessToken,
-            ...message,
-        }, this.config.passportDomain);
-    }
-    startTransaction(accessToken, transaction, popupOptions) {
-        return new Promise((resolve, reject) => {
-            const messageHandler = ({ data, origin }) => {
-                if (origin !== this.config.passportDomain
-                    || data.eventType !== PASSPORT_EVENT_TYPE) {
-                    return;
-                }
-                switch (data.messageType) {
-                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
-                        // TODO: remove once fixed
-                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                        this.postMessage(confirmationWindow, accessToken, {
-                            messageType: SendMessage.TRANSACTION_START,
-                            messageData: transaction,
-                        });
-                        break;
-                    }
-                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
-                        resolve({ confirmed: true });
-                        break;
-                    }
-                    case ReceiveMessage.TRANSACTION_ERROR: {
-                        reject(new Error('Transaction error'));
-                        break;
-                    }
-                    default:
-                        reject(new Error('Unsupported message type'));
-                }
-            };
-            window.addEventListener('message', messageHandler);
-            const confirmationWindow = openPopupCenter({
-                url: `${this.config.passportDomain}/transaction-confirmation`,
-                title: CONFIRMATION_WINDOW_TITLE,
-                width: popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
-                height: popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
-            });
-            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
-            const timer = setInterval(() => {
-                if (confirmationWindow.closed) {
-                    clearInterval(timer);
-                    window.removeEventListener('message', messageHandler);
-                    resolve({ confirmed: false });
-                }
-            }, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
-        });
-    }
-    startGuardianTransaction(transactionId, imxEtherAddress, chainType, chainId) {
+    requestConfirmation(transactionId, imxEtherAddress, chainType, chainId) {
         return new Promise((resolve, reject) => {
             const messageHandler = ({ data, origin }) => {
                 if (origin !== this.config.passportDomain
@@ -7090,7 +7064,6 @@ class ConfirmationScreen {
                 resolve({ confirmed: false });
                 return;
             }
-            // eslint-disable-next-line max-len
             let href = '';
             if (chainType === TransactionApprovalRequestChainTypeEnum.Starkex) {
                 // eslint-disable-next-line max-len
@@ -7112,6 +7085,10 @@ class ConfirmationScreen {
         });
     }
     loading(popupOptions) {
+        if (this.config.crossSdkBridgeEnabled) {
+            // There is no need to open a confirmation window if cross-sdk bridge is enabled
+            return;
+        }
         this.confirmationWindow = openPopupCenter({
             url: `${this.config.passportDomain}/transaction-confirmation/loading.html`,
             title: CONFIRMATION_WINDOW_TITLE,
@@ -7150,11 +7127,82 @@ class TypedEventEmitter {
     }
 }
 
+// These are ignored by the Relayer but for consistency we set them to the
+// appropriate values for a 1/1 wallet.
+//
+// Weight of a single signature in the multisig
+const SIGNATURE_WEIGHT = 1;
+// Total required weight in the multisig
+const SIGNATURE_THRESHOLD = 1;
+const ETH_SIGN_FLAG = '02';
+const ETH_SIGN_PREFIX = '\x19\x01';
+const META_TRANSACTIONS_TYPE = `tuple(
+  bool delegateCall,
+  bool revertOnError,
+  uint256 gasLimit,
+  address target,
+  uint256 value,
+  bytes data
+)[]`;
+function getNormalisedTransactions(txs) {
+    return txs.map((t) => ({
+        delegateCall: t.delegateCall === true,
+        revertOnError: t.revertOnError === true,
+        gasLimit: t.gasLimit ?? ethers.constants.Zero,
+        target: t.to ?? ethers.constants.AddressZero,
+        value: t.value ?? ethers.constants.Zero,
+        data: t.data ?? [],
+    }));
+}
+function digestOfTransactionsAndNonce(nonce, normalisedTransactions) {
+    const packMetaTransactionsNonceData = ethers.utils.defaultAbiCoder.encode(['uint256', META_TRANSACTIONS_TYPE], [nonce, normalisedTransactions]);
+    return ethers.utils.keccak256(packMetaTransactionsNonceData);
+}
+const getNonce = async (jsonRpcProvider, 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();
+    }
+    return 0;
+};
+const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walletAddress, signer) => {
+    const normalisedMetaTransactions = getNormalisedTransactions(metaTransactions);
+    // Get the hash
+    const digest = digestOfTransactionsAndNonce(nonce, normalisedMetaTransactions);
+    const completePayload = ethers.utils.solidityPack(['string', 'uint256', 'address', 'bytes32'], [ETH_SIGN_PREFIX, chainId, walletAddress, digest]);
+    const hash = ethers.utils.keccak256(completePayload);
+    // Sign the digest
+    const hashArray = ethers.utils.arrayify(hash);
+    const ethsigNoType = await signer.signMessage(hashArray);
+    const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
+    // Add metadata
+    const encodedSignature = encodeSignature({
+        threshold: SIGNATURE_THRESHOLD,
+        signers: [
+            {
+                weight: SIGNATURE_WEIGHT,
+                signature: signedDigest,
+            },
+        ],
+    });
+    // Encode the transaction;
+    const walletInterface = new ethers.utils.Interface(walletContracts.mainModule.abi);
+    return walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [
+        normalisedMetaTransactions,
+        nonce,
+        encodedSignature,
+    ]);
+};
+const getEip155ChainId = (chainId) => `eip155:${chainId}`;
+
 class RelayerClient {
     config;
+    jsonRpcProvider;
     user;
-    constructor({ config, user }) {
+    constructor({ config, jsonRpcProvider, user }) {
         this.config = config;
+        this.jsonRpcProvider = jsonRpcProvider;
         this.user = user;
     }
     async postToRelayer(request) {
@@ -7178,12 +7226,13 @@ class RelayerClient {
         return jsonResponse;
     }
     async ethSendTransaction(to, data) {
+        const { chainId } = await this.jsonRpcProvider.ready;
         const payload = {
             method: 'eth_sendTransaction',
             params: [{
                     to,
                     data,
-                    chainId: this.config.zkEvmChainId.toString(),
+                    chainId: getEip155ChainId(chainId),
                 }],
         };
         const { result } = await this.postToRelayer(payload);
@@ -7198,12 +7247,13 @@ class RelayerClient {
         return result;
     }
     async imGetFeeOptions(userAddress, data) {
+        const { chainId } = await this.jsonRpcProvider.ready;
         const payload = {
             method: 'im_getFeeOptions',
             params: [{
                     userAddress,
                     data,
-                    chainId: this.config.zkEvmChainId.toString(),
+                    chainId: getEip155ChainId(chainId),
                 }],
         };
         const { result } = await this.postToRelayer(payload);
@@ -7261,90 +7311,16 @@ const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupAp
     };
 };
 
-// These are ignored by the Relayer but for consistency we set them to the
-// appropriate values for a 1/1 wallet.
-//
-// Weight of a single signature in the multisig
-const SIGNATURE_WEIGHT = 1;
-// Total required weight in the multisig
-const SIGNATURE_THRESHOLD = 1;
-const ETH_SIGN_FLAG = '02';
-const ETH_SIGN_PREFIX = '\x19\x01';
-const META_TRANSACTIONS_TYPE = `tuple(
-  bool delegateCall,
-  bool revertOnError,
-  uint256 gasLimit,
-  address target,
-  uint256 value,
-  bytes data
-)[]`;
-function getNormalisedTransactions(txs) {
-    return txs.map((t) => ({
-        delegateCall: t.delegateCall === true,
-        revertOnError: t.revertOnError === true,
-        gasLimit: t.gasLimit ?? ethers.constants.Zero,
-        target: t.to ?? ethers.constants.AddressZero,
-        value: t.value ?? ethers.constants.Zero,
-        data: t.data ?? [],
-    }));
-}
-function digestOfTransactionsAndNonce(nonce, normalisedTransactions) {
-    const packMetaTransactionsNonceData = ethers.utils.defaultAbiCoder.encode(['uint256', META_TRANSACTIONS_TYPE], [nonce, normalisedTransactions]);
-    return ethers.utils.keccak256(packMetaTransactionsNonceData);
-}
-const getNonce = async (jsonRpcProvider, 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();
-    }
-    return 0;
-};
-const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walletAddress, signer) => {
-    const normalisedMetaTransactions = getNormalisedTransactions(metaTransactions);
-    // Get the hash
-    const digest = digestOfTransactionsAndNonce(nonce, normalisedMetaTransactions);
-    const completePayload = ethers.utils.solidityPack(['string', 'uint256', 'address', 'bytes32'], [ETH_SIGN_PREFIX, chainId, walletAddress, digest]);
-    const hash = ethers.utils.keccak256(completePayload);
-    // Sign the digest
-    const hashArray = ethers.utils.arrayify(hash);
-    const ethsigNoType = await signer.signMessage(hashArray);
-    const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
-    // Add metadata
-    const encodedSignature = encodeSignature({
-        threshold: SIGNATURE_THRESHOLD,
-        signers: [
-            {
-                weight: SIGNATURE_WEIGHT,
-                signature: signedDigest,
-            },
-        ],
-    });
-    // Encode the transaction;
-    const walletInterface = new ethers.utils.Interface(walletContracts.mainModule.abi);
-    return walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [
-        normalisedMetaTransactions,
-        nonce,
-        encodedSignature,
-    ]);
-};
-const chainIdNumber = (chainId) => {
-    const caip2Components = chainId.split(':');
-    if (caip2Components.length !== 2) {
-        throw new Error('Invalid configuration, chain ID is not in CAIP-2 format');
-    }
-    return BigNumber.from(caip2Components[1]);
-};
-
 const MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES = 30;
 const TRANSACTION_HASH_RETRIEVAL_WAIT = 1000;
-const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient, guardianClient, config, user, }) => guardianClient
+const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient, guardianClient, user, }) => guardianClient
     .withConfirmationScreen({ width: 480, height: 520 })(async () => {
     const transactionRequest = params[0];
     if (!transactionRequest.to) {
         throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
     }
-    const chainId = chainIdNumber(config.zkEvmChainId);
+    const { chainId } = await jsonRpcProvider.ready;
+    const chainIdBigNumber = BigNumber.from(chainId);
     const magicWeb3Provider = new Web3Provider(magicProvider);
     const signer = magicWeb3Provider.getSigner();
     const nonce = await getNonce(jsonRpcProvider, user.zkEvm.ethAddress);
@@ -7359,7 +7335,7 @@ const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient
     // accurate estimation of a transaction gas cost is only possible if the smart
     // wallet contract can actually execute it (in a simulated environment) - and
     // it can only execute signed transactions.
-    const signedTransaction = await getSignedMetaTransactions([metaTransaction], nonce, chainId, user.zkEvm.ethAddress, signer);
+    const signedTransaction = await getSignedMetaTransactions([metaTransaction], nonce, chainIdBigNumber, user.zkEvm.ethAddress, signer);
     // TODO: ID-698 Add support for non-native gas payments (e.g ERC20, feeTransaction initialisation must change)
     // NOTE: "Fee Options" represent the multiple ways we could pay for the gas
     // used in this transaction. Each fee option has a "recipientAddress" we
@@ -7378,15 +7354,14 @@ const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient
         revertOnError: true,
     };
     await guardianClient.validateEVMTransaction({
-        chainId: config.zkEvmChainId,
+        chainId: getEip155ChainId(chainId),
         nonce: convertBigNumberishToString(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);
-    // TODO: ID-697 Evaluate transactions through Guardian
+    const signedTransactions = await getSignedMetaTransactions([metaTransaction, feeMetaTransaction], nonce, chainIdBigNumber, user.zkEvm.ethAddress, signer);
     const relayerId = await relayerClient.ethSendTransaction(user.zkEvm.ethAddress, signedTransactions);
     const retrieveRelayerTransaction = async () => {
         const tx = await relayerClient.imGetTransactionByHash(relayerId);
@@ -7426,7 +7401,8 @@ class ZkEvmProvider {
     relayerClient;
     magicProvider; // Used for signing
     user;
-    constructor({ authManager, magicAdapter, config, confirmationScreen, multiRollupApiClients, }) {
+    isPassport = true;
+    constructor({ authManager, magicAdapter, config, confirmationScreen, multiRollupApiClients, passportEventEmitter, }) {
         this.authManager = authManager;
         this.magicAdapter = magicAdapter;
         this.config = config;
@@ -7437,8 +7413,18 @@ class ZkEvmProvider {
         this.jsonRpcProvider = new JsonRpcProvider(this.config.zkEvmRpcUrl);
         this.multiRollupApiClients = multiRollupApiClients;
         this.eventEmitter = new TypedEventEmitter();
-    }
-    isPassport = true;
+        passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.handleLogout);
+    }
+    handleLogout = () => {
+        const shouldEmitAccountsChanged = this.isLoggedIn();
+        this.magicProvider = undefined;
+        this.user = undefined;
+        this.relayerClient = undefined;
+        this.guardianClient = undefined;
+        if (shouldEmitAccountsChanged) {
+            this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, []);
+        }
+    };
     isLoggedIn() {
         return this.magicProvider !== undefined
             && this.user !== undefined
@@ -7461,13 +7447,19 @@ class ZkEvmProvider {
                 this.magicProvider = magicProvider;
                 this.relayerClient = new RelayerClient({
                     config: this.config,
+                    jsonRpcProvider: this.jsonRpcProvider,
                     user: this.user,
                 });
                 this.guardianClient = new GuardianClient({
-                    imxPublicApiDomain: this.config.imxPublicApiDomain,
                     accessToken: this.user.accessToken,
                     confirmationScreen: this.confirmationScreen,
                     imxEtherAddress: this.user.zkEvm.ethAddress,
+                    config: new PassportConfiguration({
+                        baseConfig: {},
+                        clientId: 'client123',
+                        logoutRedirectUri: 'http://localhost:3000/logout',
+                        redirectUri: 'http://localhost:3000/redirect',
+                    }),
                 });
                 this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [this.user.zkEvm.ethAddress]);
                 return [this.user.zkEvm.ethAddress];
@@ -7481,7 +7473,6 @@ class ZkEvmProvider {
                     magicProvider: this.magicProvider,
                     guardianClient: this.guardianClient,
                     jsonRpcProvider: this.jsonRpcProvider,
-                    config: this.config,
                     relayerClient: this.relayerClient,
                     user: this.user,
                 });
@@ -7613,8 +7604,9 @@ class Passport {
     confirmationScreen;
     immutableXClient;
     magicAdapter;
-    passportImxProviderFactory;
     multiRollupApiClients;
+    passportImxProviderFactory;
+    passportEventEmitter;
     constructor(passportModuleConfiguration) {
         this.config = new PassportConfiguration(passportModuleConfiguration);
         this.authManager = new AuthManager(this.config);
@@ -7625,12 +7617,14 @@ class Passport {
                 baseConfig: passportModuleConfiguration.baseConfig,
             });
         this.multiRollupApiClients = new MultiRollupApiClients(this.config.multiRollupConfig);
+        this.passportEventEmitter = new TypedEventEmitter();
         this.passportImxProviderFactory = new PassportImxProviderFactory({
             authManager: this.authManager,
             config: this.config,
             confirmationScreen: this.confirmationScreen,
             immutableXClient: this.immutableXClient,
             magicAdapter: this.magicAdapter,
+            passportEventEmitter: this.passportEventEmitter,
         });
     }
     async connectImxSilent() {
@@ -7665,6 +7659,7 @@ class Passport {
             throw new Error('EVM is not supported on production network');
         }
         return new ZkEvmProvider({
+            passportEventEmitter: this.passportEventEmitter,
             authManager: this.authManager,
             magicAdapter: this.magicAdapter,
             config: this.config,
@@ -7676,7 +7671,10 @@ class Passport {
         return this.authManager.loginCallback();
     }
     async logout() {
-        return this.authManager.logout();
+        await this.authManager.logout();
+        // Code after this point is only executed if the logout mode is silent
+        await this.magicAdapter.logout();
+        this.passportEventEmitter.emit(PassportEvents.LOGGED_OUT);
     }
     /**
      * This method should only be called from the logout redirect uri