@imtbl/sdk 0.16.0 → 0.17.0

package/dist/orderbook.d.ts

@@ -811,9 +811,6 @@ type CreateListingRequestBody = {
      * Buy item for listing should either be NATIVE or ERC20 item
      */
     buy: Array<Item>;
-    /**
-     * The maker marketplace fee
-     */
     fee?: Fee$1;
     /**
      * Time after which the Order is considered expired
@@ -935,6 +932,54 @@ type ListListingsResult$1 = {
     result: Array<Order$1>;
 };
 
+/**
+ * The metadata related to the transaction in which the activity occurred
+ */
+type TradeBlockchainMetadata = {
+    /**
+     * The transaction hash of the trade
+     */
+    transaction_hash: string;
+    /**
+     * EVM block number (uint64 as string)
+     */
+    block_number: string;
+    /**
+     * Transaction index in a block (uint32 as string)
+     */
+    transaction_index: string;
+    /**
+     * The log index of the fulfillment event in a block (uint32 as string)
+     */
+    log_index: string;
+};
+
+type Trade$1 = {
+    buy: Array<Item>;
+    buyer_address: string;
+    buyer_fees: Array<Fee$1>;
+    chain: Chain;
+    order_id: string;
+    blockchain_metadata: TradeBlockchainMetadata;
+    /**
+     * Time the on-chain trade event is indexed by the order book system
+     */
+    indexed_at: string;
+    /**
+     * Global Trade identifier
+     */
+    id: string;
+    sell: Array<Item>;
+    seller_address: string;
+    maker_address: string;
+    taker_address: string;
+};
+
+type ListTradeResult = {
+    page: Page$1;
+    result: Array<Trade$1>;
+};
+
 /**
  * Encoded page cursor to retrieve previous or next page. Use the value returned in the response.
  */
@@ -945,6 +990,10 @@ type PageCursor = string;
  */
 type PageSize = number;
 
+type TradeResult$1 = {
+    result: Trade$1;
+};
+
 declare class OrdersService {
     readonly httpRequest: BaseHttpRequest;
     constructor(httpRequest: BaseHttpRequest);
@@ -1024,6 +1073,45 @@ declare class OrdersService {
     }): CancelablePromise<{
         result: Array<FulfillmentDataResult>;
     }>;
+    /**
+     * List all trades
+     * List all trades
+     * @returns ListTradeResult OK response.
+     * @throws ApiError
+     */
+    listTrades({ chainName, accountAddress, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName;
+        accountAddress?: string;
+        /**
+         * Maximum number of trades to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Trade field to sort by
+         */
+        sortBy?: 'created_at';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListTradeResult>;
+    /**
+     * Get a single trade by ID
+     * Get a single trade by ID
+     * @returns TradeResult OK response.
+     * @throws ApiError
+     */
+    getTrade({ chainName, tradeId, }: {
+        chainName: ChainName;
+        /**
+         * Global Trade identifier
+         */
+        tradeId: string;
+    }): CancelablePromise<TradeResult$1>;
 }
 
 interface ERC721Item {
@@ -1062,6 +1150,7 @@ interface CreateListingParams {
     makerFee?: FeeValue;
 }
 type ListListingsParams = Omit<Parameters<typeof OrdersService.prototype.listListings>[0], 'chainName'>;
+type ListTradesParams = Omit<Parameters<typeof OrdersService.prototype.listTrades>[0], 'chainName'>;
 declare enum FeeType {
     MAKER_MARKETPLACE = "MAKER_MARKETPLACE",
     TAKER_MARKETPLACE = "TAKER_MARKETPLACE",
@@ -1162,6 +1251,50 @@ interface Page {
      */
     nextCursor: string | null;
 }
+interface Trade {
+    id: string;
+    orderId: string;
+    chain: {
+        id: string;
+        name: string;
+    };
+    buy: (ERC20Item | NativeItem)[];
+    sell: ERC721Item[];
+    buyerFees: Fee[];
+    sellerAddress: string;
+    buyerAddress: string;
+    makerAddress: string;
+    takerAddress: string;
+    /**
+     * Time the on-chain event was indexed by the Immutable order book service
+     */
+    indexedAt: string;
+    blockchainMetadata: {
+        /**
+         * The transaction hash of the trade
+         */
+        transactionHash: string;
+        /**
+         * EVM block number (uint64 as string)
+         */
+        blockNumber: string;
+        /**
+         * Transaction index in a block (uint32 as string)
+         */
+        transactionIndex: string;
+        /**
+         * The log index of the fulfillment event in a block (uint32 as string)
+         */
+        logIndex: string;
+    };
+}
+interface TradeResult {
+    result: Trade;
+}
+interface ListTradesResult {
+    page: Page;
+    result: Trade[];
+}
 
 /**
  * zkEVM orderbook SDK
@@ -1184,6 +1317,12 @@ declare class Orderbook {
      * @return {ListingResult} The returned order result.
      */
     getListing(listingId: string): Promise<ListingResult>;
+    /**
+     * Get a trade by ID
+     * @param {string} tradeId - The tradeId to find.
+     * @return {TradeResult} The returned order result.
+     */
+    getTrade(tradeId: string): Promise<TradeResult>;
     /**
      * List orders. This method is used to get a list of orders filtered by conditions specified
      * in the params object.
@@ -1191,6 +1330,13 @@ declare class Orderbook {
      * @return {ListListingsResult} The paged orders.
      */
     listListings(listOrderParams: ListListingsParams): Promise<ListListingsResult>;
+    /**
+     * List trades. This method is used to get a list of trades filtered by conditions specified
+     * in the params object
+     * @param {ListTradesParams} listTradesParams - Filtering, ordering and page parameters.
+     * @return {ListTradesResult} The paged trades.
+     */
+    listTrades(listTradesParams: ListTradesParams): Promise<ListTradesResult>;
     /**
      * Get required transactions and messages for signing prior to creating a listing
      * through the createListing method
@@ -1229,4 +1375,4 @@ declare const constants: {
     estimatedFulfillmentGasGwei: number;
 };
 
-export { Action, ActionType, CancelOrderResponse, CreateListingParams, ERC20Item, ERC721Item, Fee, FeeType, FeeValue, FulfillOrderResponse, ListListingsParams, ListListingsResult, ListingResult, NativeItem, Order, OrderStatus, Orderbook, Page, PrepareListingParams, PrepareListingResponse, RoyaltyInfo, SignableAction, SignablePurpose, TransactionAction, TransactionBuilder, TransactionPurpose, constants };
+export { Action, ActionType, CancelOrderResponse, CreateListingParams, ERC20Item, ERC721Item, Fee, FeeType, FeeValue, FulfillOrderResponse, ListListingsParams, ListListingsResult, ListTradesParams, ListTradesResult, ListingResult, NativeItem, Order, OrderStatus, Orderbook, Page, PrepareListingParams, PrepareListingResponse, RoyaltyInfo, SignableAction, SignablePurpose, Trade, TradeResult, TransactionAction, TransactionBuilder, TransactionPurpose, constants };

package/dist/orderbook.js

@@ -493,6 +493,54 @@ class OrdersService {
             },
         });
     }
+    /**
+     * List all trades
+     * List all trades
+     * @returns ListTradeResult OK response.
+     * @throws ApiError
+     */
+    listTrades({ chainName, accountAddress, pageSize, sortBy, sortDirection, pageCursor, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/v1/chains/{chain_name}/trades',
+            path: {
+                'chain_name': chainName,
+            },
+            query: {
+                'account_address': accountAddress,
+                'page_size': pageSize,
+                'sort_by': sortBy,
+                'sort_direction': sortDirection,
+                'page_cursor': pageCursor,
+            },
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
+    /**
+     * Get a single trade by ID
+     * Get a single trade by ID
+     * @returns TradeResult OK response.
+     * @throws ApiError
+     */
+    getTrade({ chainName, tradeId, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/v1/chains/{chain_name}/trades/{trade_id}',
+            path: {
+                'chain_name': chainName,
+                'trade_id': tradeId,
+            },
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
 }
 
 class OrderBookClient {
@@ -629,6 +677,57 @@ function mapFromOpenApiOrder(order) {
         updateTime: order.update_time,
     };
 }
+function mapFromOpenApiTrade(trade) {
+    const buyItems = trade.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 = trade.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: trade.id,
+        orderId: trade.order_id,
+        buy: buyItems,
+        sell: sellItems,
+        buyerFees: trade.buyer_fees.map((fee) => ({
+            amount: fee.amount,
+            recipient: fee.recipient,
+            type: fee.fee_type,
+        })),
+        chain: trade.chain,
+        indexedAt: trade.indexed_at,
+        blockchainMetadata: {
+            blockNumber: trade.blockchain_metadata.block_number,
+            logIndex: trade.blockchain_metadata.log_index,
+            transactionHash: trade.blockchain_metadata.transaction_hash,
+            transactionIndex: trade.blockchain_metadata.transaction_index,
+        },
+        buyerAddress: trade.buyer_address,
+        makerAddress: trade.maker_address,
+        sellerAddress: trade.seller_address,
+        takerAddress: trade.taker_address,
+    };
+}
 function mapFromOpenApiPage(page) {
     return {
         nextCursor: page.next_cursor,
@@ -958,12 +1057,24 @@ class ImmutableApiClient {
             listingId,
         });
     }
+    async getTrade(tradeId) {
+        return this.orderbookService.getTrade({
+            chainName: this.chainName,
+            tradeId,
+        });
+    }
     async listListings(listOrderParams) {
         return this.orderbookService.listListings({
             chainName: this.chainName,
             ...listOrderParams,
         });
     }
+    async listTrades(listTradesParams) {
+        return this.orderbookService.listTrades({
+            chainName: this.chainName,
+            ...listTradesParams,
+        });
+    }
     async createListing({ orderHash, orderComponents, orderSignature, makerFee, }) {
         if (orderComponents.offer.length !== 1) {
             throw new Error('Only one item can be listed at a time');
@@ -1129,6 +1240,17 @@ class Orderbook {
             result: mapFromOpenApiOrder(apiListing.result),
         };
     }
+    /**
+     * Get a trade by ID
+     * @param {string} tradeId - The tradeId to find.
+     * @return {TradeResult} The returned order result.
+     */
+    async getTrade(tradeId) {
+        const apiListing = await this.apiClient.getTrade(tradeId);
+        return {
+            result: mapFromOpenApiTrade(apiListing.result),
+        };
+    }
     /**
      * List orders. This method is used to get a list of orders filtered by conditions specified
      * in the params object.
@@ -1142,6 +1264,19 @@ class Orderbook {
             result: apiListings.result.map(mapFromOpenApiOrder),
         };
     }
+    /**
+     * List trades. This method is used to get a list of trades filtered by conditions specified
+     * in the params object
+     * @param {ListTradesParams} listTradesParams - Filtering, ordering and page parameters.
+     * @return {ListTradesResult} The paged trades.
+     */
+    async listTrades(listTradesParams) {
+        const apiListings = await this.apiClient.listTrades(listTradesParams);
+        return {
+            page: mapFromOpenApiPage(apiListings.page),
+            result: apiListings.result.map(mapFromOpenApiTrade),
+        };
+    }
     /**
      * Get required transactions and messages for signing prior to creating a listing
      * through the createListing method

package/dist/passport.d.ts

@@ -10610,6 +10610,7 @@ declare class Passport {
     getUserInfoDeviceFlow(): Promise<UserProfile | undefined>;
     getIdToken(): Promise<string | undefined>;
     getAccessToken(): Promise<string | undefined>;
+    getLinkedAddresses(): Promise<string[]>;
 }
 
 export { AccountsChangedEvent, DeviceConnectResponse, DeviceTokenResponse, JsonRpcError, JsonRpcRequestCallback, JsonRpcRequestPayload, JsonRpcResponsePayload, Networks, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, Provider, ProviderErrorCode, ProviderEvent, RequestArguments, RpcErrorCode, UserProfile };