@imtbl/sdk 0.13.2-alpha → 0.14.0-alpha.1

package/dist/checkout_sdk.js

@@ -1,7 +1,7 @@
 import { ethers, ContractFactory, utils, Contract as Contract$1, BigNumber as BigNumber$1, providers, constants as constants$1 } from 'ethers';
 import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers';
 import $7v2Z6$metamaskdetectprovider from '@metamask/detect-provider';
-import { Token, TradeType, Percent, CurrencyAmount } from '@uniswap/sdk-core';
+import { TradeType, Token, Percent, CurrencyAmount } from '@uniswap/sdk-core';
 import assert from 'assert';
 import { BigNumber as BigNumber$2 } from '@ethersproject/bignumber';
 import { FeeAmount, Route, SwapQuoter, Pool, Trade, toHex as toHex$1, encodeRouteToPath } from '@uniswap/v3-sdk';
@@ -12897,20 +12897,12 @@ function applySlippage(tradeType, amount, slippage) {
     return ethers.BigNumber.from(amountWithSlippage.toString());
 }
 function prepareUserQuote(otherToken, tradeInfo, slippage, fees) {
-    const resultToken = otherToken.wrapped;
-    const tokenInfo = {
-        chainId: resultToken.chainId,
-        address: resultToken.address,
-        decimals: resultToken.decimals,
-        symbol: resultToken.symbol,
-        name: resultToken.name,
-    };
     const quote = getQuoteAmountFromTradeType(tradeInfo);
     const amountWithSlippage = applySlippage(tradeInfo.tradeType, quote.value, slippage);
     return {
         amount: quote,
         amountWithMaxSlippage: {
-            token: tokenInfo,
+            token: otherToken,
             value: amountWithSlippage,
         },
         slippage,
@@ -14931,13 +14923,6 @@ function isValidNonZeroAddress(address) {
     }
 }
 const tokenInfoToUniswapToken = (tokenInfo) => new Token(tokenInfo.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
-const uniswapTokenToTokenInfo = (token) => ({
-    chainId: token.chainId,
-    address: token.address,
-    decimals: token.decimals,
-    symbol: token.symbol,
-    name: token.name,
-});
 const toCurrencyAmount = (amount) => {
     const token = tokenInfoToUniswapToken(amount.token);
     return CurrencyAmount.fromRawAmount(token, amount.value.toString());
@@ -14998,6 +14983,7 @@ async function getQuotesForRoutes(multicallContract, quoterContractAddress, rout
                     amountIn: tradeType === TradeType.EXACT_INPUT ? amountSpecified : newAmount(quoteAmount, routes[i].input),
                     amountOut: tradeType === TradeType.EXACT_INPUT ? newAmount(quoteAmount, routes[i].output) : amountSpecified,
                     gasEstimate: ethers.BigNumber.from(decodedQuoteResult[gasEstimateIndex]),
+                    tradeType,
                 });
             }
         }
@@ -15160,14 +15146,7 @@ class Router {
             throw new NoRoutesAvailableError();
         }
         // Get the best quote from all of the given routes
-        const { amountIn, amountOut, gasEstimate, route, } = await this.getBestQuoteFromRoutes(multicallContract, routes, amountSpecified, tradeType);
-        return {
-            route,
-            amountIn,
-            amountOut,
-            tradeType,
-            gasEstimate,
-        };
+        return await this.getBestQuoteFromRoutes(multicallContract, routes, amountSpecified, tradeType);
     }
     async getBestQuoteFromRoutes(multicallContract, routes, amountSpecified, tradeType) {
         const quotes = await getQuotesForRoutes(multicallContract, this.routingContracts.quoterAddress, routes, amountSpecified, tradeType);
@@ -15176,23 +15155,11 @@ class Router {
         }
         // We want to maximise the amountOut for the EXACT_INPUT type
         if (tradeType === TradeType.EXACT_INPUT) {
-            const bestQuote = this.bestQuoteForAmountIn(quotes);
-            return {
-                route: bestQuote.route,
-                amountIn: bestQuote.amountIn,
-                amountOut: bestQuote.amountOut,
-                gasEstimate: bestQuote.gasEstimate,
-            };
+            return this.bestQuoteForAmountIn(quotes);
         }
         // We want to minimise the amountIn for the EXACT_OUTPUT type
         if (tradeType === TradeType.EXACT_OUTPUT) {
-            const bestQuote = this.bestQuoteForAmountOut(quotes);
-            return {
-                route: bestQuote.route,
-                amountIn: bestQuote.amountIn,
-                amountOut: bestQuote.amountOut,
-                gasEstimate: bestQuote.gasEstimate,
-            };
+            return this.bestQuoteForAmountOut(quotes);
         }
         throw new Error('Invalid trade type');
     }
@@ -15231,9 +15198,9 @@ maxHops, // the maximum number of pools that can be traversed
 currentRoute = [], // list of pools already traversed
 routes = [], // list of all routes found so far
 startTokenIn = tokenIn) => {
-    const currencyIn = new Token(tokenIn.chainId, tokenIn.address, tokenIn.decimals);
-    const currencyOut = new Token(tokenOut.chainId, tokenOut.address, tokenOut.decimals);
-    const startCurrencyIn = new Token(startTokenIn.chainId, startTokenIn.address, startTokenIn.decimals);
+    const currencyIn = tokenInfoToUniswapToken(tokenIn);
+    const currencyOut = tokenInfoToUniswapToken(tokenOut);
+    const startCurrencyIn = tokenInfoToUniswapToken(startTokenIn);
     for (const pool of pools) {
         // if the pool doesn't have the tokenIn or if it has already been traversed,
         // skip to the next pool
@@ -15263,7 +15230,7 @@ class Fees {
     amount;
     constructor(secondaryFees, token) {
         this.secondaryFees = secondaryFees;
-        this.amount = { token, value: BigNumber$1.from(0) };
+        this.amount = newAmount(BigNumber$1.from(0), token);
     }
     addAmount(amount) {
         this.amount = addAmount(this.amount, amount);
@@ -15576,20 +15543,21 @@ class Exchange {
             getERC20Decimals(tokenOutAddress, this.provider),
             this.getSecondaryFees(),
         ]);
-        const tokenIn = new Token(this.chainId, tokenInAddress, tokenInDecimals);
-        const tokenOut = new Token(this.chainId, tokenOutAddress, tokenOutDecimals);
+        const tokenIn = {
+            address: tokenInAddress,
+            chainId: this.chainId,
+            decimals: tokenInDecimals,
+        };
+        const tokenOut = {
+            address: tokenOutAddress,
+            chainId: this.chainId,
+            decimals: tokenOutDecimals,
+        };
         // determine which amount was specified for the swap from the TradeType
-        let amountSpecified;
-        let otherToken;
-        if (tradeType === TradeType.EXACT_INPUT) {
-            amountSpecified = newAmount(amount, tokenIn);
-            otherToken = tokenOut;
-        }
-        else {
-            amountSpecified = newAmount(amount, tokenOut);
-            otherToken = tokenIn;
-        }
-        const fees = new Fees(secondaryFees, uniswapTokenToTokenInfo(tokenIn));
+        const [tokenSpecified, otherToken] = tradeType === TradeType.EXACT_INPUT
+            ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
+        const amountSpecified = newAmount(amount, tokenSpecified);
+        const fees = new Fees(secondaryFees, tokenIn);
         const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType);
         // get quote and gas details
         const [ourQuote, gasPrice] = await Promise.all([
@@ -16557,7 +16525,7 @@ class ImmutableApiClient {
                 ],
                 fees: makerFee ? [{
                         amount: makerFee.amount,
-                        fee_type: makerFee.type,
+                        fee_type: FeeType.MAKER_MARKETPLACE,
                         recipient: makerFee.recipient,
                     }] : [],
                 end_time: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
@@ -16626,6 +16594,67 @@ function getOrderbookConfig(environment) {
     }
 }
 
+function mapFromOpenApiOrder(order) {
+    const buyItems = order.buy.map((item) => {
+        if (item.item_type === 'ERC20') {
+            return {
+                type: 'ERC20',
+                contractAddress: item.contract_address,
+                amount: item.start_amount,
+            };
+        }
+        if (item.item_type === 'NATIVE') {
+            return {
+                type: 'NATIVE',
+                amount: item.start_amount,
+            };
+        }
+        throw new Error('Buy items must be either ERC20 or NATIVE');
+    });
+    const sellItems = order.sell.map((item) => {
+        if (item.item_type === 'ERC721') {
+            return {
+                type: 'ERC721',
+                contractAddress: item.contract_address,
+                tokenId: item.token_id,
+            };
+        }
+        throw new Error('Sell items must ERC721');
+    });
+    return {
+        id: order.id,
+        accountAddress: order.account_address,
+        buy: buyItems,
+        sell: sellItems,
+        fees: order.fees.map((fee) => ({
+            amount: fee.amount,
+            recipient: fee.recipient,
+            type: fee.fee_type,
+        })),
+        chain: order.chain,
+        createTime: order.create_time,
+        endTime: order.end_time,
+        protocolData: {
+            counter: order.protocol_data.counter,
+            orderType: order.protocol_data.order_type,
+            seaportAddress: order.protocol_data.seaport_address,
+            seaportVersion: order.protocol_data.seaport_version,
+            zoneAddress: order.protocol_data.zone_address,
+        },
+        salt: order.salt,
+        signature: order.signature,
+        startTime: order.start_time,
+        status: order.status,
+        updateTime: order.update_time,
+    };
+}
+function mapFromOpenApiPage(page) {
+    return {
+        nextCursor: page.next_cursor,
+        previousCursor: page.previous_cursor,
+    };
+}
+
 class SeaportLibFactory {
     defaultSeaportContractAddress;
     provider;
@@ -16685,8 +16714,11 @@ class Orderbook {
      * @param {string} listingId - The listingId to find.
      * @return {ListingResult} The returned order result.
      */
-    getListing(listingId) {
-        return this.apiClient.getListing(listingId);
+    async getListing(listingId) {
+        const apiListing = await this.apiClient.getListing(listingId);
+        return {
+            result: mapFromOpenApiOrder(apiListing.result),
+        };
     }
     /**
      * List orders. This method is used to get a list of orders filtered by conditions specified
@@ -16694,8 +16726,12 @@ class Orderbook {
      * @param {ListListingsParams} listOrderParams - Filtering, ordering and page parameters.
      * @return {ListListingsResult} The paged orders.
      */
-    listListings(listOrderParams) {
-        return this.apiClient.listListings(listOrderParams);
+    async listListings(listOrderParams) {
+        const apiListings = await this.apiClient.listListings(listOrderParams);
+        return {
+            page: mapFromOpenApiPage(apiListings.page),
+            result: apiListings.result.map(mapFromOpenApiOrder),
+        };
     }
     /**
      * Get required transactions and messages for signing prior to creating a listing
@@ -16717,8 +16753,20 @@ class Orderbook {
      * @param {CreateListingParams} createListingParams - create an order with the given params.
      * @return {ListingResult} The result of the order created in the Immutable services.
      */
-    createListing(createListingParams) {
-        return this.apiClient.createListing(createListingParams);
+    async createListing(createListingParams) {
+        const makerFee = createListingParams.makerFee
+            ? {
+                ...createListingParams.makerFee,
+                type: FeeType.MAKER_MARKETPLACE,
+            }
+            : undefined;
+        const apiListingResponse = await this.apiClient.createListing({
+            ...createListingParams,
+            makerFee,
+        });
+        return {
+            result: mapFromOpenApiOrder(apiListingResponse.result),
+        };
     }
     /**
      * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
@@ -16735,7 +16783,7 @@ class Orderbook {
                 fee: takerFee
                     ? {
                         amount: takerFee.amount,
-                        fee_type: takerFee.type,
+                        fee_type: FeeType.TAKER_MARKETPLACE,
                         recipient: takerFee.recipient,
                     }
                     : undefined,
@@ -18388,13 +18436,13 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     let type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
     let contractAddress = "";
     const buyArray = order.result.buy;
-    if (buyArray.length > 0) switch(buyArray[0].item_type){
+    if (buyArray.length > 0) switch(buyArray[0].type){
         case "NATIVE":
             type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
             break;
         case "ERC20":
             type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20;
-            contractAddress = buyArray[0].contract_address;
+            contractAddress = buyArray[0].contractAddress;
             break;
         default:
             throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Purchasing token type is unsupported", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).UNSUPPORTED_TOKEN_TYPE_ERROR, {
@@ -18402,7 +18450,7 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
             });
     }
     buyArray.forEach((item)=>{
-        if (item.item_type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721) amount = amount.add((BigNumber$1).from(item.start_amount));
+        if (item.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721) amount = amount.add((BigNumber$1).from(item.amount));
     });
     const feeArray = order.result.fees;
     feeArray.forEach((item)=>{

package/dist/checkout_widgets.js

@@ -4,7 +4,7 @@ import { useEffect } from 'react';
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.13.2-alpha";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.14.0-alpha.1";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/{erc721_hybrid_permissioned_mintable.d.ts → erc721.d.ts}

@@ -270,6 +270,14 @@ declare namespace ERC721Hybrid {
         to: string;
         quantity: BigNumber;
     };
+    type IDBurnStruct = {
+        owner: PromiseOrValue<string>;
+        tokenIds: PromiseOrValue<BigNumberish>[];
+    };
+    type IDBurnStructOutput = [string, BigNumber[]] & {
+        owner: string;
+        tokenIds: BigNumber[];
+    };
     type TransferRequestStruct = {
         from: PromiseOrValue<string>;
         tos: PromiseOrValue<string>[];
@@ -285,7 +293,8 @@ declare namespace ERC721Hybrid {
 type Mint = ERC721Hybrid.MintStruct;
 type IDMint = ERC721Hybrid.IDMintStruct;
 type TransferRequest = ERC721Hybrid.TransferRequestStruct;
-declare class ERC721HybridPermissionedMintable {
+type IDBurn = ERC721Hybrid.IDBurnStruct;
+declare class ERC721 {
     private readonly contract;
     constructor(contractAddress: string);
     /**
@@ -388,6 +397,18 @@ declare class ERC721HybridPermissionedMintable {
     populateBurnBatch(tokenIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<PopulatedTransaction>;
+    /**
+     * @returns a populated transaction for the safe burn contract function
+     */
+    populateSafeBurn(owner: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<PopulatedTransaction>;
+    /**
+     * @returns a populated transaction for the safe burn batch contract function
+     */
+    populateSafeBurnBatch(burns: IDBurn[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<PopulatedTransaction>;
     /**
      * @returns a populated transaction for the grantMinterRole contract function
      */
@@ -403,13 +424,13 @@ declare class ERC721HybridPermissionedMintable {
     /**
      * @returns a populated transaction for the mint by ID contract function
      */
-    populateMintByID(to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+    populateMint(to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<PopulatedTransaction>;
     /**
      * @returns a populated transaction for the safe mint by ID contract function
      */
-    populateSafeMintByID(to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+    populateSafeMint(to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<PopulatedTransaction>;
     /**
@@ -427,25 +448,25 @@ declare class ERC721HybridPermissionedMintable {
     /**
      * @returns a populated transaction for the batch mint by quantity contract function
      */
-    populateBatchMintByQuantity(mints: Mint[], overrides?: Overrides & {
+    populateMintBatchByQuantity(mints: Mint[], overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<PopulatedTransaction>;
     /**
      * @returns a populated transaction for the batch safe mint by quantity contract function
      */
-    populateBatchSafeMintByQuantity(mints: Mint[], overrides?: Overrides & {
+    populateSafeMintBatchByQuantity(mints: Mint[], overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<PopulatedTransaction>;
     /**
      * @returns a populated transaction for the batch mint by ID to multiple recipients contract function
      */
-    populateBatchMintByIDToMultiple(mints: IDMint[], overrides?: Overrides & {
+    populateMintBatch(mints: IDMint[], overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<PopulatedTransaction>;
     /**
      * @returns a populated transaction for the batch safe mint by ID to multiple recipients contract function
      */
-    populateBatchSafeMintByIDToMultiple(mints: IDMint[], overrides?: Overrides & {
+    populateSafeMintBatch(mints: IDMint[], overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<PopulatedTransaction>;
     /**
@@ -528,4 +549,4 @@ declare class ERC721HybridPermissionedMintable {
     }): Promise<PopulatedTransaction>;
 }
 
-export { ERC721HybridPermissionedMintable };
+export { ERC721 };