@imtbl/sdk 0.34.1-alpha → 0.35.1

package/dist/index.cjs

@@ -3791,7 +3791,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.34.1-alpha' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.35.1' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3851,7 +3851,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.34.1-alpha',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.35.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4262,7 +4262,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.34.1-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.35.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -11720,14 +11720,24 @@ var FailedOrderCancellation;
 /* eslint-disable */
 var Fee;
 (function (Fee) {
-    (function (fee_type) {
-        fee_type["ROYALTY"] = "ROYALTY";
-        fee_type["MAKER_ECOSYSTEM"] = "MAKER_ECOSYSTEM";
-        fee_type["TAKER_ECOSYSTEM"] = "TAKER_ECOSYSTEM";
-        fee_type["PROTOCOL"] = "PROTOCOL";
-    })(Fee.fee_type || (Fee.fee_type = {}));
+    (function (type) {
+        type["ROYALTY"] = "ROYALTY";
+        type["MAKER_ECOSYSTEM"] = "MAKER_ECOSYSTEM";
+        type["TAKER_ECOSYSTEM"] = "TAKER_ECOSYSTEM";
+        type["PROTOCOL"] = "PROTOCOL";
+    })(Fee.type || (Fee.type = {}));
 })(Fee || (Fee = {}));
 
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+var Order;
+(function (Order) {
+    (function (type) {
+        type["LISTING"] = "LISTING";
+    })(Order.type || (Order.type = {}));
+})(Order || (Order = {}));
+
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
@@ -11780,14 +11790,14 @@ var ActionType;
 
 function mapFromOpenApiOrder(order) {
     const buyItems = order.buy.map((item) => {
-        if (item.item_type === 'ERC20') {
+        if (item.type === 'ERC20') {
             return {
                 type: 'ERC20',
                 contractAddress: item.contract_address,
                 amount: item.amount,
             };
         }
-        if (item.item_type === 'NATIVE') {
+        if (item.type === 'NATIVE') {
             return {
                 type: 'NATIVE',
                 amount: item.amount,
@@ -11796,7 +11806,7 @@ function mapFromOpenApiOrder(order) {
         throw new Error('Buy items must be either ERC20 or NATIVE');
     });
     const sellItems = order.sell.map((item) => {
-        if (item.item_type === 'ERC721') {
+        if (item.type === 'ERC721') {
             return {
                 type: 'ERC721',
                 contractAddress: item.contract_address,
@@ -11807,20 +11817,22 @@ function mapFromOpenApiOrder(order) {
     });
     return {
         id: order.id,
+        type: order.type,
         accountAddress: order.account_address,
         buy: buyItems,
         sell: sellItems,
         fees: order.fees.map((fee) => ({
             amount: fee.amount,
-            recipient: fee.recipient,
-            type: fee.fee_type,
+            recipientAddress: fee.recipient_address,
+            type: fee.type,
         })),
         chain: order.chain,
         createdAt: order.created_at,
         endAt: order.end_at,
+        orderHash: order.order_hash,
         protocolData: {
-            counter: order.protocol_data.counter,
             orderType: order.protocol_data.order_type,
+            counter: order.protocol_data.counter,
             seaportAddress: order.protocol_data.seaport_address,
             seaportVersion: order.protocol_data.seaport_version,
             zoneAddress: order.protocol_data.zone_address,
@@ -11834,14 +11846,14 @@ function mapFromOpenApiOrder(order) {
 }
 function mapFromOpenApiTrade(trade) {
     const buyItems = trade.buy.map((item) => {
-        if (item.item_type === 'ERC20') {
+        if (item.type === 'ERC20') {
             return {
                 type: 'ERC20',
                 contractAddress: item.contract_address,
                 amount: item.amount,
             };
         }
-        if (item.item_type === 'NATIVE') {
+        if (item.type === 'NATIVE') {
             return {
                 type: 'NATIVE',
                 amount: item.amount,
@@ -11850,7 +11862,7 @@ function mapFromOpenApiTrade(trade) {
         throw new Error('Buy items must be either ERC20 or NATIVE');
     });
     const sellItems = trade.sell.map((item) => {
-        if (item.item_type === 'ERC721') {
+        if (item.type === 'ERC721') {
             return {
                 type: 'ERC721',
                 contractAddress: item.contract_address,
@@ -11866,8 +11878,8 @@ function mapFromOpenApiTrade(trade) {
         sell: sellItems,
         buyerFees: trade.buyer_fees.map((fee) => ({
             amount: fee.amount,
-            recipient: fee.recipient,
-            type: fee.fee_type,
+            recipientAddress: fee.recipient_address,
+            type: fee.type,
         })),
         chain: trade.chain,
         indexedAt: trade.indexed_at,
@@ -11981,7 +11993,7 @@ chainId) {
 
 function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress) {
     const considerationItems = order.buy.map((buyItem) => {
-        switch (buyItem.item_type) {
+        switch (buyItem.type) {
             case 'NATIVE':
                 return {
                     startAmount: buyItem.amount,
@@ -12013,9 +12025,9 @@ function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress)
     });
     const fees = order.fees.map((fee) => ({
         amount: fee.amount,
-        itemType: order.buy[0].item_type === 'ERC20' ? ItemType$1.ERC20 : ItemType$1.NATIVE,
-        recipient: fee.recipient,
-        token: order.buy[0].item_type === 'ERC20'
+        itemType: order.buy[0].type === 'ERC20' ? ItemType$1.ERC20 : ItemType$1.NATIVE,
+        recipient: fee.recipient_address,
+        token: order.buy[0].type === 'ERC20'
             ? order.buy[0].contract_address
             : ethers.constants.AddressZero,
         identifierOrCriteria: '0',
@@ -12307,11 +12319,10 @@ class ImmutableApiClient {
         return this.orderbookService.createListing({
             chainName: this.chainName,
             requestBody: {
-                order_hash: orderHash,
                 account_address: orderComponents.offerer,
                 buy: [
                     {
-                        item_type: Number(orderComponents.consideration[0].itemType)
+                        type: Number(orderComponents.consideration[0].itemType)
                             === ItemType$1.NATIVE
                             ? 'NATIVE'
                             : 'ERC20',
@@ -12321,10 +12332,11 @@ class ImmutableApiClient {
                 ],
                 fees: makerFees.map((x) => ({
                     amount: x.amount,
-                    fee_type: FeeType.MAKER_ECOSYSTEM,
-                    recipient: x.recipient,
+                    type: FeeType.MAKER_ECOSYSTEM,
+                    recipient_address: x.recipientAddress,
                 })),
                 end_at: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
+                order_hash: orderHash,
                 protocol_data: {
                     order_type: ProtocolData.order_type.FULL_RESTRICTED,
                     zone_address: orderComponents.zone,
@@ -12337,7 +12349,7 @@ class ImmutableApiClient {
                     {
                         contract_address: orderComponents.offer[0].token,
                         token_id: orderComponents.offer[0].identifierOrCriteria,
-                        item_type: 'ERC721',
+                        type: 'ERC721',
                     },
                 ],
                 signature: orderSignature,
@@ -12370,8 +12382,8 @@ function getOrderbookConfig(environment) {
     switch (environment) {
         case Environment$1.SANDBOX:
             return {
-                seaportContractAddress: '0x2CFA8f64e1B49A2DF28532D1D30Cda45117cF778',
-                zoneContractAddress: '0x1Bb4Fb11Ba021Bd0104F0Ee8E5F5c728Bc83d7F1',
+                seaportContractAddress: '0x3A0C2Ba54D6CBd3121F01b96dFd20e99D1696C9D',
+                zoneContractAddress: '0x2EA937879beeF3393853A74Ad62F9ad7DA0B9E81',
                 apiEndpoint: 'https://api.sandbox.immutable.com',
                 chainName: TESTNET_CHAIN_NAME,
                 provider: new ethers.providers.JsonRpcProvider('https://rpc.testnet.immutable.com'),
@@ -12534,8 +12546,8 @@ class Orderbook {
                 order_id: listingId,
                 fees: takerFees.map((fee) => ({
                     amount: fee.amount,
-                    fee_type: FeeType.TAKER_ECOSYSTEM,
-                    recipient: fee.recipient,
+                    type: FeeType.TAKER_ECOSYSTEM,
+                    recipient_address: fee.recipientAddress,
                 })),
             },
         ]);
@@ -12557,8 +12569,8 @@ class Orderbook {
             order_id: listingRequest.listingId,
             fees: listingRequest.takerFees.map((fee) => ({
                 amount: fee.amount,
-                fee_type: FeeType.TAKER_ECOSYSTEM,
-                recipient: fee.recipient,
+                type: FeeType.TAKER_ECOSYSTEM,
+                recipient_address: fee.recipientAddress,
             })),
         })));
         try {
@@ -28427,7 +28439,6 @@ class UniswapV3Pool__factory extends ethers.ContractFactory {
     }
 }
 
-const DEFAULT_GAS_QUOTE = 2000000;
 // TODO: Better description of function and args
 async function multicallSingleCallDataMultipleContracts(multicallContract, functionName, addresses) {
     // Encode args - generate calldata for contract
@@ -28449,22 +28460,6 @@ async function multicallSingleCallDataMultipleContracts(multicallContract, funct
     }
     return multicallContract.callStatic.multicall(calls);
 }
-// TODO: Better description of function and args
-async function multicallMultipleCallDataSingContract(multicallContract, calldata, address, options) {
-    // Create call objects
-    const calls = new Array(calldata.length);
-    // TODO: use object.keys of something similar to avoid iterating over
-    // entire object prototype
-    // eslint-disable-next-line no-restricted-syntax, guard-for-in
-    for (const i in calldata) {
-        calls[i] = {
-            target: address,
-            callData: calldata[i],
-            gasLimit: options?.gasRequired ?? DEFAULT_GAS_QUOTE,
-        };
-    }
-    return multicallContract.callStatic.multicall(calls);
-}
 const getCallData = (methodName, contractInterface) => {
     // Create ethers function fragment
     const fragment = contractInterface?.getFunction(methodName);
@@ -28624,35 +28619,27 @@ const getDefaultDeadlineSeconds = () => Math.floor(Date.now() / 1000) + DEFAULT_
 
 const amountIndex = 0;
 const gasEstimateIndex = 3;
-async function getQuotesForRoutes(multicallContract, quoterContractAddress, routes, amountSpecified, tradeType) {
-    const callData = routes.map((route) => v3Sdk.SwapQuoter.quoteCallParameters(route, toCurrencyAmount(amountSpecified), tradeType, {
+async function getQuotesForRoutes(provider, quoterContractAddress, routes, amountSpecified, tradeType) {
+    const callDatas = routes.map((route) => v3Sdk.SwapQuoter.quoteCallParameters(route, toCurrencyAmount(amountSpecified), tradeType, {
         useQuoterV2: true,
     }).calldata);
-    let quoteResults;
-    try {
-        quoteResults = await multicallMultipleCallDataSingContract(multicallContract, callData, quoterContractAddress);
-    }
-    catch (e) {
-        const message = e instanceof Error ? e.message : 'Unknown Error';
-        throw new ProviderCallError(`failed multicall: ${message}`);
-    }
-    const decodedQuoteResults = [];
-    // TODO: for..in loops iterate over the entire prototype chain,
-    // Use Object.{keys,values,entries}, and iterate over the resulting array.
-    // eslint-disable-next-line no-restricted-syntax, guard-for-in
-    for (const i in quoteResults.returnData) {
-        const functionSig = callData[i].substring(0, 10);
+    const promises = await Promise.allSettled(callDatas.map((data) => provider.send('eth_call', [
+        { to: quoterContractAddress, data }, 'latest',
+    ])));
+    const decodedQuoteResults = promises.reduce((quoteResults, promiseResult, i) => {
+        if (promiseResult.status === 'rejected')
+            return quoteResults;
+        const functionSig = callDatas[i].substring(0, 10);
         const returnTypes = quoteReturnMapping[functionSig];
         if (!returnTypes) {
             throw new Error('No quoting function signature found');
         }
-        if (quoteResults.returnData[i].returnData === '0x') {
+        if (promiseResult.value === '0x') {
             // There is no quote result for the swap using this route, so don't include it in results
-            // eslint-disable-next-line no-continue
-            continue;
+            return quoteResults;
         }
         try {
-            const decodedQuoteResult = ethers.ethers.utils.defaultAbiCoder.decode(returnTypes, quoteResults.returnData[i].returnData);
+            const decodedQuoteResult = ethers.utils.defaultAbiCoder.decode(returnTypes, promiseResult.value);
             if (decodedQuoteResult) {
                 // The 0th element in each decoded data is going to be the amountOut or amountIn.
                 const quoteAmount = decodedQuoteResult[amountIndex];
@@ -28660,11 +28647,11 @@ async function getQuotesForRoutes(multicallContract, quoterContractAddress, rout
                     throw new Error('Expected BigNumber');
                 const input = uniswapTokenToERC20(routes[i].input);
                 const output = uniswapTokenToERC20(routes[i].output);
-                decodedQuoteResults.push({
+                quoteResults.push({
                     route: routes[i],
                     amountIn: tradeType === Uniswap.TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, input),
                     amountOut: tradeType === Uniswap.TradeType.EXACT_INPUT ? newAmount(quoteAmount, output) : amountSpecified,
-                    gasEstimate: ethers.ethers.BigNumber.from(decodedQuoteResult[gasEstimateIndex]),
+                    gasEstimate: ethers.BigNumber.from(decodedQuoteResult[gasEstimateIndex]),
                     tradeType,
                 });
             }
@@ -28674,7 +28661,8 @@ async function getQuotesForRoutes(multicallContract, quoterContractAddress, rout
             // Other quotes for routes may still succeed, so do nothing
             // and continue processing
         }
-    }
+        return quoteResults;
+    }, new Array());
     return decodedQuoteResults;
 }
 
@@ -28802,19 +28790,24 @@ const fetchValidPools = async (multicallContract, erc20Pair, commonRoutingERC20s
 
 class Router {
     provider;
+    multicallContract;
     routingTokens;
     routingContracts;
-    constructor(provider, routingTokens, routingContracts) {
+    constructor(provider, multicallContract, routingTokens, routingContracts) {
         this.provider = provider;
+        this.multicallContract = multicallContract;
+        this.routingTokens = routingTokens;
+        this.routingContracts = routingContracts;
+        this.provider = provider;
+        this.multicallContract = multicallContract;
         this.routingTokens = routingTokens;
         this.routingContracts = routingContracts;
     }
     async findOptimalRoute(amountSpecified, otherToken, tradeType, maxHops = 2) {
         const [tokenIn, tokenOut] = this.determineERC20InAndERC20Out(tradeType, amountSpecified, otherToken);
-        const multicallContract = Multicall__factory.connect(this.routingContracts.multicallAddress, this.provider);
         const erc20Pair = [tokenIn, tokenOut];
         // Get all pools and use these to get all possible routes.
-        const pools = await fetchValidPools(multicallContract, erc20Pair, this.routingTokens, this.routingContracts.factoryAddress);
+        const pools = await fetchValidPools(this.multicallContract, erc20Pair, this.routingTokens, this.routingContracts.coreFactory);
         const noValidPools = pools.length === 0;
         if (noValidPools) {
             throw new NoRoutesAvailableError();
@@ -28828,10 +28821,10 @@ class Router {
             throw new NoRoutesAvailableError();
         }
         // Get the best quote from all of the given routes
-        return await this.getBestQuoteFromRoutes(multicallContract, routes, amountSpecified, tradeType);
+        return await this.getBestQuoteFromRoutes(routes, amountSpecified, tradeType);
     }
-    async getBestQuoteFromRoutes(multicallContract, routes, amountSpecified, tradeType) {
-        const quotes = await getQuotesForRoutes(multicallContract, this.routingContracts.quoterAddress, routes, amountSpecified, tradeType);
+    async getBestQuoteFromRoutes(routes, amountSpecified, tradeType) {
+        const quotes = await getQuotesForRoutes(this.provider, this.routingContracts.quoterV2, routes, amountSpecified, tradeType);
         if (quotes.length === 0) {
             throw new NoRoutesAvailableError();
         }
@@ -29560,6 +29553,7 @@ const toPublicQuote = (amount, amountWithMaxSlippage, slippage, fees) => ({
 });
 class Exchange {
     provider;
+    batchProvider;
     router;
     chainId;
     nativeToken;
@@ -29577,12 +29571,16 @@ class Exchange {
         this.secondaryFees = config.secondaryFees;
         this.routerContractAddress = config.chain.contracts.peripheryRouter;
         this.secondaryFeeContractAddress = config.chain.contracts.secondaryFee;
-        this.provider = new ethers.ethers.providers.JsonRpcProvider(config.chain.rpcUrl);
-        this.router = new Router(this.provider, config.chain.commonRoutingTokens, {
-            multicallAddress: config.chain.contracts.multicall,
-            factoryAddress: config.chain.contracts.coreFactory,
-            quoterAddress: config.chain.contracts.quoterV2,
-        });
+        this.provider = new ethers.ethers.providers.StaticJsonRpcProvider({
+            url: config.chain.rpcUrl,
+            skipFetchSetup: true,
+        }, config.chain.chainId);
+        this.batchProvider = new ethers.ethers.providers.JsonRpcBatchProvider({
+            url: config.chain.rpcUrl,
+            skipFetchSetup: true,
+        }, config.chain.chainId);
+        const multicallContract = Multicall__factory.connect(config.chain.contracts.multicall, this.provider);
+        this.router = new Router(this.batchProvider, multicallContract, config.chain.commonRoutingTokens, config.chain.contracts);
     }
     static validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress) {
         assert(isValidNonZeroAddress(fromAddress), new InvalidAddressError('invalid from address'));
@@ -29594,11 +29592,11 @@ class Exchange {
         assert(slippagePercent <= 50, new InvalidSlippageError('slippage percent must be less than or equal to 50'));
         assert(slippagePercent >= 0, new InvalidSlippageError('slippage percent must be greater than or equal to 0'));
     }
-    async getSecondaryFees() {
+    async getSecondaryFees(provider) {
         if (this.secondaryFees.length === 0) {
             return [];
         }
-        const secondaryFeeContract = SecondaryFee__factory.connect(this.secondaryFeeContractAddress, this.provider);
+        const secondaryFeeContract = SecondaryFee__factory.connect(this.secondaryFeeContractAddress, provider);
         if (await secondaryFeeContract.paused()) {
             // Do not use secondary fees if the contract is paused
             return [];
@@ -29619,11 +29617,13 @@ class Exchange {
     async getUnsignedSwapTx(fromAddress, tokenInLiteral, tokenOutLiteral, amount, slippagePercent, maxHops, deadline, tradeType) {
         Exchange.validate(tokenInLiteral, tokenOutLiteral, maxHops, slippagePercent, fromAddress);
         // get the decimals of the tokens that will be swapped
-        const [tokenInDecimals, tokenOutDecimals, secondaryFees] = await Promise.all([
-            getTokenDecimals(tokenInLiteral, this.provider, this.nativeToken),
-            getTokenDecimals(tokenOutLiteral, this.provider, this.nativeToken),
-            this.getSecondaryFees(),
-        ]);
+        const promises = [
+            getTokenDecimals(tokenInLiteral, this.batchProvider, this.nativeToken),
+            getTokenDecimals(tokenOutLiteral, this.batchProvider, this.nativeToken),
+            this.getSecondaryFees(this.batchProvider),
+            fetchGasPrice(this.batchProvider, this.nativeToken),
+        ];
+        const [tokenInDecimals, tokenOutDecimals, secondaryFees, gasPrice] = await Promise.all(promises);
         const tokenIn = this.parseTokenLiteral(tokenInLiteral, tokenInDecimals);
         const tokenOut = this.parseTokenLiteral(tokenOutLiteral, tokenOutDecimals);
         // determine which amount was specified for the swap from the TradeType
@@ -29632,10 +29632,7 @@ class Exchange {
         const fees = new Fees(secondaryFees, tokenIn);
         const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType, this.nativeTokenService);
         // Quotes will always use ERC20s. If the user-specified token is Native, we use the Wrapped Native Token pool
-        const [ourQuote, gasPrice] = await Promise.all([
-            this.router.findOptimalRoute(ourQuoteReqAmount, this.nativeTokenService.maybeWrapToken(otherToken), tradeType, maxHops),
-            fetchGasPrice(this.provider, this.nativeToken),
-        ]);
+        const ourQuote = await this.router.findOptimalRoute(ourQuoteReqAmount, this.nativeTokenService.maybeWrapToken(otherToken), tradeType, maxHops);
         const adjustedQuote = adjustQuoteWithFees(ourQuote, amountSpecified, fees, this.nativeTokenService);
         const swap = getSwap(tokenIn, tokenOut, adjustedQuote, fromAddress, slippagePercent, deadline, this.routerContractAddress, this.secondaryFeeContractAddress, gasPrice, secondaryFees);
         const { quotedAmount, quotedAmountWithMaxSlippage } = prepareUserQuote(this.nativeTokenService, adjustedQuote, slippagePercent, otherToken);
@@ -30572,7 +30569,7 @@ const GAS_OVERRIDES = {
     maxPriorityFeePerGas: ethers.BigNumber.from(101e9),
 };
 
-const SDK_VERSION_MARKER = '0.34.1-alpha';
+const SDK_VERSION_MARKER = '0.35.1';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -33603,7 +33600,7 @@ const calculateFees = (orderFees, weiAmount, decimals = 18) => {
         if (currentFeeBn.gt(0)) {
             calculateFeesResult.push({
                 amount: currentFeeBn.toString(),
-                recipient: orderFee.recipient,
+                recipientAddress: orderFee.recipient,
             });
         }
     } // for

package/dist/index.d.ts

@@ -14919,17 +14919,17 @@ type Fee$2 = {
     /**
      * Fee type
      */
-    fee_type: Fee$2.fee_type;
+    type: Fee$2.type;
     /**
      * Wallet address of fee recipient
      */
-    recipient: string;
+    recipient_address: string;
 };
 declare namespace Fee$2 {
     /**
      * Fee type
      */
-    enum fee_type {
+    enum type {
         ROYALTY = "ROYALTY",
         MAKER_ECOSYSTEM = "MAKER_ECOSYSTEM",
         TAKER_ECOSYSTEM = "TAKER_ECOSYSTEM",
@@ -14937,17 +14937,36 @@ declare namespace Fee$2 {
     }
 }
 
+type ERC1155Item = {
+    /**
+     * Token type user is offering, which in this case is ERC1155
+     */
+    type: 'ERC1155';
+    /**
+     * Address of ERC1155 token
+     */
+    contract_address: string;
+    /**
+     * ID of ERC1155 token
+     */
+    token_id: string;
+    /**
+     * A string representing the price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
+     */
+    amount: string;
+};
+
 type ERC20Item$1 = {
     /**
      * Token type user is offering, which in this case is ERC20
      */
-    item_type: 'ERC20';
+    type: 'ERC20';
     /**
      * Address of ERC20 token
      */
     contract_address: string;
     /**
-     * A string representing the starting price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
+     * A string representing the price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
      */
     amount: string;
 };
@@ -14956,7 +14975,7 @@ type ERC721Item$1 = {
     /**
      * Token type user is offering, which in this case is ERC721
      */
-    item_type: 'ERC721';
+    type: 'ERC721';
     /**
      * Address of ERC721 token
      */
@@ -14971,28 +14990,28 @@ type NativeItem$1 = {
     /**
      * Token type user is offering, which in this case is the native IMX token
      */
-    item_type: 'NATIVE';
+    type: 'NATIVE';
     /**
-     * A string representing the starting price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
+     * A string representing the price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
      */
     amount: string;
 };
 
-type Item = (NativeItem$1 | ERC20Item$1 | ERC721Item$1);
+type Item = (NativeItem$1 | ERC20Item$1 | ERC721Item$1 | ERC1155Item);
 
 type ProtocolData = {
     /**
-     * The Order type
+     * Seaport order type
      */
     order_type: ProtocolData.order_type;
-    /**
-     * Immutable zone address
-     */
-    zone_address: string;
     /**
      * big.Int or uint256 string for order counter
      */
     counter: string;
+    /**
+     * Immutable zone address
+     */
+    zone_address: string;
     /**
      * Immutable Seaport contract address
      */
@@ -15004,7 +15023,7 @@ type ProtocolData = {
 };
 declare namespace ProtocolData {
     /**
-     * The Order type
+     * Seaport order type
      */
     enum order_type {
         FULL_RESTRICTED = "FULL_RESTRICTED"
@@ -15156,6 +15175,7 @@ type Order$1 = {
      * Global Order identifier
      */
     id: string;
+    order_hash: string;
     protocol_data: ProtocolData;
     /**
      * A random value added to the create Order request
@@ -15171,11 +15191,23 @@ type Order$1 = {
      */
     start_at: string;
     status: OrderStatus;
+    /**
+     * Order type
+     */
+    type: Order$1.type;
     /**
      * Time the Order is last updated
      */
     updated_at: string;
 };
+declare namespace Order$1 {
+    /**
+     * Order type
+     */
+    enum type {
+        LISTING = "LISTING"
+    }
+}
 
 type FulfillableOrder = {
     extra_data: string;
@@ -15538,7 +15570,7 @@ declare enum FeeType {
     ROYALTY = "ROYALTY"
 }
 interface FeeValue {
-    recipient: string;
+    recipientAddress: string;
     amount: string;
 }
 interface Fee$1 extends FeeValue {
@@ -15608,6 +15640,7 @@ interface CancelOrdersOnChainResponse {
 }
 interface Order {
     id: string;
+    type: 'LISTING';
     accountAddress: string;
     buy: (ERC20Item | NativeItem)[];
     sell: ERC721Item[];
@@ -15626,6 +15659,7 @@ interface Order {
      * Time after which the Order is expired
      */
     endAt: string;
+    orderHash: string;
     protocolData: {
         orderType: 'FULL_RESTRICTED';
         zoneAddress: string;