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

package/dist/index.cjs

@@ -3649,7 +3649,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');
@@ -3709,7 +3709,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
@@ -4120,7 +4120,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
@@ -9065,39 +9065,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 () => {
@@ -9324,7 +9348,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, }) {
@@ -9673,6 +9697,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);
     }
@@ -9766,7 +9795,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() {
@@ -10821,7 +10860,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();
         }
@@ -12669,6 +12715,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);
@@ -13204,7 +13266,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);
@@ -29424,6 +29490,7 @@ var SaleEventType;
     SaleEventType["SUCCESS"] = "success";
     SaleEventType["FAILURE"] = "failure";
     SaleEventType["REJECTED"] = "rejected";
+    SaleEventType["TRANSACTION_SUCCESS"] = "transaction-success";
 })(SaleEventType || (SaleEventType = {}));
 
 /**
@@ -30592,6 +30659,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.
@@ -30692,6 +30762,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,
@@ -30714,7 +30786,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
@@ -31588,18 +31660,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.
@@ -31646,53 +31715,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,
@@ -32295,8 +32367,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.
@@ -33295,18 +33371,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) {
@@ -33322,10 +33406,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) {
@@ -33336,7 +33420,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));
@@ -33674,7 +33757,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;
 
@@ -33835,11 +33918,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/index.d.ts

@@ -14421,6 +14421,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
      *
@@ -14498,6 +14504,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>;
@@ -14536,7 +14543,7 @@ type UserProfile = {
 };
 declare enum Networks {
     PRODUCTION = "mainnet",
-    SANDBOX = "goerli"
+    SANDBOX = "sepolia"
 }
 interface OidcConfiguration {
     clientId: string;
@@ -16717,21 +16724,6 @@ type ChainTokensConfig = {
     blockscout?: boolean;
 };
 
-/**
- * Represents information about a network.
- * @interface NetworkInfo
- * @property {string} name - The name of the network.
- * @property {number} chainId - The chain ID of the network.
- * @property {TokenInfo} nativeCurrency - Information about the native currency of the network.
- * @property {boolean} isSupported - Indicates whether the network is supported.
- */
-interface NetworkInfo {
-    name: string;
-    chainId: number;
-    nativeCurrency: TokenInfo;
-    isSupported: boolean;
-}
-
 /**
  * Interface representing the params of {@link Checkout.connect}.
  * @property {Web3Provider} provider - The provider used to connect to the network.
@@ -16742,11 +16734,9 @@ interface ConnectParams {
 /**
  * Interface representing the result of {@link Checkout.connect}.
  * @property {Web3Provider} provider - The provider used to connect to the network.
- * @property {NetworkInfo} network - Information about the connected network.
  */
 interface ConnectResult {
     provider: Web3Provider;
-    network: NetworkInfo;
 }
 /**
  * Interface representing the params of {@link Checkout.checkIsWalletConnected}.
@@ -16838,6 +16828,21 @@ interface TokenAmountEstimate {
     token?: TokenInfo;
 }
 
+/**
+ * Represents information about a network.
+ * @interface NetworkInfo
+ * @property {string} name - The name of the network.
+ * @property {number} chainId - The chain ID of the network.
+ * @property {TokenInfo} nativeCurrency - Information about the native currency of the network.
+ * @property {boolean} isSupported - Indicates whether the network is supported.
+ */
+interface NetworkInfo {
+    name: string;
+    chainId: number;
+    nativeCurrency: TokenInfo;
+    isSupported: boolean;
+}
+
 /**
  * Interface representing the parameters for {@link Checkout.switchNetwork}.
  * @property {Web3Provider} provider - The provider to connect to the network.
@@ -17253,11 +17258,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: {
@@ -17270,10 +17276,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;
+    }[];
 };
 
 /**
@@ -17559,6 +17580,7 @@ type WidgetEventData = {
         [SaleEventType.FAILURE]: SaleFailed;
         [SaleEventType.REJECTED]: any;
         [SaleEventType.CLOSE_WIDGET]: {};
+        [SaleEventType.TRANSACTION_SUCCESS]: SaleTransactionSuccess;
     } & OrchestrationMapping & ProviderEventMapping;
 };
 /**
@@ -17991,6 +18013,7 @@ type checkout_sdk_d_ERC721ItemRequirement = ERC721ItemRequirement;
 type checkout_sdk_d_ErrorType = ErrorType;
 type checkout_sdk_d_ExchangeType = ExchangeType;
 declare const checkout_sdk_d_ExchangeType: typeof ExchangeType;
+type checkout_sdk_d_Fee = Fee;
 type checkout_sdk_d_FeePercentage = FeePercentage;
 type checkout_sdk_d_FeeToken = FeeToken;
 type checkout_sdk_d_FiatRampParams = FiatRampParams;
@@ -18066,6 +18089,7 @@ declare const checkout_sdk_d_SaleEventType: typeof SaleEventType;
 type checkout_sdk_d_SaleFailed = SaleFailed;
 type checkout_sdk_d_SaleItem = SaleItem;
 type checkout_sdk_d_SaleSuccess = SaleSuccess;
+type checkout_sdk_d_SaleTransactionSuccess = SaleTransactionSuccess;
 type checkout_sdk_d_SaleWidgetConfiguration = SaleWidgetConfiguration;
 type checkout_sdk_d_SaleWidgetParams = SaleWidgetParams;
 type checkout_sdk_d_SellOrder = SellOrder;
@@ -18173,6 +18197,7 @@ declare namespace checkout_sdk_d {
     checkout_sdk_d_ERC721ItemRequirement as ERC721ItemRequirement,
     checkout_sdk_d_ErrorType as ErrorType,
     checkout_sdk_d_ExchangeType as ExchangeType,
+    checkout_sdk_d_Fee as Fee,
     checkout_sdk_d_FeePercentage as FeePercentage,
     checkout_sdk_d_FeeToken as FeeToken,
     checkout_sdk_d_FiatRampParams as FiatRampParams,
@@ -18237,6 +18262,7 @@ declare namespace checkout_sdk_d {
     checkout_sdk_d_SaleFailed as SaleFailed,
     checkout_sdk_d_SaleItem as SaleItem,
     checkout_sdk_d_SaleSuccess as SaleSuccess,
+    checkout_sdk_d_SaleTransactionSuccess as SaleTransactionSuccess,
     checkout_sdk_d_SaleWidgetConfiguration as SaleWidgetConfiguration,
     checkout_sdk_d_SaleWidgetParams as SaleWidgetParams,
     checkout_sdk_d_SellOrder as SellOrder,