@imtbl/sdk 0.2.3-alpha.1 → 0.3.0-alpha.1

package/dist/index.js

@@ -8,8 +8,10 @@ import { OpenIdExtension } from '@magic-ext/oidc';
 import BN$2 from 'bn.js';
 import * as encUtils from 'enc-utils';
 import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers';
+import { ethers, BigNumber as BigNumber$1, providers, constants, utils as utils$2, Contract as Contract$1, ContractFactory } from 'ethers';
+import { walletContracts } from '@0xsequence/abi';
+import { encodeSignature } from '@0xsequence/config';
 import FormData$2 from 'form-data';
-import { providers, BigNumber as BigNumber$1, constants, utils as utils$2, Contract as Contract$1, ethers, ContractFactory } from 'ethers';
 import { Seaport as Seaport$1 } from '@opensea/seaport-js';
 import { parseUnits } from '@ethersproject/units';
 import { BigNumber as BigNumber$2 } from '@ethersproject/bignumber';
@@ -3245,6 +3247,94 @@ axios$1.default = axios$1;
 // this module should only have a default export
 var globalAxios$1 = axios$1;
 
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Immutable X API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 3.0
+ * Contact: support@immutable.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+let Configuration$1 = class Configuration {
+    /**
+     * parameter for apiKey security
+     * @param name security name
+     * @memberof Configuration
+     */
+    apiKey;
+    /**
+     * parameter for basic security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    username;
+    /**
+     * parameter for basic security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    password;
+    /**
+     * parameter for oauth2 security
+     * @param name security name
+     * @param scopes oauth2 scope
+     * @memberof Configuration
+     */
+    accessToken;
+    /**
+     * override base path
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    basePath;
+    /**
+     * base options for axios calls
+     *
+     * @type {any}
+     * @memberof Configuration
+     */
+    baseOptions;
+    /**
+     * The FormData constructor that will be used to create multipart form data
+     * requests. You can inject this here so that execution environments that
+     * do not support the FormData class can still run the generated client.
+     *
+     * @type {new () => FormData}
+     */
+    formDataCtor;
+    constructor(param = {}) {
+        this.apiKey = param.apiKey;
+        this.username = param.username;
+        this.password = param.password;
+        this.accessToken = param.accessToken;
+        this.basePath = param.basePath;
+        this.baseOptions = param.baseOptions;
+        this.formDataCtor = param.formDataCtor;
+    }
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime) {
+        const jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+};
+
 /* tslint:disable */
 /* eslint-disable */
 /**
@@ -4953,7 +5043,7 @@ class TokensApi extends BaseAPI$1 {
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-let Configuration$1 = class Configuration {
+let Configuration$2 = class Configuration {
     /**
      * parameter for apiKey security
      * @param name security name
@@ -5386,7 +5476,7 @@ var index = /*#__PURE__*/Object.freeze({
   CollectionsApiAxiosParamCreator: CollectionsApiAxiosParamCreator,
   CollectionsApiFactory: CollectionsApiFactory,
   CollectionsApiFp: CollectionsApiFp,
-  Configuration: Configuration$1,
+  Configuration: Configuration$2,
   CreateOrderProtocolDataOrderTypeEnum: CreateOrderProtocolDataOrderTypeEnum,
   ERC20ItemItemTypeEnum: ERC20ItemItemTypeEnum,
   ERC721ItemItemTypeEnum: ERC721ItemItemTypeEnum,
@@ -5418,6 +5508,69 @@ var index = /*#__PURE__*/Object.freeze({
   TokensApiFp: TokensApiFp
 });
 
+class MultiRollupApiClients {
+    config;
+    activitiesApi;
+    chainsApi;
+    collectionApi;
+    nftOwnersApi;
+    nftsApi;
+    ordersApi;
+    passportApi;
+    constructor(config) {
+        this.config = config;
+        this.activitiesApi = new ActivitiesApi(config.indexer);
+        this.chainsApi = new ChainsApi(config.indexer);
+        this.collectionApi = new CollectionsApi(config.indexer);
+        this.nftOwnersApi = new NftOwnersApi(config.indexer);
+        this.nftsApi = new NftsApi(config.indexer);
+        this.ordersApi = new OrdersApi(config.orderBook);
+        this.passportApi = new PassportApi(config.passport);
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.3.0-alpha.1' };
+const createConfig = ({ basePath, headers, }) => {
+    if (!basePath.trim()) {
+        throw Error('basePath can not be empty');
+    }
+    const composedHeaders = { ...defaultHeaders$1, ...(headers || {}) };
+    const apiConfigOptions = {
+        basePath,
+        baseOptions: { headers: composedHeaders },
+    };
+    return new Configuration$1(apiConfigOptions);
+};
+/**
+ * Creates a Configuration for the specified environment
+ * @returns an MultiRollupAPIConfiguration
+ */
+const multiRollupConfig = {
+    getProduction: () => ({
+        indexer: createConfig({
+            basePath: 'https://indexer-mr.imtbl.com',
+        }),
+        orderBook: createConfig({
+            basePath: 'https://order-book-mr.imtbl.com',
+        }),
+        passport: createConfig({
+            basePath: 'https://api.immutable.com',
+        }),
+    }),
+    getSandbox: () => ({
+        indexer: createConfig({
+            basePath: 'https://indexer-mr.sandbox.imtbl.com',
+        }),
+        orderBook: createConfig({
+            basePath: 'https://order-book-mr.sandbox.imtbl.com',
+        }),
+        passport: createConfig({
+            basePath: 'https://api.sandbox.immutable.com',
+        }),
+    }),
+};
+
 /**
  * Custom Error class that is returned from the API when a request fails
  */
@@ -5437,7 +5590,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.2.3-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.3.0-alpha.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -5703,7 +5856,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.2.3-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-0.3.0-alpha.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -10051,10 +10204,12 @@ class AuthManager {
     userManager;
     config;
     deviceCredentialsManager;
+    logoutMode;
     constructor(config) {
         this.config = config;
         this.userManager = new UserManager(getAuthConfiguration(config));
         this.deviceCredentialsManager = new DeviceCredentialsManager();
+        this.logoutMode = config.oidcConfiguration.logoutMode || 'redirect';
     }
     static mapOidcUserToDomainModel = (oidcUser) => {
         const passport = oidcUser.profile?.passport;
@@ -10208,7 +10363,15 @@ class AuthManager {
         return response.data;
     }
     async logout() {
-        return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
+        return withPassportError(async () => {
+            if (this.logoutMode === 'silent') {
+                return this.userManager.signoutSilent();
+            }
+            return this.userManager.signoutRedirect();
+        }, PassportErrorType.LOGOUT_ERROR);
+    }
+    async logoutSilentCallback(url) {
+        return this.userManager.signoutSilentCallback(url);
     }
     async logoutDeviceFlow() {
         return withPassportError(async () => {
@@ -10865,6 +11028,10 @@ class PassportConfiguration {
     magicProviderId;
     oidcConfiguration;
     baseConfig;
+    zkEvmChainId;
+    zkEvmRpcUrl;
+    relayerUrl;
+    multiRollupConfig;
     constructor({ baseConfig, overrides, ...oidcConfiguration }) {
         validateConfiguration(oidcConfiguration, [
             'clientId',
@@ -10877,10 +11044,16 @@ class PassportConfiguration {
             validateConfiguration(overrides, [
                 'network',
                 'authenticationDomain',
+                'passportDomain',
                 'magicPublishableApiKey',
                 'magicProviderId',
-                'passportDomain',
+                'zkEvmRpcUrl',
+                'zkEvmChainId',
+                'relayerUrl',
                 'imxPublicApiDomain',
+                'indexerMrBasePath',
+                'orderBookMrBasePath',
+                'passportMrBasePath',
             ], 'overrides');
             this.network = overrides.network;
             this.authenticationDomain = overrides.authenticationDomain;
@@ -10888,6 +11061,20 @@ class PassportConfiguration {
             this.imxPublicApiDomain = overrides.imxPublicApiDomain;
             this.magicPublishableApiKey = overrides.magicPublishableApiKey;
             this.magicProviderId = overrides.magicProviderId;
+            this.zkEvmRpcUrl = overrides.zkEvmRpcUrl;
+            this.zkEvmChainId = overrides.zkEvmChainId;
+            this.relayerUrl = overrides.relayerUrl;
+            this.multiRollupConfig = {
+                indexer: createConfig({
+                    basePath: overrides.indexerMrBasePath,
+                }),
+                orderBook: createConfig({
+                    basePath: overrides.orderBookMrBasePath,
+                }),
+                passport: createConfig({
+                    basePath: overrides.passportMrBasePath,
+                }),
+            };
         }
         else {
             switch (baseConfig.environment) {
@@ -10898,6 +11085,10 @@ class PassportConfiguration {
                     this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
                     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://relayer.immutable.com'; // TODO: ID-784 Update once we have added Relayer URL to config
+                    this.multiRollupConfig = multiRollupConfig.getProduction();
                     break;
                 }
                 case Environment$1.SANDBOX:
@@ -10908,6 +11099,10 @@ class PassportConfiguration {
                     this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
                     this.passportDomain = 'https://passport.sandbox.immutable.com';
                     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.multiRollupConfig = multiRollupConfig.getSandbox();
                     break;
                 }
             }
@@ -11068,6 +11263,454 @@ class ConfirmationScreen {
     }
 }
 
+// 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]);
+    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$1.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 transactionRequest = params[0];
+    if (!transactionRequest.to) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
+    }
+    const chainId = chainIdNumber(config.zkEvmChainId);
+    const magicWeb3Provider = new Web3Provider(magicProvider);
+    const signer = magicWeb3Provider.getSigner();
+    const nonce = await getNonce(jsonRpcProvider, user.zkEvm.ethAddress);
+    const metaTransaction = {
+        to: transactionRequest.to,
+        data: transactionRequest.data,
+        nonce,
+        value: transactionRequest.value,
+        revertOnError: true,
+    };
+    // NOTE: We sign the transaction before getting the fee options because
+    // 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);
+    // 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
+    // should transfer the payment to, an amount and a currency. We choose one
+    // option and build a transaction that sends the expected currency amount for
+    // that option to the specified address.
+    const feeOptions = await relayerClient.imGetFeeOptions(user.zkEvm.ethAddress, signedTransaction);
+    const imxFeeOption = feeOptions.find((feeOption) => feeOption.tokenSymbol === 'IMX');
+    if (!imxFeeOption) {
+        throw new Error('Failed to retrieve fees for IMX token');
+    }
+    const feeMetaTransaction = {
+        nonce,
+        to: imxFeeOption.recipientAddress,
+        value: imxFeeOption.tokenPrice,
+        revertOnError: true,
+    };
+    // 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 relayerId = await relayerClient.ethSendTransaction(user.zkEvm.ethAddress, signedTransactions);
+    const retrieveRelayerTransaction = async () => {
+        const tx = await relayerClient.imGetTransactionByHash(relayerId);
+        // NOTE: The transaction hash is only available from the Relayer once the
+        // transaction is actually submitted onchain. Hence we need to poll the
+        // Relayer get transaction endpoint until the status transitions to one that
+        // has the hash available.
+        if (tx.status === RelayerTransactionStatus.PENDING) {
+            throw new Error();
+        }
+        return tx;
+    };
+    const relayerTransaction = await retryWithDelay(retrieveRelayerTransaction, {
+        retries: MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES,
+        interval: TRANSACTION_HASH_RETRIEVAL_WAIT,
+        finalErr: new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'transaction hash not generated in time'),
+    });
+    if (![RelayerTransactionStatus.SUBMITTED, RelayerTransactionStatus.SUCCESSFUL].includes(relayerTransaction.status)) {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, `Transaction failed to submit with status ${relayerTransaction.status}`);
+    }
+    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;
+    multiRollupApiClients;
+    jsonRpcProvider; // Used for read operations
+    magicProvider; // Used for signing
+    user;
+    constructor({ authManager, magicAdapter, config, confirmationScreen, multiRollupApiClients, }) {
+        this.authManager = authManager;
+        this.magicAdapter = magicAdapter;
+        this.config = config;
+        this.confirmationScreen = confirmationScreen;
+        this.relayerClient = new RelayerClient({ config });
+        this.jsonRpcProvider = new JsonRpcProvider(this.config.zkEvmRpcUrl);
+        this.multiRollupApiClients = multiRollupApiClients;
+    }
+    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({
+                    authManager: this.authManager,
+                    config: this.config,
+                    magicAdapter: this.magicAdapter,
+                    multiRollupApiClients: this.multiRollupApiClients,
+                });
+                this.user = user;
+                this.magicProvider = magicProvider;
+                return [this.user.zkEvm.ethAddress];
+            }
+            case 'eth_sendTransaction': {
+                return authWrapper(ethSendTransaction);
+            }
+            case 'eth_accounts': {
+                return this.isLoggedIn() ? [this.user.zkEvm.ethAddress] : [];
+            }
+            // Pass through methods
+            case 'eth_gasPrice':
+            case 'eth_getBalance':
+            case 'eth_getStorageAt':
+            case 'eth_estimateGas':
+            case 'eth_call':
+            case 'eth_blockNumber':
+            case 'eth_chainId':
+            case 'eth_getBlockByHash':
+            case 'eth_getBlockByNumber':
+            case 'eth_getTransactionByHash':
+            case 'eth_getTransactionReceipt':
+            case 'eth_getTransactionCount': {
+                return this.jsonRpcProvider.send(request.method, request.params || []);
+            }
+            default: {
+                throw new JsonRpcError(RpcErrorCode.METHOD_NOT_FOUND, 'Method not supported');
+            }
+        }
+    }
+    async performJsonRpcRequest(request) {
+        const { id, jsonrpc } = request;
+        try {
+            const result = await this.performRequest(request);
+            return {
+                id,
+                jsonrpc,
+                result,
+            };
+        }
+        catch (error) {
+            let jsonRpcError;
+            if (error instanceof JsonRpcError) {
+                jsonRpcError = error;
+            }
+            else if (error instanceof Error) {
+                jsonRpcError = new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+            }
+            else {
+                jsonRpcError = new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+            }
+            return {
+                id,
+                jsonrpc,
+                error: jsonRpcError,
+            };
+        }
+    }
+    async request(request) {
+        try {
+            return this.performRequest(request);
+        }
+        catch (error) {
+            if (error instanceof JsonRpcError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+            }
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+        }
+    }
+    sendAsync(request, callback) {
+        if (!callback) {
+            throw new Error('No callback provided');
+        }
+        if (Array.isArray(request)) {
+            Promise.all(request.map(this.performJsonRpcRequest)).then((result) => {
+                callback(null, result);
+            }).catch((error) => {
+                callback(error, []);
+            });
+        }
+        else {
+            this.performJsonRpcRequest(request).then((result) => {
+                callback(null, result);
+            }).catch((error) => {
+                callback(error, null);
+            });
+        }
+    }
+    async send(request, callbackOrParams, callback) {
+        // Web3 >= 1.0.0-beta.38 calls `send` with method and parameters.
+        if (typeof request === 'string') {
+            if (typeof callbackOrParams === 'function') {
+                return this.sendAsync({
+                    method: request,
+                    params: [],
+                }, callbackOrParams);
+            }
+            if (callback) {
+                return this.sendAsync({
+                    method: request,
+                    params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
+                }, callback);
+            }
+            return this.request({
+                method: request,
+                params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
+            });
+        }
+        // Web3 <= 1.0.0-beta.37 uses `send` with a callback for async queries.
+        if (typeof callbackOrParams === 'function') {
+            return this.sendAsync(request, callbackOrParams);
+        }
+        if (!Array.isArray(request) && typeof request === 'object') {
+            return this.performJsonRpcRequest(request);
+        }
+        throw new JsonRpcError(RpcErrorCode.INVALID_REQUEST, 'Invalid request');
+    }
+}
+
 class Passport {
     authManager;
     config;
@@ -11075,6 +11718,7 @@ class Passport {
     immutableXClient;
     magicAdapter;
     passportImxProviderFactory;
+    multiRollupApiClients;
     constructor(passportModuleConfiguration) {
         this.config = new PassportConfiguration(passportModuleConfiguration);
         this.authManager = new AuthManager(this.config);
@@ -11084,6 +11728,7 @@ class Passport {
             || new ImmutableXClient({
                 baseConfig: passportModuleConfiguration.baseConfig,
             });
+        this.multiRollupApiClients = new MultiRollupApiClients(this.config.multiRollupConfig);
         this.passportImxProviderFactory = new PassportImxProviderFactory({
             authManager: this.authManager,
             config: this.config,
@@ -11113,12 +11758,29 @@ class Passport {
     async connectImxWithCredentials(tokenResponse) {
         return this.passportImxProviderFactory.getProviderWithCredentials(tokenResponse);
     }
+    // TODO ID-926 Make method public once development has been finalised
+    connectEvm() {
+        return new ZkEvmProvider({
+            authManager: this.authManager,
+            magicAdapter: this.magicAdapter,
+            config: this.config,
+            confirmationScreen: this.confirmationScreen,
+            multiRollupApiClients: this.multiRollupApiClients,
+        });
+    }
     async loginCallback() {
         return this.authManager.loginCallback();
     }
     async logout() {
         return this.authManager.logout();
     }
+    /**
+     * This method should only be called from the logout redirect uri
+     * when logout mode is 'silent'.
+     */
+    async logoutSilentCallback(url) {
+        return this.authManager.logoutSilentCallback(url);
+    }
     async logoutDeviceFlow() {
         return this.authManager.logoutDeviceFlow();
     }
@@ -27911,7 +28573,7 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.2.3-alpha.1";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.3.0-alpha.1";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;