@alephium/web3 0.2.0-rc.34 → 0.2.0-rc.36

package/src/api/index.ts

@@ -19,6 +19,29 @@ 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,
@@ -29,20 +52,7 @@ function initializeNodeApi(baseUrl: string, apiKey?: string): NodeApi<string> {
   return nodeApi
 }
 
-interface INodeProvider {
-  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']
-}
-
-export class NodeProvider implements INodeProvider {
+export class NodeProvider {
   readonly wallets: NodeApi<string>['wallets']
   readonly infos: NodeApi<string>['infos']
   readonly blockflow: NodeApi<string>['blockflow']
@@ -54,14 +64,18 @@ export class NodeProvider implements INodeProvider {
   readonly miners: NodeApi<string>['miners']
   readonly events: NodeApi<string>['events']
 
-  constructor(provider: INodeProvider)
   constructor(baseUrl: string, apiKey?: string)
-  constructor(param0: string | INodeProvider, apiKey?: string) {
-    let nodeApi: INodeProvider
+  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 INodeProvider
+      nodeApi = param0 as NodeProvider
     }
 
     this.wallets = nodeApi.wallets
@@ -76,49 +90,79 @@ export class NodeProvider implements INodeProvider {
     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)
+  }
 }
 
-export interface RequestArguments {
-  path: string
-  method: string
-  params?: any
+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 RemoteNodeProvider implements INodeProvider {
-  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(request: (request: RequestArguments) => Promise<any>) {
-    const fakeNodeProvide = new NodeProvider('https://1.2.3.4:12973')
-    Object.assign(this, fakeNodeProvide) // Initialize the class
-
-    // Update class properties to forward requests
-    for (const [path, pathObject] of Object.entries(this)) {
-      for (const method of Object.keys(pathObject)) {
-        pathObject[`${method}`] = async (params: any): Promise<any> => {
-          return request({ path, method, params })
-        }
-      }
+export class ExplorerProvider {
+  readonly blocks = ExplorerApi['blocks']
+  readonly transactions = ExplorerApi['transactions']
+  readonly transactionByOutputRefKey = ExplorerApi['transactionByOutputRefKey']
+  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.transactionByOutputRefKey = explorerApi.transactionByOutputRefKey
+    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)
   }
-}
 
-// TODO: use proxy provider once the endpoints are refined.
-export class ExplorerProvider extends ExplorerApi<null> {
-  constructor(baseUrl: string) {
-    super({ baseUrl: baseUrl })
+  static Remote(handler: ApiRequestHandler): ExplorerProvider {
+    return new ExplorerProvider(handler)
   }
 }
 

package/src/api/types.ts

@@ -19,7 +19,7 @@ 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 Number256 = bigint
 export type Val = Number256 | boolean | string | Val[]
 export type NamedVals = Record<string, Val>
 
@@ -68,12 +68,8 @@ 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)
-  }
+export function fromApiNumber256(n: string): bigint {
+  return BigInt(n)
 }
 
 // TODO: check hex string

package/src/contract/contract.ts

@@ -32,7 +32,6 @@ import {
   toApiVal,
   Token,
   Val,
-  toApiTokens,
   fromApiTokens,
   fromApiVals
 } from '../api'
@@ -816,11 +815,11 @@ export class Contract extends Artifact {
     const signerParams: SignDeployContractTxParams = {
       signerAddress: (await signer.getSelectedAccount()).address,
       bytecode: bytecode,
-      initialAttoAlphAmount: extractOptionalNumber256(params.initialAttoAlphAmount),
-      issueTokenAmount: extractOptionalNumber256(params.issueTokenAmount),
-      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
+      initialAttoAlphAmount: params.initialAttoAlphAmount,
+      issueTokenAmount: params.issueTokenAmount,
+      initialTokenAmounts: params.initialTokenAmounts,
       gasAmount: params.gasAmount,
-      gasPrice: extractOptionalNumber256(params.gasPrice)
+      gasPrice: params.gasPrice
     }
     return signerParams
   }
@@ -902,10 +901,10 @@ export class Script extends Artifact {
     const signerParams: SignExecuteScriptTxParams = {
       signerAddress: (await signer.getSelectedAccount()).address,
       bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
-      attoAlphAmount: extractOptionalNumber256(params.attoAlphAmount),
-      tokens: toApiTokens(params.tokens),
+      attoAlphAmount: params.attoAlphAmount,
+      tokens: params.tokens,
       gasAmount: params.gasAmount,
-      gasPrice: extractOptionalNumber256(params.gasPrice)
+      gasPrice: params.gasPrice
     }
     return signerParams
   }
@@ -923,10 +922,6 @@ export class Script extends Artifact {
   }
 }
 
-function extractOptionalNumber256(v?: Val): string | undefined {
-  return typeof v !== 'undefined' ? toApiNumber256(v) : undefined
-}
-
 function fromApiFields(vals: node.Val[], fieldsSig: node.FieldsSig): Fields {
   return fromApiVals(vals, fieldsSig.names, fieldsSig.types)
 }
@@ -1102,7 +1097,7 @@ type BuildTxParams<T> = Omit<T, 'bytecode'> & { initialFields?: Val[] }
 export interface BuildDeployContractTx {
   signerAddress: string
   initialFields?: Fields
-  initialAttoAlphAmount?: string
+  initialAttoAlphAmount?: Number256
   initialTokenAmounts?: Token[]
   issueTokenAmount?: Number256
   gasAmount?: number

package/src/global.ts

@@ -16,7 +16,7 @@ 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 { NodeProvider } from './api'
+import { ExplorerProvider, NodeProvider } from './api'
 
 let _currentNodeProvider: NodeProvider | undefined = undefined
 
@@ -36,3 +36,21 @@ export function getCurrentNodeProvider(): NodeProvider {
   }
   return _currentNodeProvider
 }
+
+let _currentExplorerProvider: ExplorerProvider | undefined = undefined
+
+export function setCurrentExplorerProvider(provider: ExplorerProvider): void
+export function setCurrentExplorerProvider(baseUrl: string, apiKey?: string): void
+export function setCurrentExplorerProvider(provider: ExplorerProvider | string, apiKey?: string): void {
+  if (typeof provider == 'string') {
+    _currentExplorerProvider = new ExplorerProvider(provider, apiKey)
+  } else {
+    _currentExplorerProvider = provider
+  }
+}
+
+// Different from `NodeProvider`, this may return `undefined`
+// as ExplorerProvider is not necessary for all applications
+export function getCurrentExplorerProvider(): ExplorerProvider | undefined {
+  return _currentExplorerProvider
+}

package/src/signer/signer.ts

@@ -18,6 +18,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import { ec as EC } from 'elliptic'
 import {
+  ExplorerProvider,
   fromApiNumber256,
   fromApiTokens,
   NodeProvider,
@@ -91,10 +92,10 @@ assertType<Eq<SignDeployContractTxResult, SignResult<node.BuildDeployContractTxR
 export interface SignExecuteScriptTxParams {
   signerAddress: string
   bytecode: string
-  attoAlphAmount?: string
+  attoAlphAmount?: Number256
   tokens?: Token[]
   gasAmount?: number
-  gasPrice?: string
+  gasPrice?: Number256
 }
 assertType<Eq<keyof SignExecuteScriptTxParams, keyof TxBuildParams<node.BuildExecuteScriptTx>>>()
 export interface SignExecuteScriptTxResult {
@@ -145,6 +146,7 @@ export interface SubmissionResult {
 
 export interface SignerProvider {
   get nodeProvider(): NodeProvider | undefined
+  get explorerProvider(): ExplorerProvider | undefined
 
   getSelectedAccount(): Promise<Account>
 
@@ -161,6 +163,7 @@ export interface SignerProvider {
 
 export abstract class SignerProviderSimple implements SignerProvider {
   abstract get nodeProvider(): NodeProvider | undefined
+  abstract get explorerProvider(): ExplorerProvider | undefined
   abstract getSelectedAccount(): Promise<Account>
 
   private getNodeProvider(): NodeProvider {
@@ -250,7 +253,9 @@ export abstract class SignerProviderSimple implements SignerProvider {
   async buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult> {
     const data: node.BuildExecuteScriptTx = {
       ...(await this.usePublicKey(params)),
-      tokens: toApiTokens(params.tokens)
+      attoAlphAmount: toApiNumber256Optional(params.attoAlphAmount),
+      tokens: toApiTokens(params.tokens),
+      gasPrice: toApiNumber256Optional(params.gasPrice)
     }
     return this.getNodeProvider().contracts.postContractsUnsignedTxExecuteScript(data)
   }