@imtbl/sdk 0.28.4 → 0.28.5

package/dist/index.cjs

@@ -3651,7 +3651,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.28.4' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.28.5' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3711,7 +3711,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.28.4',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.28.5',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4122,7 +4122,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.28.4',
+    sdkVersion: 'ts-immutable-sdk-0.28.5',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -9067,39 +9067,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 magicSdk.Magic(this.config.magicPublishableApiKey, {
+                    extensions: [new oidc.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 magicSdk.Magic(this.config.magicPublishableApiKey, {
-            extensions: [new oidc.OpenIdExtension()],
-            network: this.config.network,
-        });
-    }
 }
 
 const getStarkSigner = async (signer) => withPassportError(async () => {
@@ -9326,7 +9350,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, }) {
@@ -9675,6 +9699,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);
     }
@@ -12671,6 +12700,22 @@ async function registerOffchain(signers, config) {
     });
     return registeredUser.data;
 }
+async function isRegisteredOffchain(ethAddress, config) {
+    try {
+        const usersApi = new coreSdk.UsersApi(config.immutableXConfig.apiConfiguration);
+        const getUsersResult = await usersApi.getUsers({
+            user: ethAddress,
+        });
+        const { accounts } = getUsersResult.data;
+        return accounts?.length > 0;
+    }
+    catch (ex) {
+        if (ex instanceof globalAxios$1.AxiosError && ex.response?.status === 404) {
+            return false;
+        }
+        throw ex;
+    }
+}
 async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
     await validateChain(ethSigner, config.immutableXConfig);
     const registrationContract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
@@ -13206,7 +13251,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);
@@ -30399,6 +30448,7 @@ async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(web3Provider, walletAdd
 }
 // Blockscout client singleton per chain id
 const $1564e43dde50bb61$var$blockscoutClientMap = new Map();
+const $1564e43dde50bb61$export$be5483d07cfa803d = ()=>$1564e43dde50bb61$var$blockscoutClientMap.clear();
 const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId, filterTokens)=>{
     // Shuffle the mapping of the tokens configuration so it is a hashmap
     // for faster access to tokens config objects.
@@ -30500,6 +30550,8 @@ const $1564e43dde50bb61$export$a3238cee431627c6 = async (config, web3Provider, w
     };
 };
 const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, web3Provider, walletAddress, chainId)=>{
+    // eslint-disable-next-line no-param-reassign
+    chainId ||= await web3Provider.getSigner().getChainId();
     const { tokens: tokens } = await ($efe60cea83bfc4e8$export$473cec51305fdae8)(config, {
         type: ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ALL,
         chainId: chainId
@@ -30521,7 +30573,7 @@ const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, web3Provider, w
         // Please remove this hack once https://immutable.atlassian.net/browse/WT-1710
         // is done.
         const isL1Chain = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config) === chainId;
-        return ($458d407830d66110$export$5280dbcb91c8b391)(config, `Time to fetch balances using blockscout for ${chainId}`, $1564e43dde50bb61$export$8c978679845804d4(walletAddress, chainId, isL1Chain ? tokens : []));
+        return await ($458d407830d66110$export$5280dbcb91c8b391)(config, `Time to fetch balances using blockscout for ${chainId}`, $1564e43dde50bb61$export$8c978679845804d4(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
@@ -30892,6 +30944,7 @@ async function $2e7bf45a7c9a9570$export$942c8de7174809fc(params, readOnlyProvide
 
 
 
+
 const $ddc6bcd0896481e5$export$2fbfa41a4de56a89 = (erc20allowances, erc721allowances)=>{
     const aggregatedAllowances = [];
     if (!erc20allowances.sufficient) {
@@ -31198,7 +31251,7 @@ const $35c3fc7013888ba5$export$be546c525d418988 = async (provider, ownerAddress,
 
 
 
-/* eslint-disable arrow-body-style */ 
+
 
 
 
@@ -31391,17 +31444,14 @@ const $73d2282a108cc7e2$export$6ab9757fda54db7e = (itemRequirement, balances)=>{
 /**
  * Gets the balances for all NATIVE and ERC20 balance requirements.
  */ const $beb896e098e41faf$var$getTokenBalances = async (config, provider, ownerAddress, itemRequirements)=>{
-    let tokenBalances = [];
     try {
-        const tokenList = (0, $73d2282a108cc7e2$export$ed7929b58bab85da)(itemRequirements);
-        const { balances: balances } = await (0, $1564e43dde50bb61$export$a3238cee431627c6)(config, provider, ownerAddress, tokenList);
-        tokenBalances = [
-            ...balances.map((balance)=>balance)
-        ];
+        const tokenMap = new Map();
+        (0, $73d2282a108cc7e2$export$ed7929b58bab85da)(itemRequirements).forEach((item)=>tokenMap.set((item.address || "").toLocaleLowerCase(), item));
+        const { balances: balances } = await (0, $1564e43dde50bb61$export$fee49741664a4d7e)(config, provider, ownerAddress);
+        return balances.filter((balance)=>tokenMap.get((balance.token.address || "").toLocaleLowerCase()));
     } catch (error) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Failed to get balances", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_BALANCE_ERROR);
     }
-    return tokenBalances;
 };
 /**
  * Gets the balances for all ERC721 balance requirements.
@@ -31439,42 +31489,46 @@ const $73d2282a108cc7e2$export$6ab9757fda54db7e = (itemRequirement, balances)=>{
 };
 const $beb896e098e41faf$export$ddfc885f43c3cb6e = async (config, provider, ownerAddress, itemRequirements)=>{
     const aggregatedItems = ($aa6caea9a60d18c7$export$f96d1c819a615a64)(itemRequirements);
-    if (aggregatedItems.filter((itemRequirement)=>{
-        return itemRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721 && itemRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20 && itemRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
-    }).length > 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Unsupported item requirement balance check", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).UNSUPPORTED_BALANCE_REQUIREMENT_ERROR);
+    const requiredToken = [];
+    const requiredERC721 = [];
+    aggregatedItems.forEach((item)=>{
+        switch(item.type){
+            case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20:
+            case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE:
+                requiredToken.push(item);
+                break;
+            case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721:
+                requiredERC721.push(item);
+                break;
+        }
+    });
+    if (requiredERC721.length === 0 && requiredToken.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Unsupported item requirement balance check", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).UNSUPPORTED_BALANCE_REQUIREMENT_ERROR);
     // Get all ERC20 and NATIVE balances
-    const currentBalances = [];
-    const tokenItemRequirements = aggregatedItems.filter((itemRequirement)=>itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20 || itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE);
-    if (tokenItemRequirements.length > 0) currentBalances.push($beb896e098e41faf$var$getTokenBalances(config, provider, ownerAddress, aggregatedItems));
+    const balancePromises = [];
+    if (requiredToken.length > 0) balancePromises.push($beb896e098e41faf$var$getTokenBalances(config, provider, ownerAddress, aggregatedItems));
     // Get all ERC721 balances
-    const erc721ItemRequirements = aggregatedItems.filter((itemRequirement)=>itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721);
-    if (erc721ItemRequirements.length > 0) currentBalances.push($beb896e098e41faf$var$getERC721Balances(provider, ownerAddress, aggregatedItems));
+    if (requiredERC721.length > 0) balancePromises.push($beb896e098e41faf$var$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(($73d2282a108cc7e2$export$6ab9757fda54db7e)(tokenItemRequirement, tokenBalances));
-            });
-            if (erc721ItemRequirements.length > 0) {
-                const erc721Balances = balances[1];
-                erc721ItemRequirements.forEach((erc721ItemRequirement)=>{
-                    requirements.push(($73d2282a108cc7e2$export$9b757e40b19984c3)(erc721ItemRequirement, erc721Balances));
-                });
-            }
-        } else if (erc721ItemRequirements.length > 0) {
-            // Only erc721
-            const erc721Balances = balances[0];
-            erc721ItemRequirements.forEach((erc721ItemRequirement)=>{
-                requirements.push(($73d2282a108cc7e2$export$9b757e40b19984c3)(erc721ItemRequirement, erc721Balances));
-            });
-        }
-        return requirements;
-    });
-    const sufficient = balanceRequirements.reduce((acc, balanceRequirement)=>{
-        return acc && balanceRequirement.sufficient;
-    }, true);
+    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(($73d2282a108cc7e2$export$6ab9757fda54db7e)(item, result));
+        });
+    }
+    // Get all ERC721 balances
+    if (requiredERC721.length > 0 && promisesResponses.length > 0) {
+        const result = promisesResponses.shift();
+        if (result) requiredERC721.forEach((item)=>{
+            balanceRequirements.push(($73d2282a108cc7e2$export$9b757e40b19984c3)(item, result));
+        });
+    }
+    // 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: sufficient,
         balanceRequirements: balanceRequirements
@@ -32058,7 +32112,9 @@ const $15fe1c77041bd4f4$export$9e73e22953cebcfc = async (config, readOnlyProvide
 
 const $887d24b47765b1c0$export$c37d8687c27b9660 = "0x0000000000000000000000000000000000000001";
 const $887d24b47765b1c0$export$1430626eec86fce9 = (chainId)=>{
+    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_MAINNET) return "imtbl-zkevm-mainnet";
     if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET) return "imtbl-zkevm-testnet";
+    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_DEVNET) return "imtbl-zkevm-devent";
     return "";
 };
 const $887d24b47765b1c0$export$53e663abd9b77fc1 = async (chainId, config)=>{
@@ -32879,7 +32935,6 @@ const $a7367d01c6e76b1c$export$d62081fac18000c2 = (orderHash, orderComponents, a
 
 
 
-
 const $9051cee080948594$export$9ac1563efd38130 = 1; // 100%
 const $9051cee080948594$export$768e717351d4b176 = 6; // will allow 0.000001 (0.0001%) as the minimum value
 const $9051cee080948594$var$calculateFeesPercent = (orderFee, amountBn)=>{
@@ -32920,6 +32975,7 @@ const $9051cee080948594$export$1e69c9cfc42e28d8 = (orderFees, weiAmount, decimal
 
 
 
+
 const $64863c39386de592$export$4249179755829904 = (type, contractAddress, amount, spenderAddress)=>{
     switch(type){
         case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20:
@@ -32951,16 +33007,24 @@ const $64863c39386de592$export$8f2ff92ab8657f0b = (gasLimit, fulfillmentTransact
     };
 };
 const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, orders)=>{
-    let orderbook;
+    if (orders.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No orders were provided to the orders array. Please provide at least one order.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).FULFILL_ORDER_LISTING_ERROR);
     let order;
     let spenderAddress = "";
+    let decimals = 18;
     const gasLimit = (constants).estimatedFulfillmentGasGwei;
-    if (orders.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No orders were provided to the orders array. Please provide at least one order.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).FULFILL_ORDER_LISTING_ERROR);
+    const orderbook = $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
+    const blockchainClient = $67fc622a2b913d5f$export$436dd76f23f463ff(config);
+    const fulfillerAddress = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the address from the provider", provider.getSigner().getAddress());
+    // Prefetch balances and store them in memory
+    ($1564e43dde50bb61$export$be5483d07cfa803d)();
+    ($1564e43dde50bb61$export$fee49741664a4d7e)(config, provider, fulfillerAddress, ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
+    ($1564e43dde50bb61$export$fee49741664a4d7e)(config, provider, fulfillerAddress, ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
     const { id: id, takerFees: takerFees } = orders[0];
+    let orderChainName;
     try {
-        orderbook = $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
         order = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to fetch the listing from the orderbook", orderbook.getListing(id));
-        const { seaportContractAddress: seaportContractAddress } = orderbook.config();
+        const { seaportContractAddress: seaportContractAddress, chainName: chainName } = orderbook.config();
+        orderChainName = chainName;
         spenderAddress = seaportContractAddress;
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while getting the order listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ORDER_LISTING_ERROR, {
@@ -32973,10 +33037,12 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
         message: "No buy side tokens found on order"
     });
     const buyToken = order.result.buy[0];
-    let decimals = 18;
-    if (order.result.buy[0].type === "ERC20") {
-        const tokenContract = $06a6c5c23f7f2479$export$fbbc17f6e6e58544(order.result.buy[0].contractAddress, ($d85ad1457a3f1a83$export$db5daa1b5156ccfe), provider);
-        decimals = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get decimals of token contract for the buy token", tokenContract.decimals());
+    if (buyToken.type === "ERC20") {
+        const token = await ($458d407830d66110$export$5280dbcb91c8b391)(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) fees = ($9051cee080948594$export$1e69c9cfc42e28d8)(takerFees, buyToken.amount, decimals);
@@ -32985,7 +33051,6 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     let orderActions = [];
     const fulfillOrderStartTime = performance.now();
     try {
-        const fulfillerAddress = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the address from the provider", provider.getSigner().getAddress());
         const { actions: actions } = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to call fulfillOrder from the orderbook", orderbook.fulfillOrder(id, fulfillerAddress, fees));
         orderActions = actions;
         unsignedApprovalTransactions = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to construct the unsigned approval transactions", (0, $a7367d01c6e76b1c$export$f64a20a30eb98855)(actions));
@@ -33585,7 +33650,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.28.4";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.28.5";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 
@@ -33770,6 +33835,7 @@ $parcel$export($9b3189b6b155842e$exports, "SaleEventType", () => $9b3189b6b15584
     SaleEventType["SUCCESS"] = "success";
     SaleEventType["FAILURE"] = "failure";
     SaleEventType["REJECTED"] = "rejected";
+    SaleEventType["TRANSACTION_SUCCESS"] = "transaction-success";
 })($9b3189b6b155842e$export$881881ffb3bd733e || ($9b3189b6b155842e$export$881881ffb3bd733e = {}));
 
 

package/dist/index.d.ts

@@ -14422,6 +14422,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
      *
@@ -14499,6 +14505,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>;
@@ -14537,7 +14544,7 @@ type UserProfile = {
 };
 declare enum Networks {
     PRODUCTION = "mainnet",
-    SANDBOX = "goerli"
+    SANDBOX = "sepolia"
 }
 interface OidcConfiguration {
     clientId: string;
@@ -32173,11 +32180,12 @@ declare enum SaleEventType {
     CLOSE_WIDGET = "close-widget",
     SUCCESS = "success",
     FAILURE = "failure",
-    REJECTED = "rejected"
+    REJECTED = "rejected",
+    TRANSACTION_SUCCESS = "transaction-success"
 }
 /**
  * Represents a successful Sale transaction.
- * @property {string} transactionHash - The hash of the successful transaction.
+ * @property {Array} transactions - The executed transactions
  */
 type SaleSuccess = {
     transactions: {
@@ -32190,10 +32198,25 @@ type SaleSuccess = {
  * Type representing a Sale Widget with type FAILURE.
  * @property {string} reason - The reason why the swap failed.
  * @property {number} timestamp - The timestamp of the failed swap.
+ * @property {Array} transactions - The executed transactions
  */
 type SaleFailed = {
     reason: string;
     timestamp: number;
+    transactions: {
+        method: string;
+        hash: string | undefined;
+    }[];
+};
+/**
+ * Type representing a Sale Widget with type TRANSACTION_SUCCESS.
+ * @property {Object} transactions - The executed transactions
+ */
+type SaleTransactionSuccess = {
+    transactions: {
+        method: string;
+        hash: string | undefined;
+    }[];
 };
 /**
  * Enum representing the events emitted by the widgets.
@@ -32484,6 +32507,7 @@ type checkout_widgets_d_SaleEventType = SaleEventType;
 declare const checkout_widgets_d_SaleEventType: typeof SaleEventType;
 type checkout_widgets_d_SaleFailed = SaleFailed;
 type checkout_widgets_d_SaleSuccess = SaleSuccess;
+type checkout_widgets_d_SaleTransactionSuccess = SaleTransactionSuccess;
 type checkout_widgets_d_SemanticVersion = SemanticVersion;
 type checkout_widgets_d_SwapEventType = SwapEventType;
 declare const checkout_widgets_d_SwapEventType: typeof SwapEventType;
@@ -32538,6 +32562,7 @@ declare namespace checkout_widgets_d {
     checkout_widgets_d_SaleEventType as SaleEventType,
     checkout_widgets_d_SaleFailed as SaleFailed,
     checkout_widgets_d_SaleSuccess as SaleSuccess,
+    checkout_widgets_d_SaleTransactionSuccess as SaleTransactionSuccess,
     checkout_widgets_d_SemanticVersion as SemanticVersion,
     checkout_widgets_d_SwapEventType as SwapEventType,
     checkout_widgets_d_SwapFailed as SwapFailed,