@alephium/web3 0.2.0-rc.3 → 0.2.0-rc.31

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?: AssetOutput[]
 
   /** @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
     })
   }
@@ -570,6 +586,25 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
+  transactionByOutputRefKey = {
+    /**
+     * @description Get a transaction from a output reference key
+     *
+     * @tags Transactions
+     * @name GetTransactionByOutputRefKeyOutputRefKey
+     * @request GET:/transaction-by-output-ref-key/{output-ref-key}
+     */
+    getTransactionByOutputRefKeyOutputRefKey: (outputRefKey: string, params: RequestParams = {}) =>
+      this.request<
+        ConfirmedTransaction,
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/transaction-by-output-ref-key/${outputRefKey}`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
   addresses = {
     /**
      * @description Get address information
@@ -621,6 +656,24 @@ 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<
+        UnconfirmedTransaction[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/addresses/${address}/unconfirmed-transactions`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description Get address balance
      *
@@ -634,6 +687,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 +892,66 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         }
       ).then(convertHttpResponse)
   }
+  unconfirmedTransactions = {
+    /**
+     * @description list unconfirmed transactions
+     *
+     * @tags Unconfirmed Transactions
+     * @name GetUnconfirmedTransactions
+     * @request GET:/unconfirmed-transactions
+     */
+    getUnconfirmedTransactions: (
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<
+        UnconfirmedTransaction[],
+        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 +1047,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,12 +19,61 @@ 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 })
+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 {
+  wallets: NodeApi<string>['wallets']
+  infos: NodeApi<string>['infos']
+  blockflow: NodeApi<string>['blockflow']
+  addresses: NodeApi<string>['addresses']
+  transactions: NodeApi<string>['transactions']
+  contracts: NodeApi<string>['contracts']
+  multisig: NodeApi<string>['multisig']
+  utils: NodeApi<string>['utils']
+  miners: NodeApi<string>['miners']
+  events: NodeApi<string>['events']
+
+  constructor(baseUrl: string, apiKey?: string) {
+    const nodeApi = initializeNodeApi(baseUrl, apiKey)
+
+    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
+  }
+
+  // Have to duplicate the code above due to proxy pattern
+  reset(baseUrl: string, apiKey?: string): void {
+    const nodeApi = initializeNodeApi(baseUrl, apiKey)
+
+    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
   }
 }
 
+// TODO: use proxy provider once the endpoints are refined.
 export class ExplorerProvider extends ExplorerApi<null> {
   constructor(baseUrl: string) {
     super({ baseUrl: baseUrl })
@@ -33,3 +82,4 @@ export class ExplorerProvider extends ExplorerApi<null> {
 
 export * as node from './api-alephium'
 export * as explorer from './api-explorer'
+export * from './types'

package/src/api/types.ts

@@ -0,0 +1,233 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { assertType, bs58, Eq } from '../utils'
+import * as node from './api-alephium'
+
+export type Number256 = number | bigint | string
+export type Val = Number256 | boolean | string | Val[]
+export type NamedVals = Record<string, Val>
+
+export interface Token {
+  id: string
+  amount: Number256
+}
+assertType<Eq<keyof Token, keyof node.Token>>
+
+export function toApiToken(token: Token): node.Token {
+  return { id: token.id, amount: toApiNumber256(token.amount) }
+}
+
+export function toApiTokens(tokens?: Token[]): node.Token[] | undefined {
+  return tokens?.map(toApiToken)
+}
+
+export function fromApiToken(token: node.Token): Token {
+  return { id: token.id, amount: fromApiNumber256(token.amount) }
+}
+
+export function fromApiTokens(tokens?: node.Token[]): Token[] | undefined {
+  return tokens?.map(fromApiToken)
+}
+
+export function toApiBoolean(v: Val): boolean {
+  if (typeof v === 'boolean') {
+    return v
+  } else {
+    throw new Error(`Invalid boolean value: ${v}`)
+  }
+}
+
+// TODO: check integer bounds
+export function toApiNumber256(v: Val): string {
+  if ((typeof v === 'number' && Number.isInteger(v)) || typeof v === 'bigint') {
+    return v.toString()
+  } else if (typeof v === 'string') {
+    return v
+  } else {
+    throw new Error(`Invalid 256 bit number: ${v}`)
+  }
+}
+
+export function toApiNumber256Optional(v?: Val): string | undefined {
+  return v === undefined ? undefined : toApiNumber256(v)
+}
+
+export function fromApiNumber256(n: string): Number256 {
+  if (Number.isSafeInteger(Number.parseInt(n))) {
+    return Number(n)
+  } else {
+    return BigInt(n)
+  }
+}
+
+// TODO: check hex string
+export function toApiByteVec(v: Val): string {
+  if (typeof v === 'string') {
+    // try to convert from address to contract id
+    try {
+      const address = bs58.decode(v)
+      if (address.length == 33 && address[0] == 3) {
+        return Buffer.from(address.slice(1)).toString('hex')
+      }
+    } catch (_) {
+      return v as string
+    }
+    return v as string
+  } else {
+    throw new Error(`Invalid string: ${v}`)
+  }
+}
+
+export function toApiAddress(v: Val): string {
+  if (typeof v === 'string') {
+    try {
+      bs58.decode(v)
+      return v as string
+    } catch (error) {
+      throw new Error(`Invalid base58 string: ${v}`)
+    }
+  } else {
+    throw new Error(`Invalid string: ${v}`)
+  }
+}
+
+export function toApiArray(tpe: string, v: Val): node.Val {
+  if (!Array.isArray(v)) {
+    throw new Error(`Expected array, got ${v}`)
+  }
+
+  const semiColonIndex = tpe.lastIndexOf(';')
+  if (semiColonIndex == -1) {
+    throw new Error(`Invalid Val type: ${tpe}`)
+  }
+
+  const subType = tpe.slice(1, semiColonIndex)
+  const dim = parseInt(tpe.slice(semiColonIndex + 1, -1))
+  if ((v as Val[]).length != dim) {
+    throw new Error(`Invalid val dimension: ${v}`)
+  } else {
+    return { value: (v as Val[]).map((v) => toApiVal(v, subType)), type: 'Array' }
+  }
+}
+
+export function toApiVal(v: Val, tpe: string): node.Val {
+  if (tpe === 'Bool') {
+    return { value: toApiBoolean(v), type: tpe }
+  } else if (tpe === 'U256' || tpe === 'I256') {
+    return { value: toApiNumber256(v), type: tpe }
+  } else if (tpe === 'ByteVec') {
+    return { value: toApiByteVec(v), type: tpe }
+  } else if (tpe === 'Address') {
+    return { value: toApiAddress(v), type: tpe }
+  } else {
+    return toApiArray(tpe, v)
+  }
+}
+
+function _fromApiVal(vals: node.Val[], valIndex: number, tpe: string): [result: Val, nextIndex: number] {
+  if (vals.length === 0) {
+    throw new Error('Not enough Vals')
+  }
+
+  const firstVal = vals[`${valIndex}`]
+  if (tpe === 'Bool' && firstVal.type === tpe) {
+    return [firstVal.value as boolean, valIndex + 1]
+  } else if ((tpe === 'U256' || tpe === 'I256') && firstVal.type === tpe) {
+    return [fromApiNumber256(firstVal.value as string), valIndex + 1]
+  } else if ((tpe === 'ByteVec' || tpe === 'Address') && firstVal.type === tpe) {
+    return [firstVal.value as string, valIndex + 1]
+  } else {
+    const [baseType, dims] = decodeArrayType(tpe)
+    const arraySize = dims.reduce((a, b) => a * b)
+    const nextIndex = valIndex + arraySize
+    const valsToUse = vals.slice(valIndex, nextIndex)
+    if (valsToUse.length == arraySize && valsToUse.every((val) => val.type === baseType)) {
+      const localVals = valsToUse.map((val) => fromApiVal(val, baseType))
+      return [foldVals(localVals, dims), nextIndex]
+    } else {
+      throw new Error(`Invalid array Val type: ${valsToUse}, ${tpe}`)
+    }
+  }
+}
+
+export function fromApiVals(vals: node.Val[], names: string[], types: string[]): NamedVals {
+  let valIndex = 0
+  const result: NamedVals = {}
+  types.forEach((currentType, index) => {
+    const currentName = names[`${index}`]
+    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType)
+    valIndex = nextIndex
+    result[`${currentName}`] = val
+  })
+  return result
+}
+
+export function fromApiArray(vals: node.Val[], types: string[]): Val[] {
+  let valIndex = 0
+  const result: Val[] = []
+  for (const currentType of types) {
+    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType)
+    result.push(val)
+    valIndex = nextIndex
+  }
+  return result
+}
+
+export function fromApiVal(v: node.Val, tpe: string): Val {
+  if (v.type === 'Bool' && v.type === tpe) {
+    return v.value as boolean
+  } else if ((v.type === 'U256' || v.type === 'I256') && v.type === tpe) {
+    return fromApiNumber256(v.value as string)
+  } else if ((v.type === 'ByteVec' || v.type === 'Address') && v.type === tpe) {
+    return v.value as string
+  } else {
+    throw new Error(`Invalid node.Val type: ${v}`)
+  }
+}
+
+function decodeArrayType(tpe: string): [baseType: string, dims: number[]] {
+  const semiColonIndex = tpe.lastIndexOf(';')
+  if (semiColonIndex === -1) {
+    throw new Error(`Invalid Val type: ${tpe}`)
+  }
+
+  const subType = tpe.slice(1, semiColonIndex)
+  const dim = parseInt(tpe.slice(semiColonIndex + 1, -1))
+  if (subType[0] == '[') {
+    const [baseType, subDim] = decodeArrayType(subType)
+    return [baseType, (subDim.unshift(dim), subDim)]
+  } else {
+    return [subType, [dim]]
+  }
+}
+
+function foldVals(vals: Val[], dims: number[]): Val {
+  if (dims.length == 1) {
+    return vals
+  } else {
+    const result: Val[] = []
+    const chunkSize = vals.length / dims[0]
+    const chunkDims = dims.slice(1)
+    for (let i = 0; i < vals.length; i += chunkSize) {
+      const chunk = vals.slice(i, i + chunkSize)
+      result.push(foldVals(chunk, chunkDims))
+    }
+    return result
+  }
+}