@alephium/web3 0.5.0-rc.16 → 0.5.0-rc.18

package/src/api/explorer-provider.ts

@@ -0,0 +1,78 @@
+/*
+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 { ApiRequestArguments, ApiRequestHandler, forwardRequests, request } from './types'
+import { Api as ExplorerApi } from './api-explorer'
+
+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<string>['blocks']
+  readonly transactions: ExplorerApi<string>['transactions']
+  readonly addresses: ExplorerApi<string>['addresses']
+  readonly infos: ExplorerApi<string>['infos']
+  readonly mempool: ExplorerApi<string>['mempool']
+  readonly tokens: ExplorerApi<string>['tokens']
+  readonly charts: ExplorerApi<string>['charts']
+  readonly utils: ExplorerApi<string>['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.infos = { ...explorerApi.infos }
+    this.mempool = { ...explorerApi.mempool }
+    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)
+  }
+}

package/src/api/index.ts

@@ -16,154 +16,8 @@ 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 { Api as NodeApi } from './api-alephium'
-import { Api as ExplorerApi } from './api-explorer'
-
-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 })
-      }
-    }
-  }
-}
-
-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 mempool: NodeApi<string>['mempool']
-  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.mempool = { ...nodeApi.mempool }
-    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 infos = ExplorerApi['infos']
-  readonly mempool = ExplorerApi['mempool']
-  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.infos = { ...explorerApi.infos }
-    this.mempool = { ...explorerApi.mempool }
-    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 * from './node-provider'
+export * from './explorer-provider'
 export * as node from './api-alephium'
 export * as explorer from './api-explorer'
 export * from './types'

package/src/api/node-provider.ts

@@ -0,0 +1,84 @@
+/*
+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 { ApiRequestArguments, ApiRequestHandler, forwardRequests, request } from './types'
+import { Api as NodeApi } from './api-alephium'
+
+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 mempool: NodeApi<string>['mempool']
+  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.mempool = { ...nodeApi.mempool }
+    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)
+  }
+}

package/src/api/types.ts

@@ -245,3 +245,26 @@ export function typeLength(tpe: string): number {
   const [, dims] = decodeArrayType(tpe)
   return dims.reduce((a, b) => a * b)
 }
+
+export interface ApiRequestArguments {
+  path: string
+  method: string
+  params: any[]
+}
+export type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>
+
+export 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 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)
+}

package/src/contract/contract.ts

@@ -54,7 +54,9 @@ import {
   Eq,
   Optional,
   groupOfAddress,
-  addressFromContractId
+  addressFromContractId,
+  stringifyJsonWithBigint,
+  parseJsonWithBigint
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
 import * as path from 'path'
@@ -207,7 +209,7 @@ class ProjectArtifact {
       compilerOptionsUsed: this.compilerOptionsUsed,
       infos: Object.fromEntries(new Map([...this.infos].sort()))
     }
-    const content = JSON.stringify(artifact, null, 2)
+    const content = stringifyJsonWithBigint(artifact, 2)
     return fsPromises.writeFile(filepath, content)
   }
 
@@ -241,7 +243,7 @@ class ProjectArtifact {
       return undefined
     }
     const content = await fsPromises.readFile(filepath)
-    const json = JSON.parse(content.toString())
+    const json = parseJsonWithBigint(content.toString())
     const compilerOptionsUsed = json.compilerOptionsUsed as node.CompilerOptions
     const files = new Map(Object.entries<CodeInfo>(json.infos))
     return new ProjectArtifact(compilerOptionsUsed, files)
@@ -737,7 +739,7 @@ export class Contract extends Artifact {
   // support both 'code.ral' and 'code.ral.json'
   static async fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string): Promise<Contract> {
     const content = await fsPromises.readFile(path)
-    const artifact = JSON.parse(content.toString())
+    const artifact = parseJsonWithBigint(content.toString())
     return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug)
   }
 
@@ -751,7 +753,7 @@ export class Contract extends Artifact {
       eventsSig: this.eventsSig,
       functions: this.functions
     }
-    return JSON.stringify(object, null, 2)
+    return stringifyJsonWithBigint(object, 2)
   }
 
   toState<T extends Fields>(fields: T, asset: Asset, address?: string): ContractState<T> {
@@ -1047,7 +1049,7 @@ export class Script extends Artifact {
 
   static async fromArtifactFile(path: string, bytecodeDebugPatch: string): Promise<Script> {
     const content = await fsPromises.readFile(path)
-    const artifact = JSON.parse(content.toString())
+    const artifact = parseJsonWithBigint(content.toString())
     return this.fromJson(artifact, bytecodeDebugPatch)
   }
 
@@ -1059,7 +1061,7 @@ export class Script extends Artifact {
       fieldsSig: this.fieldsSig,
       functions: this.functions
     }
-    return JSON.stringify(object, null, 2)
+    return stringifyJsonWithBigint(object, 2)
   }
 
   async txParamsForExecution<P extends Fields>(

package/src/index.ts

@@ -16,10 +16,6 @@ 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/>.
 */
 
-BigInt.prototype['toJSON'] = function () {
-  return this.toString()
-}
-
 export * from './api'
 export * from './contract'
 export * from './signer'

package/src/signer/signer.ts

@@ -61,7 +61,7 @@ export abstract class SignerProvider {
     const derivedAddress = addressFromPublicKey(account.publicKey, account.keyType)
     const derivedGroup = groupOfAddress(derivedAddress)
     if (derivedAddress !== account.address || derivedGroup !== account.group) {
-      throw Error(`Invalid accounot data: ${JSON.stringify(account)}`)
+      throw Error(`Invalid account data: ${JSON.stringify(account)}`)
     }
   }
 

package/src/utils/index.ts

@@ -22,3 +22,4 @@ export * from './djb2'
 export * from './utils'
 export * from './subscription'
 export * from './sign'
+export * from './number'

package/src/utils/number.fixture.ts

@@ -157,3 +157,31 @@ export const tests = [
     tokenFormat: '0.0'
   }
 ]
+
+export const tests1 = [
+  {
+    raw: '0',
+    decimals: 18,
+    amount: 0n
+  },
+  {
+    raw: '1.23',
+    decimals: 2,
+    amount: 123n
+  },
+  {
+    raw: '1',
+    decimals: 5,
+    amount: 100000n
+  },
+  {
+    raw: '1',
+    decimals: 18,
+    amount: 1000000000000000000n
+  },
+  {
+    raw: '1.23456789',
+    decimals: 18,
+    amount: 1234567890000000000n
+  }
+]

package/src/utils/number.ts

@@ -54,23 +54,23 @@ export const prettifyNumberConfig: Record<string, IPrettifyNumberConfig> = {
   }
 }
 
-export function prettifyAttoAlphAmount(amount: bigint): string | null {
+export function prettifyAttoAlphAmount(amount: bigint): string | undefined {
   return prettifyNumber(amount, 18, prettifyNumberConfig.ALPH)
 }
 
-export function prettifyTokenAmount(amount: bigint, decimals: number): string | null {
+export function prettifyTokenAmount(amount: bigint, decimals: number): string | undefined {
   return prettifyNumber(amount, decimals, prettifyNumberConfig.TOKEN)
 }
 
-export function prettifyExactAmount(amount: bigint, decimals: number): string | null {
+export function prettifyExactAmount(amount: bigint, decimals: number): string | undefined {
   return prettifyNumber(amount, decimals, prettifyNumberConfig.Exact)
 }
 
-export function prettifyNumber(amount: bigint, decimals: number, config: IPrettifyNumberConfig): string | null {
+export function prettifyNumber(amount: bigint, decimals: number, config: IPrettifyNumberConfig): string | undefined {
   const number = toFixedNumber(amount, decimals)
 
   if (!isNumeric(number)) {
-    return null
+    return undefined
   }
 
   const numberBN = new BigNumber(number)
@@ -142,3 +142,50 @@ function toFixedNumber(val: bigint, decimals: number): string {
   }
   return negative + str
 }
+
+export function convertAmountWithDecimals(amount: string | number, decimals: number): bigint | undefined {
+  try {
+    const result = new BigNumber(amount).multipliedBy(Math.pow(10, decimals))
+    return BigInt(result.toFormat(0, { groupSeparator: '' }))
+  } catch (e) {
+    return undefined
+  }
+}
+
+export function convertAlphAmount(amount: string | number): bigint | undefined {
+  return convertAmountWithDecimals(amount, 18)
+}
+
+function replacer(key: string, value: any): any {
+  if (typeof value === 'bigint') {
+    return { __bigintval__: value.toString() }
+  }
+  return value
+}
+
+function reviver(key: string, value: any): any {
+  if (value != null && typeof value === 'object' && '__bigintval__' in value) {
+    return BigInt(value['__bigintval__'])
+  }
+  return value
+}
+
+export function stringifyJsonWithBigint(obj: any, space?: string | number): string {
+  const bigintToString = BigInt.prototype['toJSON']
+  BigInt.prototype['toJSON'] = undefined
+
+  const result = JSON.stringify(obj, replacer, space)
+
+  BigInt.prototype['toJSON'] = bigintToString
+  return result
+}
+
+export function parseJsonWithBigint(text: string): any {
+  const bigintToString = BigInt.prototype['toJSON']
+  BigInt.prototype['toJSON'] = undefined
+
+  const result = JSON.parse(text, reviver)
+
+  BigInt.prototype['toJSON'] = bigintToString
+  return result
+}