@imtbl/x-client 2.0.0-alpha.0

package/dist/types/IMXClient.d.ts

@@ -0,0 +1,334 @@
+import { ImxConfiguration, ImxModuleConfiguration } from './config';
+import type { AddMetadataSchemaToCollectionRequest, Asset, AssetsApi, AssetsApiGetAssetRequest, AssetsApiListAssetsRequest, Balance, BalancesApi, BalancesApiGetBalanceRequest, BalancesApiListBalancesRequest, Collection, CollectionFilter, CollectionsApi, CollectionsApiGetCollectionRequest, CollectionsApiListCollectionFiltersRequest, CollectionsApiListCollectionsRequest, CreateCollectionRequest, CreateMetadataRefreshRequest, CreateMetadataRefreshResponse, CreateTransferResponseV1, CurrencyWithLimits, Deposit, DepositsApi, DepositsApiGetDepositRequest, DepositsApiListDepositsRequest, EncodingApi, EthSigner, Exchange, ExchangeCreateExchangeAndURLResponse, ExchangesApi, ExchangesApiCreateExchangeRequest, ExchangesApiGetExchangeRequest, ExchangesApiGetExchangesRequest, GetMetadataRefreshErrorsResponse, GetMetadataRefreshes, GetMetadataRefreshResponse, GetTransactionsResponse, GetUsersApiResponse, ListAssetsResponse, ListBalancesResponse, ListCollectionsResponse, ListDepositsResponse, ListMintsResponse, ListOrdersResponseV3, ListTokensResponse, ListTradesResponse, ListTransfersResponse, ListWithdrawalsResponse, MetadataApi, MetadataApiGetMetadataSchemaRequest, MetadataRefreshesApi, MetadataSchemaProperty, MetadataSchemaRequest, Mint, MintsApi, MintsApiGetMintRequest, MintsApiListMintsRequest, MintTokensResponse, NftCheckoutPrimaryApi, NftCheckoutPrimaryApiCreateNftPrimaryRequest, NftCheckoutPrimaryApiGetCurrenciesNFTCheckoutPrimaryRequest, NftCheckoutPrimaryApiGetNftPrimaryTransactionRequest, NftCheckoutPrimaryApiGetNftPrimaryTransactionsRequest, NftprimarytransactionCreateResponse, NftprimarytransactionGetResponse, NftprimarytransactionListTransactionsResponse, OrdersApi, OrdersApiGetOrderV3Request, OrdersApiListOrdersV3Request, OrderV3, Project, ProjectsApi, SuccessResponse, TokenDetails, TokensApi, TokensApiGetTokenRequest, TokensApiListTokensRequest, Trade, TradesApi, TradesApiGetTradeV3Request, TradesApiListTradesV3Request, Transfer, TransfersApi, TransfersApiGetTransferRequest, TransfersApiListTransfersRequest, UnsignedExchangeTransferRequest, UnsignedMintRequest, UpdateCollectionRequest, UsersApi, WalletConnection, Withdrawal, WithdrawalsApi, WithdrawalsApiGetWithdrawalRequest, WithdrawalsApiListWithdrawalsRequest } from './types';
+import { Workflows } from './workflows';
+export declare class IMXClient {
+    private immutableX;
+    imxConfig: ImxConfiguration;
+    assetApi: AssetsApi;
+    balanceApi: BalancesApi;
+    collectionApi: CollectionsApi;
+    depositsApi: DepositsApi;
+    encodingApi: EncodingApi;
+    exchangeApi: ExchangesApi;
+    metadataApi: MetadataApi;
+    metadataRefreshesApi: MetadataRefreshesApi;
+    mintsApi: MintsApi;
+    nftCheckoutPrimaryApi: NftCheckoutPrimaryApi;
+    ordersApi: OrdersApi;
+    projectsApi: ProjectsApi;
+    tokensApi: TokensApi;
+    tradesApi: TradesApi;
+    transfersApi: TransfersApi;
+    usersApi: UsersApi;
+    withdrawalsApi: WithdrawalsApi;
+    workflows: Workflows;
+    constructor(config: ImxModuleConfiguration);
+    /**
+     * Get details of a Deposit with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Deposit
+     * @throws {@link IMXError}
+     */
+    getDeposit(request: DepositsApiGetDepositRequest): Promise<Deposit>;
+    /**
+     * Get a list of Deposits
+     * @param request - optional object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Deposits
+     * @throws {@link IMXError}
+     */
+    listDeposits(request?: DepositsApiListDepositsRequest): Promise<ListDepositsResponse>;
+    /**
+     * Get Stark keys for a registered User
+     * @param ethAddress - the eth address of the User
+     * @returns a promise that resolves with the requested User
+     * @throws {@link IMXError}
+     */
+    getUser(ethAddress: string): Promise<GetUsersApiResponse>;
+    /**
+     * Get details of an Asset
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Asset
+     * @throws {@link IMXError}
+     */
+    getAsset(request: AssetsApiGetAssetRequest): Promise<Asset>;
+    /**
+     * Get a list of Assets
+     * @param request - optional object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Assets
+     * @throws {@link IMXError}
+     */
+    listAssets(request?: AssetsApiListAssetsRequest): Promise<ListAssetsResponse>;
+    /**
+     * Create a Collection
+     * @param ethSigner - the L1 signer
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Collection
+     * @throws {@link IMXError}
+     */
+    createCollection(ethSigner: EthSigner, request: CreateCollectionRequest): Promise<Collection>;
+    /**
+     * Get details of a Collection at the given address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Collection
+     * @throws {@link IMXError}
+     */
+    getCollection(request: CollectionsApiGetCollectionRequest): Promise<Collection>;
+    /**
+     * Get a list of Collection filters
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Collection Filters
+     * @throws {@link IMXError}
+     */
+    listCollectionFilters(request: CollectionsApiListCollectionFiltersRequest): Promise<CollectionFilter[]>;
+    /**
+     * Get a list of Collections
+     * @param request - optional object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Collections
+     * @throws {@link IMXError}
+     */
+    listCollections(request?: CollectionsApiListCollectionsRequest): Promise<ListCollectionsResponse>;
+    /**
+     * Update a Collection
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the updated Collection
+     * @throws {@link IMXError}
+     */
+    updateCollection(ethSigner: EthSigner, collectionAddress: string, request: UpdateCollectionRequest): Promise<Collection>;
+    /**
+     * Add metadata schema to Collection
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the SuccessResponse if successful
+     * @throws {@link IMXError}
+     */
+    addMetadataSchemaToCollection(ethSigner: EthSigner, collectionAddress: string, request: AddMetadataSchemaToCollectionRequest): Promise<SuccessResponse>;
+    /**
+     * Get Metadata schema
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Metadata schema
+     * @throws {@link IMXError}
+     */
+    getMetadataSchema(request: MetadataApiGetMetadataSchemaRequest): Promise<MetadataSchemaProperty[]>;
+    /**
+     * Update metadata schema by name
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param name - the Metadata schema name
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the {@link SuccessResponse}
+     * @throws {@link IMXError}
+     */
+    updateMetadataSchemaByName(ethSigner: EthSigner, collectionAddress: string, name: string, request: MetadataSchemaRequest): Promise<SuccessResponse>;
+    /**
+     * Get a list of metadata refreshes
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @returns a promise that resolves with the requested metadata refreshes
+     * @throws {@link IMXError}
+     */
+    listMetadataRefreshes(ethSigner: EthSigner, collectionAddress?: string, pageSize?: number, cursor?: string): Promise<GetMetadataRefreshes>;
+    /**
+     * Get a list of metadata refresh errors
+     * @param ethSigner - the L1 signer
+     * @param refreshId - the metadata refresh ID
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @returns a promise that resolves with the requested metadata refresh errors
+     * @throws {@link IMXError}
+     */
+    getMetadataRefreshErrors(ethSigner: EthSigner, refreshId: string, pageSize?: number, cursor?: string): Promise<GetMetadataRefreshErrorsResponse>;
+    /**
+     * Get a list of metadata refresh results
+     * @param ethSigner - the L1 signer
+     * @param refreshId - the metadata refresh ID
+     * @returns a promise that resolves with the requested metadata refresh results
+     * @throws {@link IMXError}
+     */
+    getMetadataRefreshResults(ethSigner: EthSigner, refreshId: string): Promise<GetMetadataRefreshResponse>;
+    /**
+     * Request a metadata refresh
+     * @param ethSigner - the L1 signer
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested metadata refresh
+     * @throws {@link IMXError}
+     */
+    createMetadataRefresh(ethSigner: EthSigner, request: CreateMetadataRefreshRequest): Promise<CreateMetadataRefreshResponse>;
+    /**
+     * Get a Project
+     * @param ethSigner - the L1 signer
+     * @param id - the Project ID
+     * @returns a promise that resolves with the requested Project
+     * @throws {@link IMXError}
+     */
+    getProject(ethSigner: EthSigner, id: string): Promise<Project>;
+    /**
+     * Get the token Balances of the User
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Balance
+     * @throws {@link IMXError}
+     */
+    getBalance(request: BalancesApiGetBalanceRequest): Promise<Balance>;
+    /**
+     * Get a list of Balances for given User
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Balances
+     * @throws {@link IMXError}
+     */
+    listBalances(request: BalancesApiListBalancesRequest): Promise<ListBalancesResponse>;
+    /**
+     * Get details of a Mint with the given ID
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Mint
+     * @throws {@link IMXError}
+     */
+    getMint(request: MintsApiGetMintRequest): Promise<Mint[]>;
+    /**
+     * Get a list of Mints
+     * @param request optional object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Mints
+     * @throws {@link IMXError}
+     */
+    listMints(request?: MintsApiListMintsRequest): Promise<ListMintsResponse>;
+    /**
+     * Mint tokens in a batch with fees
+     * @param ethSigner - the L1 signer
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the minted tokens
+     * @throws {@link IMXError}
+     */
+    mint(ethSigner: EthSigner, request: UnsignedMintRequest): Promise<MintTokensResponse>;
+    /**
+     * Get a list of Withdrawals
+     * @param request - optional object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Withdrawals
+     * @throws {@link IMXError}
+     */
+    listWithdrawals(request?: WithdrawalsApiListWithdrawalsRequest): Promise<ListWithdrawalsResponse>;
+    /**
+     * Get details of Withdrawal with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Withdrawal
+     * @throws {@link IMXError}
+     */
+    getWithdrawal(request: WithdrawalsApiGetWithdrawalRequest): Promise<Withdrawal>;
+    /**
+     * Get details of an Order with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Order
+     * @throws {@link IMXError}
+     */
+    getOrder(request: OrdersApiGetOrderV3Request): 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 IMXError}
+     */
+    listOrders(request?: OrdersApiListOrdersV3Request): 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
+     * @returns a promise that resolves with the requested Trade
+     * @throws {@link IMXError}
+     */
+    getTrade(request: TradesApiGetTradeV3Request): Promise<Trade>;
+    /**
+     * Get a list of Trades
+     * @param request - optional object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Trades
+     * @throws {@link IMXError}
+     */
+    listTrades(request?: TradesApiListTradesV3Request): Promise<ListTradesResponse>;
+    /**
+     * Get details of a Token
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Token
+     * @throws {@link IMXError}
+     */
+    getToken(request: TokensApiGetTokenRequest): Promise<TokenDetails>;
+    /**
+     * Get a list of Tokens
+     * @param request - optional object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Tokens
+     * @throws {@link IMXError}
+     */
+    listTokens(request?: TokensApiListTokensRequest): Promise<ListTokensResponse>;
+    /**
+     * Get details of a Transfer with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Transfer
+     * @throws {@link IMXError}
+     */
+    getTransfer(request: TransfersApiGetTransferRequest): Promise<Transfer>;
+    /**
+     * Get a list of Transfers
+     * @param request - optional object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Transfers
+     * @throws {@link IMXError}
+     */
+    listTransfers(request?: TransfersApiListTransfersRequest): Promise<ListTransfersResponse>;
+    /**
+     * Create a new Exchange transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Exchange Transaction
+     * @throws {@link IMXError}
+     */
+    createExchange(request: ExchangesApiCreateExchangeRequest): Promise<ExchangeCreateExchangeAndURLResponse>;
+    /**
+     * Get an Exchange transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the Exchange Transaction
+     * @throws {@link IMXError}
+     */
+    getExchange(request: ExchangesApiGetExchangeRequest): Promise<Exchange>;
+    /**
+     * Get Exchange transactions
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with Exchange Transactions
+     * @throws {@link IMXError}
+     */
+    getExchanges(request: ExchangesApiGetExchangesRequest): Promise<GetTransactionsResponse>;
+    /**
+     * Create a new Transfer request
+     * @param walletConnection - the pair of Eth/Stark signers
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Exchange Transfer
+     * @throws {@link IMXError}
+     */
+    exchangeTransfer(walletConnection: WalletConnection, request: UnsignedExchangeTransferRequest): Promise<CreateTransferResponseV1>;
+    /**
+     * Create a new nft primary transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created nft primary Transaction
+     * @throws {@link IMXError}
+     */
+    createNftPrimary(request: NftCheckoutPrimaryApiCreateNftPrimaryRequest): Promise<NftprimarytransactionCreateResponse>;
+    /**
+     * Get nft primary supported currencies and their limits
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary Currencies
+     * @throws {@link IMXError}
+     */
+    getCurrenciesNFTCheckoutPrimary(request: NftCheckoutPrimaryApiGetCurrenciesNFTCheckoutPrimaryRequest): Promise<CurrencyWithLimits>;
+    /**
+     * Get nft primary transaction by transaction id
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary transaction
+     * @throws {@link IMXError}
+     */
+    getNftPrimaryTransaction(request: NftCheckoutPrimaryApiGetNftPrimaryTransactionRequest): Promise<NftprimarytransactionGetResponse>;
+    /**
+     * Get list of nft primary transactions
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary transaction
+     * @throws {@link IMXError}
+     */
+    getNftPrimaryTransactions(request: NftCheckoutPrimaryApiGetNftPrimaryTransactionsRequest): Promise<NftprimarytransactionListTransactionsResponse>;
+}
+export declare class ImmutableX extends IMXClient {
+}

package/dist/types/config/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/config/index.d.ts

@@ -0,0 +1,77 @@
+import { imx } from '@imtbl/generated-clients';
+import { Environment, ImmutableConfiguration, ModuleConfiguration } from '@imtbl/config';
+export { Environment, ImmutableConfiguration } from '@imtbl/config';
+export declare class ApiConfiguration extends imx.Configuration {
+}
+interface ImmutableXConfigurationParams {
+    basePath: string;
+    chainID: number;
+    coreContractAddress: string;
+    registrationContractAddress: string;
+    registrationV4ContractAddress?: string;
+    baseConfig?: ImmutableConfiguration;
+}
+export interface EthConfiguration {
+    coreContractAddress: string;
+    registrationContractAddress: string;
+    registrationV4ContractAddress?: string;
+    chainID: number;
+}
+interface ImxEnvironment extends EthConfiguration {
+    basePath: string;
+    headers?: Record<string, string>;
+    sdkVersion?: string;
+    baseConfig?: ImmutableConfiguration;
+}
+export interface ImmutableXConfiguration {
+    /**
+     * The configuration for the API client
+     */
+    apiConfiguration: ApiConfiguration;
+    /**
+     * The configuration for the Ethereum network
+     */
+    ethConfiguration: EthConfiguration;
+}
+/**
+ * @dev use createImmutableXConfiguration instead
+ */
+export declare const createConfig: ({ coreContractAddress, registrationContractAddress, registrationV4ContractAddress, chainID, basePath, headers, sdkVersion, baseConfig, }: ImxEnvironment) => ImmutableXConfiguration;
+/**
+ * createImmutableXConfiguration to create a custom ImmutableXConfiguration
+ * other than the production and sandbox defined below.
+ */
+export declare const createImmutableXConfiguration: ({ basePath, chainID, coreContractAddress, registrationContractAddress, registrationV4ContractAddress, baseConfig, }: ImmutableXConfigurationParams) => ImmutableXConfiguration;
+interface environmentConfig {
+    baseConfig?: ImmutableConfiguration;
+}
+export declare const production: ({ baseConfig }: environmentConfig) => ImmutableXConfiguration;
+export declare const sandbox: ({ baseConfig }: environmentConfig) => ImmutableXConfiguration;
+export interface ImxOverrides {
+    immutableXConfig: ImmutableXConfiguration;
+}
+export interface ImxModuleConfiguration extends ModuleConfiguration<ImxOverrides> {
+}
+export declare class ImxConfiguration {
+    readonly immutableXConfig: ImmutableXConfiguration;
+    readonly baseConfig: ImmutableConfiguration;
+    constructor({ baseConfig, overrides }: ImxModuleConfiguration);
+}
+export interface ConfigOptions {
+    environment: Environment;
+    apiKey?: string;
+    publishableKey?: string;
+    rateLimitingKey?: string;
+}
+/**
+ * @name imxClientConfig
+ * @description Helper method to create a standard ImxModuleConfiguration
+ * object for the IMXClient class. If you need to override the default
+ * configuration, manually construct the ImxModuleConfiguration object.
+ * @param configOptions {ConfigOptions} The configuration options
+ * @param configOptions.environment {Environment} The environment to connect to
+ * @param configOptions.apkKey {string} The API key from Immutable Hub
+ * @param configOptions.publishableKey {string} The publishable key from Immutable Hub
+ * @returns {ImxModuleConfiguration}
+ */
+export declare const imxClientConfig: (configOptions: ConfigOptions) => ImxModuleConfiguration;

package/dist/types/contracts/@openzeppelin/contracts/index.d.ts

@@ -0,0 +1,4 @@
+import type * as token from "./token";
+export type { token };
+import type * as utils from "./utils";
+export type { utils };

package/dist/types/contracts/@openzeppelin/contracts/token/ERC20/IERC20.d.ts

@@ -0,0 +1,129 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IERC20Interface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IERC20 extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC20;
+    waitForDeployment(): Promise<this>;
+    interface: IERC20Interface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

package/dist/types/contracts/@openzeppelin/contracts/token/ERC20/index.d.ts

@@ -0,0 +1 @@
+export type { IERC20 } from "./IERC20";