@imtbl/sdk 0.44.4-alpha.1 → 0.45.0

package/dist/index.d.ts

@@ -15302,6 +15302,28 @@ declare namespace blockchain_data_d {
   };
 }
 
+declare enum PassportErrorType {
+    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
+    INVALID_CONFIGURATION = "INVALID_CONFIGURATION",
+    WALLET_CONNECTION_ERROR = "WALLET_CONNECTION_ERROR",
+    NOT_LOGGED_IN_ERROR = "NOT_LOGGED_IN_ERROR",
+    SILENT_LOGIN_ERROR = "SILENT_LOGIN_ERROR",
+    REFRESH_TOKEN_ERROR = "REFRESH_TOKEN_ERROR",
+    USER_REGISTRATION_ERROR = "USER_REGISTRATION_ERROR",
+    USER_NOT_REGISTERED_ERROR = "USER_NOT_REGISTERED_ERROR",
+    LOGOUT_ERROR = "LOGOUT_ERROR",
+    TRANSFER_ERROR = "TRANSFER_ERROR",
+    CREATE_ORDER_ERROR = "CREATE_ORDER_ERROR",
+    CANCEL_ORDER_ERROR = "CANCEL_ORDER_ERROR",
+    EXCHANGE_TRANSFER_ERROR = "EXCHANGE_TRANSFER_ERROR",
+    CREATE_TRADE_ERROR = "CREATE_TRADE_ERROR",
+    OPERATION_NOT_SUPPORTED_ERROR = "OPERATION_NOT_SUPPORTED_ERROR"
+}
+declare class PassportError extends Error {
+    type: PassportErrorType;
+    constructor(message: string, type: PassportErrorType);
+}
+
 declare type Bytes = ArrayLike<number>;
 declare type BytesLike = Bytes | string;
 interface Hexable {
@@ -25386,13 +25408,141 @@ interface ImmutableXConfiguration {
     ethConfiguration: EthConfiguration;
 }
 
+interface IMXProvider {
+    /**
+     * Get the Signer address
+     *
+     * @return {Promise<string>} Returns a promise that resolves with the signer's address
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Register a User to Immutable X if they are not already registered
+     *
+     * @return {Promise<RegisterUserResponse>} Returns a promise that resolves with the user registration response
+     */
+    registerOffchain(): Promise<RegisterUserResponse>;
+    /**
+     *  Checks if a User is registered off-chain
+     *
+     *  @return {Promise<boolean>} Returns a promise that resolves with true if the User is registered with IMX, false otherwise
+     */
+    isRegisteredOffchain(): Promise<boolean>;
+    /**
+     * Checks if a User is registered on-chain
+     *
+     * @return {Promise<boolean>} Returns a promise that resolves with true if the User is registered, false otherwise
+     */
+    isRegisteredOnchain(): Promise<boolean>;
+    /**
+     * Create an Order
+     *
+     * @param {UnsignedOrderRequest} request The unsigned order request to create an order
+     * @return {Promise<CreateOrderResponse>} Returns a promise that resolves with the created Order
+     */
+    createOrder(request: UnsignedOrderRequest): Promise<CreateOrderResponse>;
+    /**
+     * Cancel an Order
+     *
+     * @param {GetSignableCancelOrderRequest} request The signable cancel order request
+     * @return {Promise<CancelOrderResponse>} Returns a promise that resolves with the cancelled Order
+     */
+    cancelOrder(request: GetSignableCancelOrderRequest): Promise<CancelOrderResponse>;
+    /**
+     * Create a Trade
+     *
+     * @param {GetSignableTradeRequest} request The signable trade request
+     * @return {Promise<CreateTradeResponse>} Returns a promise that resolves with the created Trade
+     */
+    createTrade(request: GetSignableTradeRequest): Promise<CreateTradeResponse>;
+    /**
+     * Create a new Transfer request
+     *
+     * @param {UnsignedTransferRequest} request The unsigned transfer request
+     * @return {Promise<CreateTransferResponseV1>} Returns a promise that resolves with the created Transfer
+     */
+    transfer(request: UnsignedTransferRequest): Promise<CreateTransferResponseV1>;
+    /**
+     * Create a batch of NFT transfer requests
+     *
+     * @param {Array<NftTransferDetails>} request An array of NFT transfer details
+     * @return {Promise<CreateTransferResponse>} Resolves a promise that resolves with the list of Transfer IDs
+     */
+    batchNftTransfer(request: Array<NftTransferDetails>): Promise<CreateTransferResponse>;
+    /**
+     * Create a new Exchange transaction
+     *
+     * @param {UnsignedExchangeTransferRequest} request The unsigned exchange transfer request
+     * @return {Promise<CreateTransferResponseV1>} Returns a promise that resolves with the created Exchange Transaction
+     */
+    exchangeTransfer(request: UnsignedExchangeTransferRequest): Promise<CreateTransferResponseV1>;
+    /**
+     * Deposit either ETH, ERC20 or ERC721 tokens
+     *
+     * @param {TokenAmount} request The token type amount in its corresponding unit
+     * @return {Promise<TransactionResponse>} Returns a promise that resolves with the transaction
+     */
+    deposit(deposit: TokenAmount): Promise<TransactionResponse>;
+    /**
+     * Create a Withdrawal
+     *
+     * @param {TokenAmount} request The token type amount in its corresponding unit
+     * @return {Promise<CreateWithdrawalResponse>} Returns a promise that resolves with the created Withdrawal
+     */
+    prepareWithdrawal(request: TokenAmount): Promise<CreateWithdrawalResponse>;
+    /**
+     * Completes a Withdrawal
+     *
+     * @param {string} starkPublicKey The stark public key
+     * @param {AnyToken} token The token to withdraw
+     * @return {Promise<TransactionResponse>} Returns a promise that resolves with the transaction
+     */
+    completeWithdrawal(starkPublicKey: string, token: AnyToken): Promise<TransactionResponse>;
+}
+
+interface ProviderOverrides {
+    immutableXConfig: ImmutableXConfiguration;
+}
+interface ProviderModuleConfiguration extends ModuleConfiguration<ProviderOverrides> {
+}
+declare class ProviderConfiguration {
+    readonly immutableXConfig: ImmutableXConfiguration;
+    readonly baseConfig: ImmutableConfiguration;
+    constructor({ baseConfig, overrides }: ProviderModuleConfiguration);
+}
+
+declare class GenericIMXProvider implements IMXProvider {
+    private readonly config;
+    private readonly signers;
+    constructor(config: ProviderConfiguration, ethSigner: Signer, starkSigner: StarkSigner);
+    getAddress(): Promise<string>;
+    isRegisteredOffchain(): Promise<boolean>;
+    registerOffchain(): Promise<RegisterUserResponse>;
+    batchNftTransfer(request: Array<NftTransferDetails>): Promise<CreateTransferResponse>;
+    cancelOrder(request: GetSignableCancelOrderRequest): Promise<CancelOrderResponse>;
+    completeWithdrawal(starkPublicKey: string, token: AnyToken): Promise<TransactionResponse>;
+    createOrder(request: UnsignedOrderRequest): Promise<CreateOrderResponse>;
+    createTrade(request: GetSignableTradeRequest): Promise<CreateTradeResponse>;
+    deposit(tokenAmount: TokenAmount): Promise<TransactionResponse>;
+    exchangeTransfer(request: UnsignedExchangeTransferRequest): Promise<CreateTransferResponseV1>;
+    isRegisteredOnchain(): Promise<boolean>;
+    prepareWithdrawal(request: TokenAmount): Promise<CreateWithdrawalResponse>;
+    transfer(request: UnsignedTransferRequest): Promise<CreateTransferResponseV1>;
+}
+
+declare class MetaMaskIMXProvider extends GenericIMXProvider {
+    private static imxSigner;
+    static connect(config: ProviderConfiguration): Promise<MetaMaskIMXProvider>;
+    static disconnect(): Promise<void>;
+    static signMessage(message: string): Promise<string>;
+}
+
 interface ImxOverrides {
     immutableXConfig: ImmutableXConfiguration;
 }
 interface ImxModuleConfiguration extends ModuleConfiguration<ImxOverrides> {
 }
 
-declare class ImmutableXClient {
+declare class IMXClient {
     private immutableX;
     depositsApi: DepositsApi;
     mintsApi: MintsApi;
@@ -25738,201 +25888,6 @@ declare class ImmutableXClient {
     getNftPrimaryTransactions(request: NftCheckoutPrimaryApiGetNftPrimaryTransactionsRequest): Promise<NftprimarytransactionListTransactionsResponse>;
 }
 
-type immutablex_client_d_AnyToken = AnyToken;
-type immutablex_client_d_ERC20Amount = ERC20Amount;
-type immutablex_client_d_ERC20Token = ERC20Token;
-type immutablex_client_d_ERC721Token = ERC721Token;
-type immutablex_client_d_ETHAmount = ETHAmount;
-type immutablex_client_d_ETHToken = ETHToken;
-type immutablex_client_d_ExchangeTokenAmount = ExchangeTokenAmount;
-type immutablex_client_d_IMXError = IMXError;
-declare const immutablex_client_d_IMXError: typeof IMXError;
-type immutablex_client_d_ImmutableXClient = ImmutableXClient;
-declare const immutablex_client_d_ImmutableXClient: typeof ImmutableXClient;
-type immutablex_client_d_NftTransferDetails = NftTransferDetails;
-type immutablex_client_d_StarkSigner = StarkSigner;
-type immutablex_client_d_TokenAmount = TokenAmount;
-type immutablex_client_d_UnsignedExchangeTransferRequest = UnsignedExchangeTransferRequest;
-type immutablex_client_d_UnsignedMintRequest = UnsignedMintRequest;
-type immutablex_client_d_UnsignedOrderRequest = UnsignedOrderRequest;
-type immutablex_client_d_UnsignedTransferRequest = UnsignedTransferRequest;
-type immutablex_client_d_WalletConnection = WalletConnection;
-declare namespace immutablex_client_d {
-  export {
-    immutablex_client_d_AnyToken as AnyToken,
-    immutablex_client_d_ERC20Amount as ERC20Amount,
-    immutablex_client_d_ERC20Token as ERC20Token,
-    immutablex_client_d_ERC721Token as ERC721Token,
-    immutablex_client_d_ETHAmount as ETHAmount,
-    immutablex_client_d_ETHToken as ETHToken,
-    immutablex_client_d_ExchangeTokenAmount as ExchangeTokenAmount,
-    immutablex_client_d_IMXError as IMXError,
-    immutablex_client_d_ImmutableXClient as ImmutableXClient,
-    ImxModuleConfiguration as ImxClientModuleConfiguration,
-    WalletConnection as ImxClientWalletConnection,
-    immutablex_client_d_NftTransferDetails as NftTransferDetails,
-    immutablex_client_d_StarkSigner as StarkSigner,
-    immutablex_client_d_TokenAmount as TokenAmount,
-    immutablex_client_d_UnsignedExchangeTransferRequest as UnsignedExchangeTransferRequest,
-    immutablex_client_d_UnsignedMintRequest as UnsignedMintRequest,
-    immutablex_client_d_UnsignedOrderRequest as UnsignedOrderRequest,
-    immutablex_client_d_UnsignedTransferRequest as UnsignedTransferRequest,
-    immutablex_client_d_WalletConnection as WalletConnection,
-    createStarkSigner as imxClientCreateStarkSigner,
-    generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey,
-  };
-}
-
-declare enum PassportErrorType {
-    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
-    INVALID_CONFIGURATION = "INVALID_CONFIGURATION",
-    WALLET_CONNECTION_ERROR = "WALLET_CONNECTION_ERROR",
-    NOT_LOGGED_IN_ERROR = "NOT_LOGGED_IN_ERROR",
-    SILENT_LOGIN_ERROR = "SILENT_LOGIN_ERROR",
-    REFRESH_TOKEN_ERROR = "REFRESH_TOKEN_ERROR",
-    USER_REGISTRATION_ERROR = "USER_REGISTRATION_ERROR",
-    USER_NOT_REGISTERED_ERROR = "USER_NOT_REGISTERED_ERROR",
-    LOGOUT_ERROR = "LOGOUT_ERROR",
-    TRANSFER_ERROR = "TRANSFER_ERROR",
-    CREATE_ORDER_ERROR = "CREATE_ORDER_ERROR",
-    CANCEL_ORDER_ERROR = "CANCEL_ORDER_ERROR",
-    EXCHANGE_TRANSFER_ERROR = "EXCHANGE_TRANSFER_ERROR",
-    CREATE_TRADE_ERROR = "CREATE_TRADE_ERROR",
-    OPERATION_NOT_SUPPORTED_ERROR = "OPERATION_NOT_SUPPORTED_ERROR"
-}
-declare class PassportError extends Error {
-    type: PassportErrorType;
-    constructor(message: string, type: PassportErrorType);
-}
-
-interface IMXProvider {
-    /**
-     * Get the Signer address
-     *
-     * @return {Promise<string>} Returns a promise that resolves with the signer's address
-     */
-    getAddress(): Promise<string>;
-    /**
-     * Register a User to Immutable X if they are not already registered
-     *
-     * @return {Promise<RegisterUserResponse>} Returns a promise that resolves with the user registration response
-     */
-    registerOffchain(): Promise<RegisterUserResponse>;
-    /**
-     *  Checks if a User is registered off-chain
-     *
-     *  @return {Promise<boolean>} Returns a promise that resolves with true if the User is registered with IMX, false otherwise
-     */
-    isRegisteredOffchain(): Promise<boolean>;
-    /**
-     * Checks if a User is registered on-chain
-     *
-     * @return {Promise<boolean>} Returns a promise that resolves with true if the User is registered, false otherwise
-     */
-    isRegisteredOnchain(): Promise<boolean>;
-    /**
-     * Create an Order
-     *
-     * @param {UnsignedOrderRequest} request The unsigned order request to create an order
-     * @return {Promise<CreateOrderResponse>} Returns a promise that resolves with the created Order
-     */
-    createOrder(request: UnsignedOrderRequest): Promise<CreateOrderResponse>;
-    /**
-     * Cancel an Order
-     *
-     * @param {GetSignableCancelOrderRequest} request The signable cancel order request
-     * @return {Promise<CancelOrderResponse>} Returns a promise that resolves with the cancelled Order
-     */
-    cancelOrder(request: GetSignableCancelOrderRequest): Promise<CancelOrderResponse>;
-    /**
-     * Create a Trade
-     *
-     * @param {GetSignableTradeRequest} request The signable trade request
-     * @return {Promise<CreateTradeResponse>} Returns a promise that resolves with the created Trade
-     */
-    createTrade(request: GetSignableTradeRequest): Promise<CreateTradeResponse>;
-    /**
-     * Create a new Transfer request
-     *
-     * @param {UnsignedTransferRequest} request The unsigned transfer request
-     * @return {Promise<CreateTransferResponseV1>} Returns a promise that resolves with the created Transfer
-     */
-    transfer(request: UnsignedTransferRequest): Promise<CreateTransferResponseV1>;
-    /**
-     * Create a batch of NFT transfer requests
-     *
-     * @param {Array<NftTransferDetails>} request An array of NFT transfer details
-     * @return {Promise<CreateTransferResponse>} Resolves a promise that resolves with the list of Transfer IDs
-     */
-    batchNftTransfer(request: Array<NftTransferDetails>): Promise<CreateTransferResponse>;
-    /**
-     * Create a new Exchange transaction
-     *
-     * @param {UnsignedExchangeTransferRequest} request The unsigned exchange transfer request
-     * @return {Promise<CreateTransferResponseV1>} Returns a promise that resolves with the created Exchange Transaction
-     */
-    exchangeTransfer(request: UnsignedExchangeTransferRequest): Promise<CreateTransferResponseV1>;
-    /**
-     * Deposit either ETH, ERC20 or ERC721 tokens
-     *
-     * @param {TokenAmount} request The token type amount in its corresponding unit
-     * @return {Promise<TransactionResponse>} Returns a promise that resolves with the transaction
-     */
-    deposit(deposit: TokenAmount): Promise<TransactionResponse>;
-    /**
-     * Create a Withdrawal
-     *
-     * @param {TokenAmount} request The token type amount in its corresponding unit
-     * @return {Promise<CreateWithdrawalResponse>} Returns a promise that resolves with the created Withdrawal
-     */
-    prepareWithdrawal(request: TokenAmount): Promise<CreateWithdrawalResponse>;
-    /**
-     * Completes a Withdrawal
-     *
-     * @param {string} starkPublicKey The stark public key
-     * @param {AnyToken} token The token to withdraw
-     * @return {Promise<TransactionResponse>} Returns a promise that resolves with the transaction
-     */
-    completeWithdrawal(starkPublicKey: string, token: AnyToken): Promise<TransactionResponse>;
-}
-
-interface ProviderOverrides {
-    immutableXConfig: ImmutableXConfiguration;
-}
-interface ProviderModuleConfiguration extends ModuleConfiguration<ProviderOverrides> {
-}
-declare class ProviderConfiguration {
-    readonly immutableXConfig: ImmutableXConfiguration;
-    readonly baseConfig: ImmutableConfiguration;
-    constructor({ baseConfig, overrides }: ProviderModuleConfiguration);
-}
-
-declare class GenericIMXProvider implements IMXProvider {
-    private readonly config;
-    private readonly signers;
-    constructor(config: ProviderConfiguration, ethSigner: Signer, starkSigner: StarkSigner);
-    getAddress(): Promise<string>;
-    isRegisteredOffchain(): Promise<boolean>;
-    registerOffchain(): Promise<RegisterUserResponse>;
-    batchNftTransfer(request: Array<NftTransferDetails>): Promise<CreateTransferResponse>;
-    cancelOrder(request: GetSignableCancelOrderRequest): Promise<CancelOrderResponse>;
-    completeWithdrawal(starkPublicKey: string, token: AnyToken): Promise<TransactionResponse>;
-    createOrder(request: UnsignedOrderRequest): Promise<CreateOrderResponse>;
-    createTrade(request: GetSignableTradeRequest): Promise<CreateTradeResponse>;
-    deposit(tokenAmount: TokenAmount): Promise<TransactionResponse>;
-    exchangeTransfer(request: UnsignedExchangeTransferRequest): Promise<CreateTransferResponseV1>;
-    isRegisteredOnchain(): Promise<boolean>;
-    prepareWithdrawal(request: TokenAmount): Promise<CreateWithdrawalResponse>;
-    transfer(request: UnsignedTransferRequest): Promise<CreateTransferResponseV1>;
-}
-
-declare class MetaMaskIMXProvider extends GenericIMXProvider {
-    private static imxSigner;
-    static connect(config: ProviderConfiguration): Promise<MetaMaskIMXProvider>;
-    static disconnect(): Promise<void>;
-    static signMessage(message: string): Promise<string>;
-}
-
 type UserProfile = {
     email?: string;
     nickname?: string;
@@ -25952,7 +25907,7 @@ interface PassportOverrides {
     magicProviderId: string;
     passportDomain: string;
     imxPublicApiDomain: string;
-    immutableXClient: ImmutableXClient;
+    immutableXClient: IMXClient;
     imxApiClients: ImxApiClients;
     zkEvmRpcUrl: string;
     relayerUrl: string;
@@ -27301,22 +27256,6 @@ declare namespace orderbook_d {
   };
 }
 
-type provider_d_GenericIMXProvider = GenericIMXProvider;
-declare const provider_d_GenericIMXProvider: typeof GenericIMXProvider;
-type provider_d_IMXProvider = IMXProvider;
-type provider_d_MetaMaskIMXProvider = MetaMaskIMXProvider;
-declare const provider_d_MetaMaskIMXProvider: typeof MetaMaskIMXProvider;
-type provider_d_ProviderConfiguration = ProviderConfiguration;
-declare const provider_d_ProviderConfiguration: typeof ProviderConfiguration;
-declare namespace provider_d {
-  export {
-    provider_d_GenericIMXProvider as GenericIMXProvider,
-    provider_d_IMXProvider as IMXProvider,
-    provider_d_MetaMaskIMXProvider as MetaMaskIMXProvider,
-    provider_d_ProviderConfiguration as ProviderConfiguration,
-  };
-}
-
 /**
  * Enum representing different chain IDs.
  * @enum {number}
@@ -30287,4 +30226,60 @@ declare namespace checkout_d {
   };
 }
 
-export { blockchain_data_d as blockchainData, checkout_d as checkout, config_d as config, immutablex_client_d as immutablexClient, orderbook_d as orderbook, passport_d as passport, provider_d as provider };
+type x_d_AnyToken = AnyToken;
+type x_d_ERC20Amount = ERC20Amount;
+type x_d_ERC20Token = ERC20Token;
+type x_d_ERC721Token = ERC721Token;
+type x_d_ETHAmount = ETHAmount;
+type x_d_ETHToken = ETHToken;
+type x_d_ExchangeTokenAmount = ExchangeTokenAmount;
+type x_d_GenericIMXProvider = GenericIMXProvider;
+declare const x_d_GenericIMXProvider: typeof GenericIMXProvider;
+type x_d_IMXClient = IMXClient;
+declare const x_d_IMXClient: typeof IMXClient;
+type x_d_IMXError = IMXError;
+declare const x_d_IMXError: typeof IMXError;
+type x_d_IMXProvider = IMXProvider;
+type x_d_MetaMaskIMXProvider = MetaMaskIMXProvider;
+declare const x_d_MetaMaskIMXProvider: typeof MetaMaskIMXProvider;
+type x_d_NftTransferDetails = NftTransferDetails;
+type x_d_ProviderConfiguration = ProviderConfiguration;
+declare const x_d_ProviderConfiguration: typeof ProviderConfiguration;
+type x_d_StarkSigner = StarkSigner;
+type x_d_TokenAmount = TokenAmount;
+type x_d_UnsignedExchangeTransferRequest = UnsignedExchangeTransferRequest;
+type x_d_UnsignedMintRequest = UnsignedMintRequest;
+type x_d_UnsignedOrderRequest = UnsignedOrderRequest;
+type x_d_UnsignedTransferRequest = UnsignedTransferRequest;
+type x_d_WalletConnection = WalletConnection;
+declare namespace x_d {
+  export {
+    x_d_AnyToken as AnyToken,
+    x_d_ERC20Amount as ERC20Amount,
+    x_d_ERC20Token as ERC20Token,
+    x_d_ERC721Token as ERC721Token,
+    x_d_ETHAmount as ETHAmount,
+    x_d_ETHToken as ETHToken,
+    x_d_ExchangeTokenAmount as ExchangeTokenAmount,
+    x_d_GenericIMXProvider as GenericIMXProvider,
+    x_d_IMXClient as IMXClient,
+    x_d_IMXError as IMXError,
+    x_d_IMXProvider as IMXProvider,
+    ImxModuleConfiguration as ImxClientModuleConfiguration,
+    WalletConnection as ImxClientWalletConnection,
+    x_d_MetaMaskIMXProvider as MetaMaskIMXProvider,
+    x_d_NftTransferDetails as NftTransferDetails,
+    x_d_ProviderConfiguration as ProviderConfiguration,
+    x_d_StarkSigner as StarkSigner,
+    x_d_TokenAmount as TokenAmount,
+    x_d_UnsignedExchangeTransferRequest as UnsignedExchangeTransferRequest,
+    x_d_UnsignedMintRequest as UnsignedMintRequest,
+    x_d_UnsignedOrderRequest as UnsignedOrderRequest,
+    x_d_UnsignedTransferRequest as UnsignedTransferRequest,
+    x_d_WalletConnection as WalletConnection,
+    createStarkSigner as imxClientCreateStarkSigner,
+    generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey,
+  };
+}
+
+export { blockchain_data_d as blockchainData, checkout_d as checkout, config_d as config, orderbook_d as orderbook, passport_d as passport, x_d as x };