@imtbl/sdk 0.4.0-alpha.2 → 0.4.1-alpha

package/dist/orderbook.d.ts

@@ -1,6 +1,6 @@
-import { OrderbookOverrides, OrderbookModuleConfiguration } from 'config/config';
-import { ListingResult, ListListingsResult } from 'openapi/sdk';
-import { ListListingsParams, PrepareListingParams, PrepareListingResponse, CreateListingParams, FulfillOrderResponse, CancelOrderResponse } from 'types';
+import { OrderbookOverrides } from 'config/config';
+import { ListingResult, ListListingsResult, OrdersService } from 'openapi/sdk';
+import { ListListingsParams as ListListingsParams$1, PrepareListingParams as PrepareListingParams$1, PrepareListingResponse as PrepareListingResponse$1, CreateListingParams as CreateListingParams$1, FulfillOrderResponse as FulfillOrderResponse$1, CancelOrderResponse as CancelOrderResponse$1 } from 'types';
 
 declare enum Environment {
     PRODUCTION = "production",
@@ -28,7 +28,7 @@ declare class Orderbook {
     private apiClient;
     private seaport;
     private orderbookConfig;
-    constructor(config: ModuleConfiguration<OrderbookOverrides>, localConfig?: OrderbookModuleConfiguration);
+    constructor(config: ModuleConfiguration<OrderbookOverrides>);
     /**
      * Get an order by ID
      * @param {string} listingId - The listingId to find.
@@ -41,7 +41,7 @@ declare class Orderbook {
      * @param {ListOrderParams} listOrderParams - Filtering, ordering and page parameters.
      * @return {Orders} The paged orders.
      */
-    listListings(listOrderParams: ListListingsParams): Promise<ListListingsResult>;
+    listListings(listOrderParams: ListListingsParams$1): Promise<ListListingsResult>;
     /**
      * Get required transactions and messages for signing prior to creating a listing
      * through the createListing method
@@ -50,13 +50,13 @@ declare class Orderbook {
      * the unsigned approval transaction, the typed order message for signing and
      * the order components that can be submitted to `createListing` with a signature.
      */
-    prepareListing({ makerAddress, sell, buy, orderExpiry, }: PrepareListingParams): Promise<PrepareListingResponse>;
+    prepareListing({ makerAddress, sell, buy, orderExpiry, }: PrepareListingParams$1): Promise<PrepareListingResponse$1>;
     /**
      * Create an order
      * @param {CreateListingParams} createListingParams - create an order with the given params.
      * @return {ListingResult} The result of the order created in the Immutable services.
      */
-    createListing(createListingParams: CreateListingParams): Promise<ListingResult>;
+    createListing(createListingParams: CreateListingParams$1): Promise<ListingResult>;
     /**
      * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
      * transaction exists it must be signed and submitted to the chain before the fulfilment
@@ -65,7 +65,7 @@ declare class Orderbook {
      * @param {string} fulfillerAddress - The address of the account fulfilling the order.
      * @return {FulfillOrderResponse} Approval and fulfilment transactions.
      */
-    fulfillOrder(listingId: string, takerAddress: string): Promise<FulfillOrderResponse>;
+    fulfillOrder(listingId: string, takerAddress: string): Promise<FulfillOrderResponse$1>;
     /**
      * Get an unsigned cancel order transaction. Orders can only be cancelled by
      * the account that created them.
@@ -73,9 +73,180 @@ declare class Orderbook {
      * @param {string} accountAddress - The address of the account cancelling the order.
      * @return {CancelOrderResponse} The unsigned cancel order transaction
      */
-    cancelOrder(listingId: string, accountAddress: string): Promise<CancelOrderResponse>;
+    cancelOrder(listingId: string, accountAddress: string): Promise<CancelOrderResponse$1>;
+}
+
+declare type Bytes = ArrayLike<number>;
+declare type BytesLike = Bytes | string;
+interface Hexable {
+    toHexString(): string;
+}
+
+declare type BigNumberish = BigNumber | Bytes | bigint | string | number;
+declare class BigNumber implements Hexable {
+    readonly _hex: string;
+    readonly _isBigNumber: boolean;
+    constructor(constructorGuard: any, hex: string);
+    fromTwos(value: number): BigNumber;
+    toTwos(value: number): BigNumber;
+    abs(): BigNumber;
+    add(other: BigNumberish): BigNumber;
+    sub(other: BigNumberish): BigNumber;
+    div(other: BigNumberish): BigNumber;
+    mul(other: BigNumberish): BigNumber;
+    mod(other: BigNumberish): BigNumber;
+    pow(other: BigNumberish): BigNumber;
+    and(other: BigNumberish): BigNumber;
+    or(other: BigNumberish): BigNumber;
+    xor(other: BigNumberish): BigNumber;
+    mask(value: number): BigNumber;
+    shl(value: number): BigNumber;
+    shr(value: number): BigNumber;
+    eq(other: BigNumberish): boolean;
+    lt(other: BigNumberish): boolean;
+    lte(other: BigNumberish): boolean;
+    gt(other: BigNumberish): boolean;
+    gte(other: BigNumberish): boolean;
+    isNegative(): boolean;
+    isZero(): boolean;
+    toNumber(): number;
+    toBigInt(): bigint;
+    toString(): string;
+    toHexString(): string;
+    toJSON(key?: string): any;
+    static from(value: any): BigNumber;
+    static isBigNumber(value: any): value is BigNumber;
+}
+
+declare type AccessList = Array<{
+    address: string;
+    storageKeys: Array<string>;
+}>;
+
+interface TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: BigNumberish;
+    verifyingContract?: string;
+    salt?: BytesLike;
+}
+interface TypedDataField {
+    name: string;
+    type: string;
+}
+
+interface PopulatedTransaction {
+    to?: string;
+    from?: string;
+    nonce?: number;
+    gasLimit?: BigNumber;
+    gasPrice?: BigNumber;
+    data?: string;
+    value?: BigNumber;
+    chainId?: number;
+    type?: number;
+    accessList?: AccessList;
+    maxFeePerGas?: BigNumber;
+    maxPriorityFeePerGas?: BigNumber;
+    customData?: Record<string, any>;
+    ccipReadEnabled?: boolean;
+}
+
+declare enum OrderType {
+    FULL_OPEN = 0,
+    PARTIAL_OPEN = 1,
+    FULL_RESTRICTED = 2,
+    PARTIAL_RESTRICTED = 3
+}
+declare enum ItemType {
+    NATIVE = 0,
+    ERC20 = 1,
+    ERC721 = 2,
+    ERC1155 = 3,
+    ERC721_WITH_CRITERIA = 4,
+    ERC1155_WITH_CRITERIA = 5
+}
+
+type OfferItem = {
+    itemType: ItemType;
+    token: string;
+    identifierOrCriteria: string;
+    startAmount: string;
+    endAmount: string;
+};
+type ConsiderationItem = {
+    itemType: ItemType;
+    token: string;
+    identifierOrCriteria: string;
+    startAmount: string;
+    endAmount: string;
+    recipient: string;
+};
+type OrderParameters = {
+    offerer: string;
+    zone: string;
+    orderType: OrderType;
+    startTime: BigNumberish;
+    endTime: BigNumberish;
+    zoneHash: string;
+    salt: string;
+    offer: OfferItem[];
+    consideration: ConsiderationItem[];
+    totalOriginalConsiderationItems: BigNumberish;
+    conduitKey: string;
+};
+type OrderComponents = OrderParameters & {
+    counter: BigNumberish;
+};
+
+interface ERC721Item {
+    type: 'ERC721';
+    contractAddress: string;
+    tokenId: string;
+}
+interface ERC20Item {
+    type: 'ERC20';
+    contractAddress: string;
+    amount: string;
+}
+interface NativeItem {
+    type: 'NATIVE';
+    amount: string;
+}
+interface RoyaltyInfo {
+    recipient: string;
+    amountRequired: string;
+}
+interface PrepareListingParams {
+    makerAddress: string;
+    sell: ERC721Item;
+    buy: ERC20Item | NativeItem;
+    orderExpiry?: Date;
+}
+interface PrepareListingResponse {
+    unsignedApprovalTransaction?: PopulatedTransaction;
+    typedOrderMessageForSigning: {
+        domain: TypedDataDomain;
+        types: Record<string, TypedDataField[]>;
+        value: Record<string, any>;
+    };
+    orderComponents: OrderComponents;
+    orderHash: string;
+}
+interface CreateListingParams {
+    orderComponents: OrderComponents;
+    orderHash: string;
+    orderSignature: string;
+}
+type ListListingsParams = Omit<Parameters<typeof OrdersService.prototype.listListings>[0], 'chainName'>;
+interface FulfillOrderResponse {
+    unsignedApprovalTransaction?: PopulatedTransaction;
+    unsignedFulfillmentTransaction: PopulatedTransaction;
+}
+interface CancelOrderResponse {
+    unsignedCancelOrderTransaction: PopulatedTransaction;
 }
 
 declare const module = "orderbook";
 
-export { Orderbook, module };
+export { CancelOrderResponse, CreateListingParams, ERC20Item, ERC721Item, FulfillOrderResponse, ListListingsParams, NativeItem, Orderbook, PrepareListingParams, PrepareListingResponse, RoyaltyInfo, module };

package/dist/orderbook.js

@@ -3,6 +3,12 @@ import FormData from 'form-data';
 import { providers, BigNumber, constants, utils, Contract } from 'ethers';
 import { Seaport as Seaport$1 } from '@opensea/seaport-js';
 
+var Environment;
+(function (Environment) {
+    Environment["PRODUCTION"] = "production";
+    Environment["SANDBOX"] = "sandbox";
+})(Environment || (Environment = {}));
+
 class BaseHttpRequest {
     config;
     constructor(config) {
@@ -898,31 +904,25 @@ class ImmutableApiClientFactory {
     }
 }
 
-const DEVNET_CHAIN_NAME = 'imtbl-zkevm-devnet';
 const TESTNET_CHAIN_NAME = 'imtbl-zkevm-testnet';
 const MAINNET_CHAIN_NAME = 'imtbl-zkevm-mainnet';
-function getOrderbookConfig(chainName) {
-    switch (chainName) {
-        case DEVNET_CHAIN_NAME:
-            return {
-                seaportContractAddress: '0x41388404Efb7a68Fd31d75CEf71dF91e2BDBa2fb',
-                zoneContractAddress: '0xCb5063b0c1dcF4f7fed8E7eaa79faf9859792767',
-                apiEndpoint: 'https://order-book-mr.dev.imtbl.com',
-                provider: new providers.JsonRpcProvider('https://zkevm-rpc.dev.x.immutable.com'),
-            };
-        case TESTNET_CHAIN_NAME:
+function getOrderbookConfig(environment) {
+    switch (environment) {
+        case Environment.SANDBOX:
             return {
-                seaportContractAddress: '0x45E23dA18804F99Cf67408AeBE85F67c958381Ff',
-                zoneContractAddress: '0x25b00b7eb97eab6194798E9B8eF63Aa526D5bd7E',
+                seaportContractAddress: '0x474989C4D25DD41B0B9b1ECb4643B9Fe25f83B19',
+                zoneContractAddress: '0x6FeDb4949E5b452700A8a8956999a7E05B6770F3',
                 apiEndpoint: 'https://order-book-mr.sandbox.imtbl.com',
+                chainName: TESTNET_CHAIN_NAME,
                 provider: new providers.JsonRpcProvider('https://zkevm-rpc.sandbox.x.immutable.com'),
             };
-        case MAINNET_CHAIN_NAME:
-            // not yet deployed
+        // not yet deployed
+        case Environment.PRODUCTION:
             return {
                 seaportContractAddress: '',
                 zoneContractAddress: '',
                 apiEndpoint: 'https://order-book-mr.imtbl.com',
+                chainName: MAINNET_CHAIN_NAME,
                 provider: new providers.JsonRpcProvider('https://zkevm-rpc.x.immutable.com'),
             };
         default:
@@ -1881,21 +1881,19 @@ class Orderbook {
     apiClient;
     seaport;
     orderbookConfig;
-    constructor(config, localConfig) {
-        // either use preconfigured config or local config passed in
-        const maybeConfig = getOrderbookConfig(config.overrides?.chainName) || localConfig;
-        if (!maybeConfig) {
-            throw new Error('Orderbook configuration not passed, either select one of the preseet chainNames or pass in localConfig');
+    constructor(config) {
+        const obConfig = getOrderbookConfig(config.baseConfig.environment);
+        const finalConfig = {
+            ...obConfig,
+            ...config.overrides,
+        };
+        if (!finalConfig) {
+            throw new Error('Orderbook configuration not passed, please specify the environment under config.baseConfig.environment');
         }
-        this.orderbookConfig = maybeConfig;
-        const { apiEndpoint } = this.orderbookConfig;
+        this.orderbookConfig = finalConfig;
+        const { apiEndpoint, chainName } = this.orderbookConfig;
         if (!apiEndpoint) {
-            throw new Error('API endpoint must be provided as an override');
-        }
-        // TODO: Move chainId lookup to a map based on env. Just using override to get dev started
-        const chainName = config.overrides?.chainName;
-        if (!chainName) {
-            throw new Error('chainName must be provided as an override');
+            throw new Error('API endpoint must be provided');
         }
         this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainName, this.orderbookConfig.seaportContractAddress).create();
         const seaportLibFactory = new SeaportLibFactory(this.orderbookConfig.seaportContractAddress, this.orderbookConfig.provider);