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

package/dist/orderbook.d.ts

@@ -1,4 +1,4 @@
-import { OrderbookOverrides, OrderbookModuleConfiguration } from 'config/config';
+import { OrderbookOverrides } from 'config/config';
 import { ListingResult, ListListingsResult } from 'openapi/sdk';
 import { ListListingsParams, PrepareListingParams, PrepareListingResponse, CreateListingParams, FulfillOrderResponse, CancelOrderResponse } from 'types';
 
@@ -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.

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);

package/dist/passport.d.ts

@@ -203,7 +203,7 @@ declare abstract class ForkEvent extends Description {
 }
 declare type EventType = string | Array<string | Array<string>> | EventFilter | ForkEvent;
 declare type Listener = (...args: Array<any>) => void;
-declare abstract class Provider implements OnceBlockable {
+declare abstract class Provider$1 implements OnceBlockable {
     abstract getNetwork(): Promise<Network>;
     abstract getBlockNumber(): Promise<number>;
     abstract getGasPrice(): Promise<BigNumber>;
@@ -222,27 +222,27 @@ declare abstract class Provider implements OnceBlockable {
     abstract getLogs(filter: Filter): Promise<Array<Log>>;
     abstract resolveName(name: string | Promise<string>): Promise<null | string>;
     abstract lookupAddress(address: string | Promise<string>): Promise<null | string>;
-    abstract on(eventName: EventType, listener: Listener): Provider;
-    abstract once(eventName: EventType, listener: Listener): Provider;
+    abstract on(eventName: EventType, listener: Listener): Provider$1;
+    abstract once(eventName: EventType, listener: Listener): Provider$1;
     abstract emit(eventName: EventType, ...args: Array<any>): boolean;
     abstract listenerCount(eventName?: EventType): number;
     abstract listeners(eventName?: EventType): Array<Listener>;
-    abstract off(eventName: EventType, listener?: Listener): Provider;
-    abstract removeAllListeners(eventName?: EventType): Provider;
-    addListener(eventName: EventType, listener: Listener): Provider;
-    removeListener(eventName: EventType, listener: Listener): Provider;
+    abstract off(eventName: EventType, listener?: Listener): Provider$1;
+    abstract removeAllListeners(eventName?: EventType): Provider$1;
+    addListener(eventName: EventType, listener: Listener): Provider$1;
+    removeListener(eventName: EventType, listener: Listener): Provider$1;
     abstract waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number): Promise<TransactionReceipt>;
     readonly _isProvider: boolean;
     constructor();
-    static isProvider(value: any): value is Provider;
+    static isProvider(value: any): value is Provider$1;
 }
 
 declare abstract class Signer {
-    readonly provider?: Provider;
+    readonly provider?: Provider$1;
     abstract getAddress(): Promise<string>;
     abstract signMessage(message: Bytes | string): Promise<string>;
     abstract signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
-    abstract connect(provider: Provider): Signer;
+    abstract connect(provider: Provider$1): Signer;
     readonly _isSigner: boolean;
     constructor();
     getBalance(blockTag?: BlockTag): Promise<BigNumber>;
@@ -10352,14 +10352,14 @@ declare class ImmutableXClient {
      * @returns a promise that resolves with the requested Order
      * @throws {@link index.IMXError}
      */
-    getOrder(request: OrdersApiGetOrderRequest): Promise<Order>;
+    getOrder(request: OrdersApiGetOrderRequest): Promise<OrderV3>;
     /**
      * Get a list of Orders
      * @param request - optional object containing the parameters to be provided in the API request
      * @returns a promise that resolves with the requested list of Orders
      * @throws {@link index.IMXError}
      */
-    listOrders(request?: OrdersApiListOrdersRequest): Promise<ListOrdersResponse>;
+    listOrders(request?: OrdersApiListOrdersRequest): Promise<ListOrdersResponseV3>;
     /**
      * Get details of a Trade with the given ID
      * @param request - the request object containing the parameters to be provided in the API request
@@ -10473,6 +10473,7 @@ declare enum Networks {
 interface OidcConfiguration {
     clientId: string;
     logoutRedirectUri: string;
+    logoutMode?: 'redirect' | 'silent';
     redirectUri: string;
     scope?: string;
     audience?: string;
@@ -10485,6 +10486,12 @@ interface PassportOverrides {
     passportDomain: string;
     imxPublicApiDomain: string;
     immutableXClient: ImmutableXClient;
+    zkEvmRpcUrl: string;
+    zkEvmChainId: string;
+    relayerUrl: string;
+    indexerMrBasePath: string;
+    orderBookMrBasePath: string;
+    passportMrBasePath: string;
 }
 interface PassportModuleConfiguration extends ModuleConfiguration<PassportOverrides>, OidcConfiguration {
 }
@@ -10502,6 +10509,58 @@ type DeviceTokenResponse = {
     expires_in: number;
 };
 
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ */
+declare enum ProviderErrorCode {
+    USER_REJECTED_REQUEST = 4001,
+    UNAUTHORIZED = 4100,
+    UNSUPPORTED_METHOD = 4200,
+    DISCONNECTED = 4900
+}
+declare enum RpcErrorCode {
+    RPC_SERVER_ERROR = -32000,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603,
+    PARSE_ERROR = -32700
+}
+declare class JsonRpcError extends Error {
+    readonly message: string;
+    readonly code: ProviderErrorCode | RpcErrorCode;
+    constructor(code: ProviderErrorCode | RpcErrorCode, message: string);
+}
+
+interface RequestArguments {
+    method: string;
+    params?: Array<any>;
+}
+type JsonRpcRequestPayload = RequestArguments & {
+    jsonrpc?: string;
+    id?: string | number;
+};
+interface JsonRpcRequestCallback {
+    (err: JsonRpcError | null, result?: JsonRpcResponsePayload | (JsonRpcResponsePayload | null)[] | null): void;
+}
+interface JsonRpcResponsePayload {
+    result?: Array<any> | null;
+    error?: JsonRpcError | null;
+    jsonrpc?: string;
+    id?: string | number;
+}
+type Provider = {
+    request: (request: RequestArguments) => Promise<any>;
+    sendAsync: (request: JsonRpcRequestPayload | JsonRpcRequestPayload[], callback: JsonRpcRequestCallback) => void;
+    send: (request: string | JsonRpcRequestPayload | JsonRpcRequestPayload[], callbackOrParams?: JsonRpcRequestCallback | Array<any>, callback?: JsonRpcRequestCallback) => void;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+    removeListener: (event: string, listener: (...args: any[]) => void) => void;
+};
+declare enum ProviderEvent {
+    ACCOUNTS_CHANGED = "accountsChanged"
+}
+type AccountsChangedEvent = Array<string>;
+
 declare class Passport {
     private readonly authManager;
     private readonly config;
@@ -10509,6 +10568,7 @@ declare class Passport {
     private readonly immutableXClient;
     private readonly magicAdapter;
     private readonly passportImxProviderFactory;
+    private readonly multiRollupApiClients;
     constructor(passportModuleConfiguration: PassportModuleConfiguration);
     connectImxSilent(): Promise<IMXProvider | null>;
     connectImx(): Promise<IMXProvider>;
@@ -10519,8 +10579,14 @@ declare class Passport {
      */
     checkStoredDeviceFlowCredentials(): DeviceTokenResponse | null;
     connectImxWithCredentials(tokenResponse: DeviceTokenResponse): Promise<IMXProvider | null>;
+    protected connectEvm(): Provider;
     loginCallback(): Promise<void>;
     logout(): Promise<void>;
+    /**
+     * This method should only be called from the logout redirect uri
+     * when logout mode is 'silent'.
+     */
+    logoutSilentCallback(url: string): Promise<void>;
     logoutDeviceFlow(): Promise<void>;
     getUserInfo(): Promise<UserProfile | undefined>;
     getUserInfoDeviceFlow(): Promise<UserProfile | undefined>;
@@ -10528,4 +10594,4 @@ declare class Passport {
     getAccessToken(): Promise<string | undefined>;
 }
 
-export { DeviceConnectResponse, DeviceTokenResponse, Networks, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, UserProfile };
+export { AccountsChangedEvent, DeviceConnectResponse, DeviceTokenResponse, JsonRpcError, JsonRpcRequestCallback, JsonRpcRequestPayload, JsonRpcResponsePayload, Networks, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, Provider, ProviderErrorCode, ProviderEvent, RequestArguments, RpcErrorCode, UserProfile };