@imtbl/sdk 0.28.6-alpha.1 → 0.28.7-alpha

package/dist/index.js

@@ -1,4 +1,4 @@
-import globalAxios$1, { isAxiosError as isAxiosError$1, HttpStatusCode as HttpStatusCode$2 } from 'axios';
+import globalAxios$1, { isAxiosError as isAxiosError$1, AxiosError as AxiosError$1, HttpStatusCode as HttpStatusCode$2 } from 'axios';
 import { ImmutableX, Config, IMXError, createStarkSigner, generateLegacyStarkPrivateKey, TransfersApi, OrdersApi as OrdersApi$1, UsersApi, Contracts, TradesApi, ExchangesApi, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi as TokensApi$1 } from '@imtbl/core-sdk';
 import { UserManager, InMemoryWebStorage, WebStorageStateStore } from 'oidc-client-ts';
 import jwt_decode from 'jwt-decode';
@@ -3627,7 +3627,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.28.6-alpha.1' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.28.7-alpha' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3687,7 +3687,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.28.6-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.28.7-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4098,7 +4098,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.28.6-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-0.28.7-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -9043,39 +9043,63 @@ class AuthManager {
     }
 }
 
+const lazyLoad = (promiseToAwait, initialiseFunction) => (promiseToAwait().then(initialiseFunction));
+const lazyDocumentReady = (initialiseFunction) => {
+    const documentReadyPromise = () => new Promise((resolve) => {
+        if (window.document.readyState === 'complete') {
+            resolve();
+        }
+        else {
+            const onReadyStateChange = () => {
+                if (window.document.readyState === 'complete') {
+                    resolve();
+                    window.document.removeEventListener('readystatechange', onReadyStateChange);
+                }
+            };
+            window.document.addEventListener('readystatechange', onReadyStateChange);
+        }
+    });
+    return lazyLoad(documentReadyPromise, initialiseFunction);
+};
+
 class MagicAdapter {
     config;
-    magicClient;
+    lazyMagicClient;
     constructor(config) {
         this.config = config;
         if (typeof window !== 'undefined') {
-            this.magicClient = this.initMagicClient();
-            this.magicClient.preload();
+            this.lazyMagicClient = lazyDocumentReady(() => {
+                const client = new Magic(this.config.magicPublishableApiKey, {
+                    extensions: [new OpenIdExtension()],
+                    network: this.config.network,
+                });
+                client.preload();
+                return client;
+            });
+        }
+    }
+    get magicClient() {
+        if (!this.lazyMagicClient) {
+            throw new Error('Cannot perform this action outside of the browser');
         }
+        return this.lazyMagicClient;
     }
     async login(idToken) {
         return withPassportError(async () => {
-            if (!this.magicClient) {
-                this.magicClient = this.initMagicClient();
-            }
-            await this.magicClient.openid.loginWithOIDC({
+            const magicClient = await this.magicClient;
+            await magicClient.openid.loginWithOIDC({
                 jwt: idToken,
                 providerId: this.config.magicProviderId,
             });
-            return this.magicClient.rpcProvider;
+            return magicClient.rpcProvider;
         }, PassportErrorType.WALLET_CONNECTION_ERROR);
     }
     async logout() {
-        if (this.magicClient?.user) {
-            await this.magicClient.user.logout();
+        const magicClient = await this.magicClient;
+        if (magicClient.user) {
+            await magicClient.user.logout();
         }
     }
-    initMagicClient() {
-        return new Magic(this.config.magicPublishableApiKey, {
-            extensions: [new OpenIdExtension()],
-            network: this.config.network,
-        });
-    }
 }
 
 const getStarkSigner = async (signer) => withPassportError(async () => {
@@ -9302,7 +9326,7 @@ var PassportEvents;
 var Networks;
 (function (Networks) {
     Networks["PRODUCTION"] = "mainnet";
-    Networks["SANDBOX"] = "goerli";
+    Networks["SANDBOX"] = "sepolia";
 })(Networks || (Networks = {}));
 
 async function exchangeTransfer$1({ user, starkSigner, request, exchangesApi, }) {
@@ -9651,6 +9675,11 @@ class PassportImxProvider {
     }
     // TODO: Remove once implemented
     // eslint-disable-next-line class-methods-use-this
+    isRegisteredOffchain() {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    // TODO: Remove once implemented
+    // eslint-disable-next-line class-methods-use-this
     isRegisteredOnchain() {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
@@ -9744,7 +9773,17 @@ class PassportImxProviderFactory {
         this.passportEventEmitter = passportEventEmitter;
     }
     async getProvider() {
-        const user = await this.authManager.loginSilent() || await this.authManager.login();
+        let user = null;
+        try {
+            user = await this.authManager.loginSilent();
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.warn(e);
+        }
+        if (!user) {
+            user = await this.authManager.login();
+        }
         return this.createProviderInstance(user);
     }
     async getProviderSilent() {
@@ -10799,7 +10838,14 @@ class Passport {
      */
     async login(options) {
         const { useCachedSession = false } = options || {};
-        let user = await this.authManager.loginSilent();
+        let user = null;
+        try {
+            user = await this.authManager.loginSilent();
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.warn('loginSilent failed with error:', error);
+        }
         if (!user && !useCachedSession) {
             user = await this.authManager.login();
         }
@@ -12647,6 +12693,22 @@ async function registerOffchain(signers, config) {
     });
     return registeredUser.data;
 }
+async function isRegisteredOffchain(ethAddress, config) {
+    try {
+        const usersApi = new UsersApi(config.immutableXConfig.apiConfiguration);
+        const getUsersResult = await usersApi.getUsers({
+            user: ethAddress,
+        });
+        const { accounts } = getUsersResult.data;
+        return accounts?.length > 0;
+    }
+    catch (ex) {
+        if (ex instanceof AxiosError$1 && ex.response?.status === 404) {
+            return false;
+        }
+        throw ex;
+    }
+}
 async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
     await validateChain(ethSigner, config.immutableXConfig);
     const registrationContract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
@@ -13182,7 +13244,11 @@ class GenericIMXProvider {
         this.signers = { ethSigner, starkSigner };
     }
     async getAddress() {
-        return await this.signers.ethSigner.getAddress();
+        return this.signers.ethSigner.getAddress();
+    }
+    async isRegisteredOffchain() {
+        const ethAddress = await this.getAddress();
+        return isRegisteredOffchain(ethAddress, this.config);
     }
     registerOffchain() {
         return registerOffchain(this.signers, this.config);
@@ -29402,6 +29468,7 @@ var SaleEventType;
     SaleEventType["SUCCESS"] = "success";
     SaleEventType["FAILURE"] = "failure";
     SaleEventType["REJECTED"] = "rejected";
+    SaleEventType["TRANSACTION_SUCCESS"] = "transaction-success";
 })(SaleEventType || (SaleEventType = {}));
 
 /**
@@ -30570,6 +30637,9 @@ async function getERC20Balance(web3Provider, walletAddress, contractAddress) {
 }
 // Blockscout client singleton per chain id
 const blockscoutClientMap = new Map();
+// This function is a utility function that can be used to reset the
+// blockscout map and therefore clear all the cache.
+const resetBlockscoutClientMap = () => blockscoutClientMap.clear();
 const getIndexerBalance = async (walletAddress, chainId, filterTokens) => {
     // Shuffle the mapping of the tokens configuration so it is a hashmap
     // for faster access to tokens config objects.
@@ -30670,6 +30740,8 @@ const getBalances = async (config, web3Provider, walletAddress, tokens) => {
     return { balances };
 };
 const getAllBalances = async (config, web3Provider, walletAddress, chainId) => {
+    // eslint-disable-next-line no-param-reassign
+    chainId ||= await web3Provider.getSigner().getChainId();
     const { tokens } = await getTokenAllowList(config, {
         type: TokenFilterTypes.ALL,
         chainId,
@@ -30692,7 +30764,7 @@ const getAllBalances = async (config, web3Provider, walletAddress, chainId) => {
         // Please remove this hack once https://immutable.atlassian.net/browse/WT-1710
         // is done.
         const isL1Chain = getL1ChainId(config) === chainId;
-        return measureAsyncExecution(config, `Time to fetch balances using blockscout for ${chainId}`, getIndexerBalance(walletAddress, chainId, isL1Chain ? tokens : []));
+        return await measureAsyncExecution(config, `Time to fetch balances using blockscout for ${chainId}`, getIndexerBalance(walletAddress, chainId, isL1Chain ? tokens : []));
     }
     // This fallback to use ERC20s calls which is a best effort solution
     // Fails in fetching data from the RCP calls might result in some
@@ -31566,18 +31638,15 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
  * Gets the balances for all NATIVE and ERC20 balance requirements.
  */
 const getTokenBalances = async (config, provider, ownerAddress, itemRequirements) => {
-    let tokenBalances = [];
     try {
-        const tokenList = getTokensFromRequirements(itemRequirements);
-        const { balances } = await getBalances(config, provider, ownerAddress, tokenList);
-        tokenBalances = [
-            ...balances.map((balance) => balance),
-        ];
+        const tokenMap = new Map();
+        getTokensFromRequirements(itemRequirements).forEach((item) => tokenMap.set((item.address || '').toLocaleLowerCase(), item));
+        const { balances } = await getAllBalances(config, provider, ownerAddress);
+        return balances.filter((balance) => tokenMap.get((balance.token.address || '').toLocaleLowerCase()));
     }
     catch (error) {
         throw new CheckoutError('Failed to get balances', CheckoutErrorType.GET_BALANCE_ERROR);
     }
-    return tokenBalances;
 };
 /**
  * Gets the balances for all ERC721 balance requirements.
@@ -31624,53 +31693,56 @@ const getERC721Balances = async (provider, ownerAddress, itemRequirements) => {
  */
 const balanceCheck = async (config, provider, ownerAddress, itemRequirements) => {
     const aggregatedItems = balanceAggregator(itemRequirements);
-    if (aggregatedItems.filter((itemRequirement) => {
-        return itemRequirement.type !== ItemType.ERC721
-            && itemRequirement.type !== ItemType.ERC20
-            && itemRequirement.type !== ItemType.NATIVE;
-    }).length > 0) {
+    const requiredToken = [];
+    const requiredERC721 = [];
+    aggregatedItems.forEach((item) => {
+        switch (item.type) {
+            case ItemType.ERC20:
+            case ItemType.NATIVE:
+                requiredToken.push(item);
+                break;
+            case ItemType.ERC721:
+                requiredERC721.push(item);
+                break;
+        }
+    });
+    if (requiredERC721.length === 0 && requiredToken.length === 0) {
         throw new CheckoutError('Unsupported item requirement balance check', CheckoutErrorType.UNSUPPORTED_BALANCE_REQUIREMENT_ERROR);
     }
     // Get all ERC20 and NATIVE balances
-    const currentBalances = [];
-    const tokenItemRequirements = aggregatedItems
-        .filter((itemRequirement) => itemRequirement.type === ItemType.ERC20 || itemRequirement.type === ItemType.NATIVE);
-    if (tokenItemRequirements.length > 0) {
-        currentBalances.push(getTokenBalances(config, provider, ownerAddress, aggregatedItems));
+    const balancePromises = [];
+    if (requiredToken.length > 0) {
+        balancePromises.push(getTokenBalances(config, provider, ownerAddress, aggregatedItems));
     }
     // Get all ERC721 balances
-    const erc721ItemRequirements = aggregatedItems
-        .filter((itemRequirement) => itemRequirement.type === ItemType.ERC721);
-    if (erc721ItemRequirements.length > 0) {
-        currentBalances.push(getERC721Balances(provider, ownerAddress, aggregatedItems));
+    if (requiredERC721.length > 0) {
+        balancePromises.push(getERC721Balances(provider, ownerAddress, aggregatedItems));
     }
     // Wait for all balances and calculate the requirements
-    const balanceRequirements = await Promise.all(currentBalances).then((balances) => {
-        const requirements = [];
-        if (balances.length > 1 || tokenItemRequirements.length > 0) {
-            const tokenBalances = balances[0];
-            tokenItemRequirements.forEach((tokenItemRequirement) => {
-                requirements.push(getTokenBalanceRequirement(tokenItemRequirement, tokenBalances));
+    const promisesResponses = await Promise.all(balancePromises);
+    const balanceRequirements = [];
+    // Get all ERC20 and NATIVE balances
+    if (requiredToken.length > 0 && promisesResponses.length > 0) {
+        const result = promisesResponses.shift();
+        if (result) {
+            requiredToken.forEach((item) => {
+                balanceRequirements.push(getTokenBalanceRequirement(item, result));
             });
-            if (erc721ItemRequirements.length > 0) {
-                const erc721Balances = balances[1];
-                erc721ItemRequirements.forEach((erc721ItemRequirement) => {
-                    requirements.push(getERC721BalanceRequirement(erc721ItemRequirement, erc721Balances));
-                });
-            }
         }
-        else if (erc721ItemRequirements.length > 0) {
-            // Only erc721
-            const erc721Balances = balances[0];
-            erc721ItemRequirements.forEach((erc721ItemRequirement) => {
-                requirements.push(getERC721BalanceRequirement(erc721ItemRequirement, erc721Balances));
+    }
+    // Get all ERC721 balances
+    if (requiredERC721.length > 0 && promisesResponses.length > 0) {
+        const result = promisesResponses.shift();
+        if (result) {
+            requiredERC721.forEach((item) => {
+                balanceRequirements.push(getERC721BalanceRequirement(item, result));
             });
         }
-        return requirements;
-    });
-    const sufficient = balanceRequirements.reduce((acc, balanceRequirement) => {
-        return acc && balanceRequirement.sufficient;
-    }, true);
+    }
+    // Find if there are any requirements that aren't sufficient.
+    // If there is not item with sufficient === false then the requirements
+    // are satisfied.
+    const sufficient = balanceRequirements.find((req) => req.sufficient === false) === undefined;
     return {
         sufficient,
         balanceRequirements,
@@ -32273,8 +32345,12 @@ const getBridgeFeeEstimate = async (config, readOnlyProviders) => {
 // If the root address evaluates to this then its ETH
 const INDEXER_ETH_ROOT_CONTRACT_ADDRESS = '0x0000000000000000000000000000000000000001';
 const getIndexerChainName = (chainId) => {
+    if (chainId === ChainId.IMTBL_ZKEVM_MAINNET)
+        return 'imtbl-zkevm-mainnet';
     if (chainId === ChainId.IMTBL_ZKEVM_TESTNET)
         return 'imtbl-zkevm-testnet';
+    if (chainId === ChainId.IMTBL_ZKEVM_DEVNET)
+        return 'imtbl-zkevm-devent';
     return '';
 };
 // Indexer ERC20 call does not support IMX so cannot get root chain mapping from this endpoint.
@@ -33273,18 +33349,26 @@ const getTransactionOrGas = (gasLimit, fulfillmentTransactions) => {
     };
 };
 const buy = async (config, provider, orders) => {
-    let orderbook;
-    let order;
-    let spenderAddress = '';
-    const gasLimit = constants.estimatedFulfillmentGasGwei;
     if (orders.length === 0) {
         throw new CheckoutError('No orders were provided to the orders array. Please provide at least one order.', CheckoutErrorType.FULFILL_ORDER_LISTING_ERROR);
     }
+    let order;
+    let spenderAddress = '';
+    let decimals = 18;
+    const gasLimit = constants.estimatedFulfillmentGasGwei;
+    const orderbook = createOrderbookInstance(config);
+    const blockchainClient = createBlockchainDataInstance(config);
+    const fulfillerAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
+    // Prefetch balances and store them in memory
+    resetBlockscoutClientMap();
+    getAllBalances(config, provider, fulfillerAddress, getL1ChainId(config));
+    getAllBalances(config, provider, fulfillerAddress, getL2ChainId(config));
     const { id, takerFees } = orders[0];
+    let orderChainName;
     try {
-        orderbook = createOrderbookInstance(config);
         order = await measureAsyncExecution(config, 'Time to fetch the listing from the orderbook', orderbook.getListing(id));
-        const { seaportContractAddress } = orderbook.config();
+        const { seaportContractAddress, chainName } = orderbook.config();
+        orderChainName = chainName;
         spenderAddress = seaportContractAddress;
     }
     catch (err) {
@@ -33300,10 +33384,10 @@ const buy = async (config, provider, orders) => {
         });
     }
     const buyToken = order.result.buy[0];
-    let decimals = 18;
-    if (order.result.buy[0].type === 'ERC20') {
-        const tokenContract = getTokenContract(order.result.buy[0].contractAddress, ERC20ABI, provider);
-        decimals = await measureAsyncExecution(config, 'Time to get decimals of token contract for the buy token', tokenContract.decimals());
+    if (buyToken.type === 'ERC20') {
+        const token = await measureAsyncExecution(config, 'Time to get decimals of token contract for the buy token', blockchainClient.getToken({ contractAddress: buyToken.contractAddress, chainName: orderChainName }));
+        if (token.result.decimals)
+            decimals = token.result.decimals;
     }
     let fees = [];
     if (takerFees && takerFees.length > 0) {
@@ -33314,7 +33398,6 @@ const buy = async (config, provider, orders) => {
     let orderActions = [];
     const fulfillOrderStartTime = performance.now();
     try {
-        const fulfillerAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
         const { actions } = await measureAsyncExecution(config, 'Time to call fulfillOrder from the orderbook', orderbook.fulfillOrder(id, fulfillerAddress, fees));
         orderActions = actions;
         unsignedApprovalTransactions = await measureAsyncExecution(config, 'Time to construct the unsigned approval transactions', getUnsignedERC20ApprovalTransactions(actions));
@@ -33652,7 +33735,7 @@ async function getItemRequirementsFromRequirements(provider, requirements) {
     return itemRequirements;
 }
 
-const SDK_VERSION_MARKER = '0.28.6-alpha.1';
+const SDK_VERSION_MARKER = '0.28.7-alpha';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -33813,11 +33896,7 @@ class Checkout {
     async connect(params) {
         const web3Provider = await validateProvider(this.config, params.provider, { allowUnsupportedProvider: true });
         await connectSite(web3Provider);
-        const networkInfo = await getNetworkInfo(this.config, web3Provider);
-        return {
-            provider: web3Provider,
-            network: networkInfo,
-        };
+        return { provider: web3Provider };
     }
     /**
      * Switches the network for the current wallet provider.

package/dist/passport.d.ts

@@ -9732,6 +9732,12 @@ interface IMXProvider {
      * @return {Promise<RegisterUserResponse>} Returns a promise that resolves with the user registration response
      */
     registerOffchain(): Promise<RegisterUserResponse>;
+    /**
+     *  Checks if a User is registered off-chain
+     *
+     *  @return {Promise<boolean>} Returns a promise that resolves with true if the User is registered with IMX, false otherwise
+     */
+    isRegisteredOffchain(): Promise<boolean>;
     /**
      * Checks if a User is registered on-chain
      *
@@ -10184,7 +10190,7 @@ type UserProfile = {
 };
 declare enum Networks {
     PRODUCTION = "mainnet",
-    SANDBOX = "goerli"
+    SANDBOX = "sepolia"
 }
 interface OidcConfiguration {
     clientId: string;

package/dist/passport.js

@@ -2072,7 +2072,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.28.6-alpha.1' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.28.7-alpha' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -2128,7 +2128,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.28.6-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-0.28.7-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -7056,39 +7056,63 @@ class AuthManager {
     }
 }
 
+const lazyLoad = (promiseToAwait, initialiseFunction) => (promiseToAwait().then(initialiseFunction));
+const lazyDocumentReady = (initialiseFunction) => {
+    const documentReadyPromise = () => new Promise((resolve) => {
+        if (window.document.readyState === 'complete') {
+            resolve();
+        }
+        else {
+            const onReadyStateChange = () => {
+                if (window.document.readyState === 'complete') {
+                    resolve();
+                    window.document.removeEventListener('readystatechange', onReadyStateChange);
+                }
+            };
+            window.document.addEventListener('readystatechange', onReadyStateChange);
+        }
+    });
+    return lazyLoad(documentReadyPromise, initialiseFunction);
+};
+
 class MagicAdapter {
     config;
-    magicClient;
+    lazyMagicClient;
     constructor(config) {
         this.config = config;
         if (typeof window !== 'undefined') {
-            this.magicClient = this.initMagicClient();
-            this.magicClient.preload();
+            this.lazyMagicClient = lazyDocumentReady(() => {
+                const client = new Magic(this.config.magicPublishableApiKey, {
+                    extensions: [new OpenIdExtension()],
+                    network: this.config.network,
+                });
+                client.preload();
+                return client;
+            });
+        }
+    }
+    get magicClient() {
+        if (!this.lazyMagicClient) {
+            throw new Error('Cannot perform this action outside of the browser');
         }
+        return this.lazyMagicClient;
     }
     async login(idToken) {
         return withPassportError(async () => {
-            if (!this.magicClient) {
-                this.magicClient = this.initMagicClient();
-            }
-            await this.magicClient.openid.loginWithOIDC({
+            const magicClient = await this.magicClient;
+            await magicClient.openid.loginWithOIDC({
                 jwt: idToken,
                 providerId: this.config.magicProviderId,
             });
-            return this.magicClient.rpcProvider;
+            return magicClient.rpcProvider;
         }, PassportErrorType.WALLET_CONNECTION_ERROR);
     }
     async logout() {
-        if (this.magicClient?.user) {
-            await this.magicClient.user.logout();
+        const magicClient = await this.magicClient;
+        if (magicClient.user) {
+            await magicClient.user.logout();
         }
     }
-    initMagicClient() {
-        return new Magic(this.config.magicPublishableApiKey, {
-            extensions: [new OpenIdExtension()],
-            network: this.config.network,
-        });
-    }
 }
 
 const getStarkSigner = async (signer) => withPassportError(async () => {
@@ -7315,7 +7339,7 @@ var PassportEvents;
 var Networks;
 (function (Networks) {
     Networks["PRODUCTION"] = "mainnet";
-    Networks["SANDBOX"] = "goerli";
+    Networks["SANDBOX"] = "sepolia";
 })(Networks || (Networks = {}));
 
 async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
@@ -7664,6 +7688,11 @@ class PassportImxProvider {
     }
     // TODO: Remove once implemented
     // eslint-disable-next-line class-methods-use-this
+    isRegisteredOffchain() {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    // TODO: Remove once implemented
+    // eslint-disable-next-line class-methods-use-this
     isRegisteredOnchain() {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
@@ -7757,7 +7786,17 @@ class PassportImxProviderFactory {
         this.passportEventEmitter = passportEventEmitter;
     }
     async getProvider() {
-        const user = await this.authManager.loginSilent() || await this.authManager.login();
+        let user = null;
+        try {
+            user = await this.authManager.loginSilent();
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.warn(e);
+        }
+        if (!user) {
+            user = await this.authManager.login();
+        }
         return this.createProviderInstance(user);
     }
     async getProviderSilent() {
@@ -8812,7 +8851,14 @@ class Passport {
      */
     async login(options) {
         const { useCachedSession = false } = options || {};
-        let user = await this.authManager.loginSilent();
+        let user = null;
+        try {
+            user = await this.authManager.loginSilent();
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.warn('loginSilent failed with error:', error);
+        }
         if (!user && !useCachedSession) {
             user = await this.authManager.login();
         }

package/dist/provider.d.ts

@@ -833,6 +833,12 @@ interface IMXProvider {
      * @return {Promise<RegisterUserResponse>} Returns a promise that resolves with the user registration response
      */
     registerOffchain(): Promise<RegisterUserResponse>;
+    /**
+     *  Checks if a User is registered off-chain
+     *
+     *  @return {Promise<boolean>} Returns a promise that resolves with true if the User is registered with IMX, false otherwise
+     */
+    isRegisteredOffchain(): Promise<boolean>;
     /**
      * Checks if a User is registered on-chain
      *
@@ -910,6 +916,7 @@ declare class GenericIMXProvider implements IMXProvider {
     private readonly signers;
     constructor(config: ProviderConfiguration$1, ethSigner: Signer, starkSigner: StarkSigner);
     getAddress(): Promise<string>;
+    isRegisteredOffchain(): Promise<boolean>;
     registerOffchain(): Promise<RegisterUserResponse>;
     batchNftTransfer(request: Array<NftTransferDetails>): Promise<CreateTransferResponse>;
     cancelOrder(request: GetSignableCancelOrderRequest): Promise<CancelOrderResponse>;