@alephium/web3 0.5.0-rc.9 → 0.5.0

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 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.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 * 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

@@ -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 = bigint
+export type Number256 = bigint | string
 export type Val = Number256 | boolean | string | Val[]
 export type NamedVals = Record<string, Val>
 
@@ -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

@@ -53,7 +53,8 @@ import {
   assertType,
   Eq,
   Optional,
-  groupOfAddress
+  groupOfAddress,
+  addressFromContractId
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
 import * as path from 'path'
@@ -1360,6 +1361,15 @@ export interface CallContractResult<R> {
   events: ContractEvent[]
 }
 
+function specialContractAddress(n: number): string {
+  const bytes = new Uint8Array(32).fill(0)
+  bytes[31] = n
+  return addressFromContractId(binToHex(bytes))
+}
+
+export const CreateContractEventAddress = specialContractAddress(-1)
+export const DestroyContractEventAddress = specialContractAddress(-2)
+
 export interface SystemEventSig extends EventSig {
   optionalFieldNames?: string[]
   optionalFieldTypes?: string[]
@@ -1472,18 +1482,17 @@ export async function fetchContractState<F extends Fields, I extends ContractIns
 }
 
 export function subscribeContractCreatedEvent(
-  instance: ContractInstance,
   options: SubscribeOptions<ContractCreatedEvent>,
   fromCount?: number
 ): EventSubscription {
   return subscribeEventsFromContract(
     options,
-    instance.address,
+    CreateContractEventAddress,
     Contract.ContractCreatedEventIndex,
     (event) => {
       return {
         ...decodeContractCreatedEvent(event),
-        contractAddress: instance.address
+        contractAddress: CreateContractEventAddress
       }
     },
     fromCount
@@ -1491,18 +1500,17 @@ export function subscribeContractCreatedEvent(
 }
 
 export function subscribeContractDestroyedEvent(
-  instance: ContractInstance,
   options: SubscribeOptions<ContractDestroyedEvent>,
   fromCount?: number
 ): EventSubscription {
   return subscribeEventsFromContract(
     options,
-    instance.address,
+    DestroyContractEventAddress,
     Contract.ContractDestroyedEventIndex,
     (event) => {
       return {
         ...decodeContractDestroyedEvent(event),
-        contractAddress: instance.address
+        contractAddress: DestroyContractEventAddress
       }
     },
     fromCount
@@ -1552,34 +1560,17 @@ export function subscribeContractEvent<F extends Fields, M extends ContractEvent
   )
 }
 
-export function subscribeAllEvents(
+export function subscribeContractEvents(
   contract: Contract,
   instance: ContractInstance,
   options: SubscribeOptions<ContractEvent<any>>,
   fromCount?: number
 ): EventSubscription {
   const messageCallback = (event: node.ContractEvent): Promise<void> => {
-    switch (event.eventIndex) {
-      case Contract.ContractCreatedEventIndex: {
-        return options.messageCallback({
-          ...decodeContractCreatedEvent(event),
-          contractAddress: instance.address
-        })
-      }
-
-      case Contract.ContractDestroyedEventIndex: {
-        return options.messageCallback({
-          ...decodeContractDestroyedEvent(event),
-          contractAddress: instance.address
-        })
-      }
-
-      default:
-        return options.messageCallback({
-          ...decodeEvent(contract, instance, event, event.eventIndex),
-          contractAddress: instance.address
-        })
-    }
+    return options.messageCallback({
+      ...decodeEvent(contract, instance, event, event.eventIndex),
+      contractAddress: instance.address
+    })
   }
   const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
     return options.errorCallback(err, subscription as unknown as Subscription<ContractEvent<any>>)
@@ -1610,3 +1601,14 @@ export async function callMethod<I, F extends Fields, A extends Arguments, R>(
   const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex)
   return callResult as CallContractResult<R>
 }
+
+export async function getContractEventsCurrentCount(contractAddress: Address): Promise<number> {
+  return getCurrentNodeProvider()
+    .events.getEventsContractContractaddressCurrentCount(contractAddress)
+    .catch((error) => {
+      if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
+        return 0
+      }
+      throw error
+    })
+}

package/src/signer/signer.ts

@@ -16,6 +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 { Buffer } from 'buffer/'
+import { createHash } from 'crypto'
 import { ExplorerProvider, fromApiNumber256, fromApiTokens, NodeProvider, toApiNumber256, toApiTokens } from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
@@ -38,12 +40,8 @@ import {
   SignUnsignedTxResult,
   SubmissionResult,
   SubmitTransactionParams,
-  ExtSignTransferTxParams,
-  ExtSignDeployContractTxParams,
-  ExtSignExecuteScriptTxParams,
-  ExtSignUnsignedTxParams,
-  ExtSignMessageParams,
-  KeyType
+  KeyType,
+  MessageHasher
 } from './types'
 import { TransactionBuilder } from './tx-builder'
 import { addressFromPublicKey, groupOfAddress } from '../utils'
@@ -90,18 +88,6 @@ export abstract class InteractiveSignerProvider<
   }
 
   abstract disconnect(): Promise<void>
-
-  // Methods inherited from SignerProvider, but require networkId in the params
-  abstract override signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>
-  abstract override signAndSubmitDeployContractTx(
-    params: ExtSignDeployContractTxParams
-  ): Promise<SignDeployContractTxResult>
-  abstract override signAndSubmitExecuteScriptTx(
-    params: ExtSignExecuteScriptTxParams
-  ): Promise<SignExecuteScriptTxResult>
-  abstract override signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
-  abstract override signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
-  abstract override signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>
 }
 
 export abstract class SignerProviderSimple extends SignerProvider {
@@ -193,9 +179,8 @@ export abstract class SignerProviderSimple extends SignerProvider {
   }
 
   async signMessage(params: SignMessageParams): Promise<SignMessageResult> {
-    const extendedMessage = extendMessage(params.message)
-    const messageHash = blake.blake2b(extendedMessage, undefined, 32)
-    const signature = await this.signRaw(params.signerAddress, utils.binToHex(messageHash))
+    const messageHash = hashMessage(params.message, params.messageHasher)
+    const signature = await this.signRaw(params.signerAddress, messageHash)
     return { signature: signature }
   }
 
@@ -259,14 +244,36 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
   }
 }
 
-function extendMessage(message: string): string {
+export function extendMessage(message: string): string {
   return 'Alephium Signed Message: ' + message
 }
 
-export function verifySignedMessage(message: string, publicKey: string, signature: string, keyType?: KeyType): boolean {
-  const extendedMessage = extendMessage(message)
-  const messageHash = blake.blake2b(extendedMessage, undefined, 32)
-  return utils.verifySignature(utils.binToHex(messageHash), publicKey, signature, keyType)
+export function hashMessage(message: string, hasher: MessageHasher): string {
+  switch (hasher) {
+    case 'alephium':
+      return utils.binToHex(blake.blake2b(extendMessage(message), undefined, 32))
+    case 'sha256':
+      const sha256 = createHash('sha256')
+      sha256.update(Buffer.from(message))
+      return utils.binToHex(sha256.digest())
+    case 'blake2b':
+      return utils.binToHex(blake.blake2b(message, undefined, 32))
+    case 'identity':
+      return message
+    default:
+      throw Error(`Invalid message hasher: ${hasher}`)
+  }
+}
+
+export function verifySignedMessage(
+  message: string,
+  messageHasher: MessageHasher,
+  publicKey: string,
+  signature: string,
+  keyType?: KeyType
+): boolean {
+  const messageHash = hashMessage(message, messageHasher)
+  return utils.verifySignature(messageHash, publicKey, signature, keyType)
 }
 
 export function toApiDestination(data: Destination): node.Destination {

package/src/signer/types.ts

@@ -136,12 +136,19 @@ export interface SignUnsignedTxResult {
 }
 assertType<Eq<SignUnsignedTxResult, SignTransferTxResult>>
 
+export type MessageHasher =
+  | 'alephium' // Message is prefixed with 'Alephium signed message: ' before hashed with blake2b
+  | 'sha256'
+  | 'blake2b'
+  | 'identity' // No hash is used, the message to be 32 bytes
+
 export interface SignMessageParams {
   signerAddress: string
   signerKeyType?: KeyType
   message: string
+  messageHasher: MessageHasher
 }
-assertType<Eq<SignMessageParams, { message: string } & SignerAddress>>()
+assertType<Eq<SignMessageParams, { message: string; messageHasher: MessageHasher } & SignerAddress>>()
 export interface SignMessageResult {
   signature: string
 }
@@ -159,13 +166,9 @@ export interface SubmissionResult {
 export interface EnableOptionsBase {
   // chainGroup - specify whether to use addresses from a specific group
   chainGroup?: number
+  // keyType - specify which type of signing algorithm to use
+  keyType?: KeyType
+
   networkId: string
-  onDisconnected: () => Promise<void>
+  onDisconnected: () => Promise<void> | void
 }
-
-// Transaction Params for InteractiveSignerProvider
-export type ExtSignTransferTxParams = SignTransferTxParams & { networkId: string }
-export type ExtSignDeployContractTxParams = SignDeployContractTxParams & { networkId: string }
-export type ExtSignExecuteScriptTxParams = SignExecuteScriptTxParams & { networkId: string }
-export type ExtSignUnsignedTxParams = SignUnsignedTxParams & { networkId: string }
-export type ExtSignMessageParams = SignMessageParams & { networkId: string }

package/src/utils/index.ts

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