@alephium/web3 0.2.0-test.1 → 0.2.2

package/src/api/api-explorer.ts

@@ -28,6 +28,29 @@ export interface AddressInfo {
   txNumber: number
 }
 
+export interface AssetOutput {
+  /** @format int32 */
+  hint: number
+
+  /** @format 32-byte-hash */
+  key: string
+
+  /** @format uint256 */
+  attoAlphAmount: string
+  address: string
+  tokens?: Token[]
+
+  /** @format int64 */
+  lockTime?: number
+
+  /** @format hex-string */
+  message?: string
+
+  /** @format 32-byte-hash */
+  spent?: string
+  type: string
+}
+
 export interface BadRequest {
   detail: string
 }
@@ -76,6 +99,23 @@ export interface ConfirmedTransaction {
   type: string
 }
 
+export interface ContractOutput {
+  /** @format int32 */
+  hint: number
+
+  /** @format 32-byte-hash */
+  key: string
+
+  /** @format uint256 */
+  attoAlphAmount: string
+  address: string
+  tokens?: Token[]
+
+  /** @format 32-byte-hash */
+  spent?: string
+  type: string
+}
+
 export interface ExplorerInfo {
   releaseVersion: string
   commit: string
@@ -90,14 +130,14 @@ export interface Hashrate {
 
 export interface Input {
   outputRef: OutputRef
-  unlockScript?: string
 
-  /** @format 32-byte-hash */
-  txHashRef: string
-  address: string
+  /** @format hex-string */
+  unlockScript?: string
+  address?: string
 
   /** @format uint256 */
-  amount: string
+  attoAlphAmount?: string
+  tokens?: Token[]
 }
 
 export interface InternalServerError {
@@ -110,28 +150,17 @@ export interface ListBlocks {
   blocks?: BlockEntryLite[]
 }
 
+export interface LogbackValue {
+  name: string
+  level: string
+}
+
 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 type Output = AssetOutput | ContractOutput
 
 export interface OutputRef {
   /** @format int32 */
@@ -198,6 +227,14 @@ export interface TimedCount {
   totalCountAllChains: number
 }
 
+export interface Token {
+  /** @format 32-byte-hash */
+  id: string
+
+  /** @format uint256 */
+  amount: string
+}
+
 export interface TokenSupply {
   /** @format int64 */
   timestamp: number
@@ -239,20 +276,6 @@ export interface Transaction {
 
 export 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
 }
@@ -266,28 +289,22 @@ export interface UnconfirmedTransaction {
 
   /** @format int32 */
   chainTo: number
-  inputs?: UInput[]
-  outputs?: UOutput[]
+  inputs?: Input[]
+  outputs?: Output[]
 
   /** @format int32 */
   gasAmount: number
 
   /** @format uint256 */
   gasPrice: string
+
+  /** @format int64 */
+  lastSeen: number
   type: string
 }
 
 import 'cross-fetch/polyfill'
-
-function convertHttpResponse<T>(
-  response: HttpResponse<T, { detail: string }> | HttpResponse<T, { detail: string }>
-): T {
-  if (response.error) {
-    throw new Error(response.error.detail)
-  } else {
-    return response.data
-  }
-}
+import { convertHttpResponse } from './utils'
 
 export type QueryParamsType = Record<string | number, any>
 export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>
@@ -491,7 +508,6 @@ export class HttpClient<SecurityDataType = unknown> {
         this.abortControllers.delete(cancelToken)
       }
 
-      if (!response.ok) throw data
       return data
     })
   }
@@ -524,7 +540,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      *
      * @tags Blocks
      * @name GetBlocksBlockHash
-     * @request GET:/blocks/{block-hash}
+     * @request GET:/blocks/{block_hash}
      */
     getBlocksBlockHash: (blockHash: string, params: RequestParams = {}) =>
       this.request<BlockEntryLite, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
@@ -539,7 +555,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      *
      * @tags Blocks
      * @name GetBlocksBlockHashTransactions
-     * @request GET:/blocks/{block-hash}/transactions
+     * @request GET:/blocks/{block_hash}/transactions
      */
     getBlocksBlockHashTransactions: (
       blockHash: string,
@@ -560,7 +576,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      *
      * @tags Transactions
      * @name GetTransactionsTransactionHash
-     * @request GET:/transactions/{transaction-hash}
+     * @request GET:/transactions/{transaction_hash}
      */
     getTransactionsTransactionHash: (transactionHash: string, params: RequestParams = {}) =>
       this.request<TransactionLike, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
@@ -568,6 +584,21 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         method: 'GET',
         format: 'json',
         ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get a transaction from a output reference key
+     *
+     * @tags Transactions
+     * @name GetTransactionsByOutputRefKeyOutputRefKey
+     * @request GET:/transactions/by/output-ref-key/{output_ref_key}
+     */
+    getTransactionsByOutputRefKeyOutputRefKey: (outputRefKey: string, params: RequestParams = {}) =>
+      this.request<Transaction, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/transactions/by/output-ref-key/${outputRefKey}`,
+        method: 'GET',
+        format: 'json',
+        ...params
       }).then(convertHttpResponse)
   }
   addresses = {
@@ -606,6 +637,26 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description List transactions of a given address within a time-range
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressTimerangedTransactions
+     * @request GET:/addresses/{address}/timeranged-transactions
+     */
+    getAddressesAddressTimerangedTransactions: (
+      address: string,
+      query: { fromTs: number; toTs: number; page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/timeranged-transactions`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description Get total transactions of a given address
      *
@@ -621,6 +672,21 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description List unconfirmed transactions of a given address
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressUnconfirmedTransactions
+     * @request GET:/addresses/{address}/unconfirmed-transactions
+     */
+    getAddressesAddressUnconfirmedTransactions: (address: string, params: RequestParams = {}) =>
+      this.request<TransactionLike[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/unconfirmed-transactions`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description Get address balance
      *
@@ -634,6 +700,75 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         method: 'GET',
         format: 'json',
         ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description List address tokens
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressTokens
+     * @request GET:/addresses/{address}/tokens
+     */
+    getAddressesAddressTokens: (address: string, params: RequestParams = {}) =>
+      this.request<string[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/tokens`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description List address tokens
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressTokensTokenIdTransactions
+     * @request GET:/addresses/{address}/tokens/{token_id}/transactions
+     */
+    getAddressesAddressTokensTokenIdTransactions: (
+      address: string,
+      tokenId: string,
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/tokens/${tokenId}/transactions`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get address balance of given token
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressTokensTokenIdBalance
+     * @request GET:/addresses/{address}/tokens/{token_id}/balance
+     */
+    getAddressesAddressTokensTokenIdBalance: (address: string, tokenId: string, params: RequestParams = {}) =>
+      this.request<AddressBalance, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/tokens/${tokenId}/balance`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
+  addressesActive = {
+    /**
+     * @description Are the addresses active (at least 1 transaction)
+     *
+     * @tags Addresses
+     * @name PostAddressesActive
+     * @request POST:/addresses-active
+     */
+    postAddressesActive: (data?: string[], params: RequestParams = {}) =>
+      this.request<boolean[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses-active`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
       }).then(convertHttpResponse)
   }
   infos = {
@@ -770,6 +905,63 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         }
       ).then(convertHttpResponse)
   }
+  unconfirmedTransactions = {
+    /**
+     * @description list unconfirmed transactions
+     *
+     * @tags Transactions
+     * @name GetUnconfirmedTransactions
+     * @request GET:/unconfirmed-transactions
+     */
+    getUnconfirmedTransactions: (
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<TransactionLike[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/unconfirmed-transactions`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
+  tokens = {
+    /**
+     * @description List tokens
+     *
+     * @tags Tokens
+     * @name GetTokens
+     * @request GET:/tokens
+     */
+    getTokens: (query?: { page?: number; limit?: number; reverse?: boolean }, params: RequestParams = {}) =>
+      this.request<string[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description List token transactions
+     *
+     * @tags Tokens
+     * @name GetTokensTokenIdTransactions
+     * @request GET:/tokens/{token_id}/transactions
+     */
+    getTokensTokenIdTransactions: (
+      tokenId: string,
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens/${tokenId}/transactions`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
   charts = {
     /**
      * @description `interval-type` query param: hourly, daily
@@ -865,17 +1057,18 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description Update logging file, only logback.xml is accepted
+     * @description Update logback values
      *
      * @tags Utils
      * @name PutUtilsUpdateLogConfig
      * @request PUT:/utils/update-log-config
      */
-    putUtilsUpdateLogConfig: (data: string, params: RequestParams = {}) =>
+    putUtilsUpdateLogConfig: (data?: LogbackValue[], params: RequestParams = {}) =>
       this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/utils/update-log-config`,
         method: 'PUT',
         body: data,
+        type: ContentType.Json,
         ...params
       }).then(convertHttpResponse)
   }

package/src/api/index.ts

@@ -19,17 +19,151 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import { Api as NodeApi } from './api-alephium'
 import { Api as ExplorerApi } from './api-explorer'
 
-export class NodeProvider extends NodeApi<null> {
-  constructor(baseUrl: string) {
-    super({ baseUrl: baseUrl })
+export interface ApiRequestArguments {
+  path: string
+  method: string
+  params: any[]
+}
+export type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>
+
+function forwardRequests(api: Record<string, any>, handler: ApiRequestHandler): void {
+  // Update class properties to forward requests
+  for (const [path, pathObject] of Object.entries(api)) {
+    for (const method of Object.keys(pathObject)) {
+      pathObject[`${method}`] = async (...params: any): Promise<any> => {
+        return handler({ path, method, params })
+      }
+    }
   }
 }
 
-export class ExplorerProvider extends ExplorerApi<null> {
-  constructor(baseUrl: string) {
-    super({ baseUrl: baseUrl })
+async function request(provider: Record<string, any>, args: ApiRequestArguments): Promise<any> {
+  const call = provider[`${args.path}`][`${args.method}`] as (...any) => Promise<any>
+  return call(...args.params)
+}
+
+function initializeNodeApi(baseUrl: string, apiKey?: string): NodeApi<string> {
+  const nodeApi = new NodeApi<string>({
+    baseUrl: baseUrl,
+    baseApiParams: { secure: true },
+    securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+  })
+  nodeApi.setSecurityData(apiKey ?? null)
+  return nodeApi
+}
+
+export class NodeProvider {
+  readonly wallets: NodeApi<string>['wallets']
+  readonly infos: NodeApi<string>['infos']
+  readonly blockflow: NodeApi<string>['blockflow']
+  readonly addresses: NodeApi<string>['addresses']
+  readonly transactions: NodeApi<string>['transactions']
+  readonly contracts: NodeApi<string>['contracts']
+  readonly multisig: NodeApi<string>['multisig']
+  readonly utils: NodeApi<string>['utils']
+  readonly miners: NodeApi<string>['miners']
+  readonly events: NodeApi<string>['events']
+
+  constructor(baseUrl: string, apiKey?: string)
+  constructor(provider: NodeProvider)
+  constructor(handler: ApiRequestHandler)
+  constructor(param0: string | NodeProvider | ApiRequestHandler, apiKey?: string) {
+    let nodeApi: NodeProvider
+    if (typeof param0 === 'string') {
+      nodeApi = initializeNodeApi(param0, apiKey)
+    } else if (typeof param0 === 'function') {
+      nodeApi = new NodeProvider('https://1.2.3.4:0')
+      forwardRequests(nodeApi, param0 as ApiRequestHandler)
+    } else {
+      nodeApi = param0 as NodeProvider
+    }
+
+    this.wallets = { ...nodeApi.wallets }
+    this.infos = { ...nodeApi.infos }
+    this.blockflow = { ...nodeApi.blockflow }
+    this.addresses = { ...nodeApi.addresses }
+    this.transactions = { ...nodeApi.transactions }
+    this.contracts = { ...nodeApi.contracts }
+    this.multisig = { ...nodeApi.multisig }
+    this.utils = { ...nodeApi.utils }
+    this.miners = { ...nodeApi.miners }
+    this.events = { ...nodeApi.events }
+  }
+
+  request = (args: ApiRequestArguments): Promise<any> => {
+    return request(this, args)
+  }
+
+  // This can prevent the proxied node provider from being modified
+  static Proxy(nodeProvider: NodeProvider): NodeProvider {
+    return new NodeProvider(nodeProvider)
+  }
+
+  static Remote(handler: ApiRequestHandler): NodeProvider {
+    return new NodeProvider(handler)
+  }
+}
+
+function initializeExplorerApi(baseUrl: string, apiKey?: string): ExplorerApi<string> {
+  const explorerApi = new ExplorerApi<string>({
+    baseUrl: baseUrl,
+    baseApiParams: { secure: true },
+    securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+  })
+  explorerApi.setSecurityData(apiKey ?? null)
+  return explorerApi
+}
+
+export class ExplorerProvider {
+  readonly blocks = ExplorerApi['blocks']
+  readonly transactions = ExplorerApi['transactions']
+  readonly addresses = ExplorerApi['addresses']
+  readonly addressesActive = ExplorerApi['addressesActive']
+  readonly infos = ExplorerApi['infos']
+  readonly unconfirmedTransactions = ExplorerApi['unconfirmedTransactions']
+  readonly tokens = ExplorerApi['tokens']
+  readonly charts = ExplorerApi['charts']
+  readonly utils = ExplorerApi['utils']
+
+  constructor(baseUrl: string, apiKey?: string)
+  constructor(provider: ExplorerProvider)
+  constructor(handler: ApiRequestHandler)
+  constructor(param0: string | ExplorerProvider | ApiRequestHandler, apiKey?: string) {
+    let explorerApi: ExplorerProvider
+    if (typeof param0 === 'string') {
+      explorerApi = initializeExplorerApi(param0, apiKey)
+    } else if (typeof param0 === 'function') {
+      explorerApi = new ExplorerProvider('https://1.2.3.4:0')
+      forwardRequests(explorerApi, param0 as ApiRequestHandler)
+    } else {
+      explorerApi = param0 as ExplorerProvider
+    }
+
+    this.blocks = { ...explorerApi.blocks }
+    this.transactions = { ...explorerApi.transactions }
+    this.addresses = { ...explorerApi.addresses }
+    this.addressesActive = { ...explorerApi.addressesActive }
+    this.infos = { ...explorerApi.infos }
+    this.unconfirmedTransactions = { ...explorerApi.unconfirmedTransactions }
+    this.tokens = { ...explorerApi.tokens }
+    this.charts = { ...explorerApi.charts }
+    this.utils = { ...explorerApi.utils }
+  }
+
+  request = (args: ApiRequestArguments): Promise<any> => {
+    return request(this, args)
+  }
+
+  // This can prevent the proxied explorer provider from being modified
+  static Proxy(explorerProvider: ExplorerProvider): ExplorerProvider {
+    return new ExplorerProvider(explorerProvider)
+  }
+
+  static Remote(handler: ApiRequestHandler): ExplorerProvider {
+    return new ExplorerProvider(handler)
   }
 }
 
 export * as node from './api-alephium'
 export * as explorer from './api-explorer'
+export * from './types'