@alephium/web3 0.0.1-test.0

package/dist/src/api/api-explorer.d.ts

@@ -0,0 +1,475 @@
+export interface AddressBalance {
+    /** @format uint256 */
+    balance: string;
+    /** @format uint256 */
+    lockedBalance: string;
+}
+export interface AddressInfo {
+    /** @format uint256 */
+    balance: string;
+    /** @format uint256 */
+    lockedBalance: string;
+    /** @format int32 */
+    txNumber: number;
+}
+export interface BadRequest {
+    detail: string;
+}
+export interface BlockEntryLite {
+    /** @format block-hash */
+    hash: string;
+    /** @format int64 */
+    timestamp: number;
+    /** @format int32 */
+    chainFrom: number;
+    /** @format int32 */
+    chainTo: number;
+    /** @format int32 */
+    height: number;
+    /** @format int32 */
+    txNumber: number;
+    mainChain: boolean;
+    /** @format bigint */
+    hashRate: string;
+}
+export interface ConfirmedTransaction {
+    /** @format 32-byte-hash */
+    hash: string;
+    /** @format block-hash */
+    blockHash: string;
+    /** @format int64 */
+    timestamp: number;
+    inputs?: Input[];
+    outputs?: Output[];
+    /** @format int32 */
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    type: string;
+}
+export interface ExplorerInfo {
+    releaseVersion: string;
+    commit: string;
+}
+export interface Hashrate {
+    /** @format int64 */
+    timestamp: number;
+    hashrate: number;
+    value: number;
+}
+export interface Input {
+    outputRef: OutputRef;
+    unlockScript?: string;
+    /** @format 32-byte-hash */
+    txHashRef: string;
+    address: string;
+    /** @format uint256 */
+    amount: string;
+}
+export interface InternalServerError {
+    detail: string;
+}
+export interface ListBlocks {
+    /** @format int32 */
+    total: number;
+    blocks?: BlockEntryLite[];
+}
+export interface NotFound {
+    detail: string;
+    resource: string;
+}
+export interface Output {
+    /** @format int32 */
+    hint: number;
+    /** @format 32-byte-hash */
+    key: string;
+    /** @format uint256 */
+    amount: string;
+    address: string;
+    /** @format int64 */
+    lockTime?: number;
+    /** @format 32-byte-hash */
+    spent?: string;
+}
+export interface OutputRef {
+    /** @format int32 */
+    hint: number;
+    /** @format 32-byte-hash */
+    key: string;
+}
+export interface PerChainCount {
+    /** @format int32 */
+    chainFrom: number;
+    /** @format int32 */
+    chainTo: number;
+    /** @format int64 */
+    count: number;
+}
+export interface PerChainDuration {
+    /** @format int32 */
+    chainFrom: number;
+    /** @format int32 */
+    chainTo: number;
+    /** @format int64 */
+    duration: number;
+    /** @format int64 */
+    value: number;
+}
+export interface PerChainHeight {
+    /** @format int32 */
+    chainFrom: number;
+    /** @format int32 */
+    chainTo: number;
+    /** @format int64 */
+    height: number;
+    /** @format int64 */
+    value: number;
+}
+export interface PerChainTimedCount {
+    /** @format int64 */
+    timestamp: number;
+    totalCountPerChain?: PerChainCount[];
+}
+export interface ServiceUnavailable {
+    detail: string;
+}
+export interface TimedCount {
+    /** @format int64 */
+    timestamp: number;
+    /** @format int64 */
+    totalCountAllChains: number;
+}
+export interface TokenSupply {
+    /** @format int64 */
+    timestamp: number;
+    /** @format uint256 */
+    total: string;
+    /** @format uint256 */
+    circulating: string;
+    /** @format uint256 */
+    reserved: string;
+    /** @format uint256 */
+    locked: string;
+    /** @format uint256 */
+    maximum: string;
+}
+export interface Transaction {
+    /** @format 32-byte-hash */
+    hash: string;
+    /** @format block-hash */
+    blockHash: string;
+    /** @format int64 */
+    timestamp: number;
+    inputs?: Input[];
+    outputs?: Output[];
+    /** @format int32 */
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+}
+export declare type TransactionLike = ConfirmedTransaction | UnconfirmedTransaction;
+export interface UInput {
+    outputRef: OutputRef;
+    unlockScript?: string;
+}
+export interface UOutput {
+    /** @format uint256 */
+    amount: string;
+    address: string;
+    /** @format int64 */
+    lockTime?: number;
+}
+export interface Unauthorized {
+    detail: string;
+}
+export interface UnconfirmedTransaction {
+    /** @format 32-byte-hash */
+    hash: string;
+    /** @format int32 */
+    chainFrom: number;
+    /** @format int32 */
+    chainTo: number;
+    inputs?: UInput[];
+    outputs?: UOutput[];
+    /** @format int32 */
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    type: string;
+}
+import 'cross-fetch/polyfill';
+export declare type QueryParamsType = Record<string | number, any>;
+export declare type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
+export interface FullRequestParams extends Omit<RequestInit, 'body'> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseFormat;
+    /** request body */
+    body?: unknown;
+    /** base url */
+    baseUrl?: string;
+    /** request cancellation token */
+    cancelToken?: CancelToken;
+}
+export declare type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export interface ApiConfig<SecurityDataType = unknown> {
+    baseUrl?: string;
+    baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
+    customFetch?: typeof fetch;
+}
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+declare type CancelToken = Symbol | string | number;
+export declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    baseUrl: string;
+    private securityData;
+    private securityWorker?;
+    private abortControllers;
+    private customFetch;
+    private baseApiParams;
+    constructor(apiConfig?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    private encodeQueryParam;
+    private addQueryParam;
+    private addArrayQueryParam;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    protected addQueryParams(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    private mergeRequestParams;
+    private createAbortSignal;
+    abortRequest: (cancelToken: CancelToken) => void;
+    request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<HttpResponse<T, E>>;
+}
+/**
+ * @title Alephium Explorer API
+ * @version 1.0
+ */
+export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    blocks: {
+        /**
+         * @description List blocks within time interval
+         *
+         * @tags Blocks
+         * @name GetBlocks
+         * @request GET:/blocks
+         */
+        getBlocks: (query?: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            reverse?: boolean | undefined;
+        } | undefined, params?: RequestParams) => Promise<ListBlocks>;
+        /**
+         * @description Get a block with hash
+         *
+         * @tags Blocks
+         * @name GetBlocksBlockHash
+         * @request GET:/blocks/{block-hash}
+         */
+        getBlocksBlockHash: (blockHash: string, params?: RequestParams) => Promise<BlockEntryLite>;
+        /**
+         * @description Get block's transactions
+         *
+         * @tags Blocks
+         * @name GetBlocksBlockHashTransactions
+         * @request GET:/blocks/{block-hash}/transactions
+         */
+        getBlocksBlockHashTransactions: (blockHash: string, query?: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            reverse?: boolean | undefined;
+        } | undefined, params?: RequestParams) => Promise<Transaction[]>;
+    };
+    transactions: {
+        /**
+         * @description Get a transaction with hash
+         *
+         * @tags Transactions
+         * @name GetTransactionsTransactionHash
+         * @request GET:/transactions/{transaction-hash}
+         */
+        getTransactionsTransactionHash: (transactionHash: string, params?: RequestParams) => Promise<ConfirmedTransaction | UnconfirmedTransaction>;
+    };
+    addresses: {
+        /**
+         * @description Get address information
+         *
+         * @tags Addresses
+         * @name GetAddressesAddress
+         * @request GET:/addresses/{address}
+         */
+        getAddressesAddress: (address: string, params?: RequestParams) => Promise<AddressInfo>;
+        /**
+         * @description List transactions of a given address
+         *
+         * @tags Addresses
+         * @name GetAddressesAddressTransactions
+         * @request GET:/addresses/{address}/transactions
+         */
+        getAddressesAddressTransactions: (address: string, query?: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            reverse?: boolean | undefined;
+        } | undefined, params?: RequestParams) => Promise<Transaction[]>;
+        /**
+         * @description Get total transactions of a given address
+         *
+         * @tags Addresses
+         * @name GetAddressesAddressTotalTransactions
+         * @request GET:/addresses/{address}/total-transactions
+         */
+        getAddressesAddressTotalTransactions: (address: string, params?: RequestParams) => Promise<number>;
+        /**
+         * @description Get address balance
+         *
+         * @tags Addresses
+         * @name GetAddressesAddressBalance
+         * @request GET:/addresses/{address}/balance
+         */
+        getAddressesAddressBalance: (address: string, params?: RequestParams) => Promise<AddressBalance>;
+    };
+    infos: {
+        /**
+         * @description Get explorer informations
+         *
+         * @tags Infos
+         * @name GetInfos
+         * @request GET:/infos
+         */
+        getInfos: (params?: RequestParams) => Promise<ExplorerInfo>;
+        /**
+         * @description List latest height for each chain
+         *
+         * @tags Infos
+         * @name GetInfosHeights
+         * @request GET:/infos/heights
+         */
+        getInfosHeights: (params?: RequestParams) => Promise<PerChainHeight[]>;
+        /**
+         * @description Get token supply list
+         *
+         * @tags Infos
+         * @name GetInfosSupply
+         * @request GET:/infos/supply
+         */
+        getInfosSupply: (query?: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            reverse?: boolean | undefined;
+        } | undefined, params?: RequestParams) => Promise<TokenSupply[]>;
+        /**
+         * @description Get the ALPH total supply
+         *
+         * @tags Infos
+         * @name GetInfosSupplyTotalAlph
+         * @request GET:/infos/supply/total-alph
+         */
+        getInfosSupplyTotalAlph: (params?: RequestParams) => Promise<number>;
+        /**
+         * @description Get the ALPH circulating supply
+         *
+         * @tags Infos
+         * @name GetInfosSupplyCirculatingAlph
+         * @request GET:/infos/supply/circulating-alph
+         */
+        getInfosSupplyCirculatingAlph: (params?: RequestParams) => Promise<number>;
+        /**
+         * @description Get the ALPH reserved supply
+         *
+         * @tags Infos
+         * @name GetInfosSupplyReservedAlph
+         * @request GET:/infos/supply/reserved-alph
+         */
+        getInfosSupplyReservedAlph: (params?: RequestParams) => Promise<number>;
+        /**
+         * @description Get the ALPH locked supply
+         *
+         * @tags Infos
+         * @name GetInfosSupplyLockedAlph
+         * @request GET:/infos/supply/locked-alph
+         */
+        getInfosSupplyLockedAlph: (params?: RequestParams) => Promise<number>;
+        /**
+         * @description Get the total number of transactions
+         *
+         * @tags Infos
+         * @name GetInfosTotalTransactions
+         * @request GET:/infos/total-transactions
+         */
+        getInfosTotalTransactions: (params?: RequestParams) => Promise<number>;
+        /**
+         * @description Get the average block time for each chain
+         *
+         * @tags Infos
+         * @name GetInfosAverageBlockTimes
+         * @request GET:/infos/average-block-times
+         */
+        getInfosAverageBlockTimes: (params?: RequestParams) => Promise<PerChainDuration[]>;
+    };
+    charts: {
+        /**
+         * @description `interval-type` query param: hourly, daily
+         *
+         * @tags Charts
+         * @name GetChartsHashrates
+         * @summary Get hashrate chart in H/s
+         * @request GET:/charts/hashrates
+         */
+        getChartsHashrates: (query: {
+            fromTs: number;
+            toTs: number;
+            'interval-type': string;
+        }, params?: RequestParams) => Promise<Hashrate[]>;
+        /**
+         * @description `interval-type` query param: hourly, daily
+         *
+         * @tags Charts
+         * @name GetChartsTransactionsCount
+         * @summary Get transaction count history
+         * @request GET:/charts/transactions-count
+         */
+        getChartsTransactionsCount: (query: {
+            fromTs: number;
+            toTs: number;
+            'interval-type': string;
+        }, params?: RequestParams) => Promise<TimedCount[]>;
+        /**
+         * @description `interval-type` query param: hourly, daily
+         *
+         * @tags Charts
+         * @name GetChartsTransactionsCountPerChain
+         * @summary Get transaction count history per chain
+         * @request GET:/charts/transactions-count-per-chain
+         */
+        getChartsTransactionsCountPerChain: (query: {
+            fromTs: number;
+            toTs: number;
+            'interval-type': string;
+        }, params?: RequestParams) => Promise<PerChainTimedCount[]>;
+    };
+    utils: {
+        /**
+         * @description Perform a sanity check
+         *
+         * @tags Utils
+         * @name PutUtilsSanityCheck
+         * @request PUT:/utils/sanity-check
+         */
+        putUtilsSanityCheck: (params?: RequestParams) => Promise<void>;
+    };
+}
+export {};