@alephium/web3 0.5.0-rc.2 → 0.5.0-rc.21

package/src/signer/signer.ts

@@ -16,7 +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 { ec as EC } from 'elliptic'
+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'
@@ -39,57 +40,58 @@ import {
   SignUnsignedTxResult,
   SubmissionResult,
   SubmitTransactionParams,
-  ExtSignTransferTxParams,
-  ExtSignDeployContractTxParams,
-  ExtSignExecuteScriptTxParams,
-  ExtSignUnsignedTxParams,
-  ExtSignMessageParams
+  KeyType,
+  MessageHasher
 } from './types'
 import { TransactionBuilder } from './tx-builder'
+import { addressFromPublicKey, groupOfAddress } from '../utils'
 
-const ec = new EC('secp256k1')
+export abstract class SignerProvider {
+  abstract get nodeProvider(): NodeProvider | undefined
+  abstract get explorerProvider(): ExplorerProvider | undefined
 
-export interface SignerProvider {
-  get nodeProvider(): NodeProvider | undefined
-  get explorerProvider(): ExplorerProvider | undefined
+  protected abstract unsafeGetSelectedAccount(): Promise<Account>
+  async getSelectedAccount(): Promise<Account> {
+    const account = await this.unsafeGetSelectedAccount()
+    SignerProvider.validateAccount(account)
+    return account
+  }
 
-  getSelectedAddress(): Promise<Address>
+  static validateAccount(account: Account): void {
+    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)}`)
+    }
+  }
 
-  signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
-  signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
-  signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
+  abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
+  abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+  abstract signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
 
-  signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
   // The message will be prefixed with 'Alephium Signed Message: ' before signing
   // so that the resulted signature cannot be reused for building transactions.
-  signMessage(params: SignMessageParams): Promise<SignMessageResult>
+  abstract signMessage(params: SignMessageParams): Promise<SignMessageResult>
 }
 
 // Abstraction for interactive signer (e.g. WalletConnect instance, Extension wallet object)
-export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase>
-  extends SignerProvider {
-  enable(opt?: EnableOptions): Promise<Address>
-  disconnect(): Promise<void>
-
-  // Methods inherited from SignerProvider, but require networkId in the params
-  signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>
-  signAndSubmitDeployContractTx(params: ExtSignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  signAndSubmitExecuteScriptTx(params: ExtSignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
-  signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
-  signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
-  signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>
-}
-
-export abstract class SignerProviderSimple extends TransactionBuilder implements SignerProvider {
-  abstract get explorerProvider(): ExplorerProvider | undefined
+export abstract class InteractiveSignerProvider<
+  EnableOptions extends EnableOptionsBase = EnableOptionsBase
+> extends SignerProvider {
+  protected abstract unsafeEnable(opt?: EnableOptions): Promise<Account>
+  async enable(opt?: EnableOptions): Promise<Account> {
+    const account = await this.unsafeEnable(opt)
+    SignerProvider.validateAccount(account)
+    return account
+  }
 
-  abstract getSelectedAccount(): Promise<Account>
+  abstract disconnect(): Promise<void>
+}
 
-  async getSelectedAddress(): Promise<Address> {
-    const account = await this.getSelectedAccount()
-    return account.address
-  }
+export abstract class SignerProviderSimple extends SignerProvider {
+  abstract override get nodeProvider(): NodeProvider
 
   async submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult> {
     const data: node.SubmitTransaction = { unsignedTx: params.unsignedTx, signature: params.signature }
@@ -133,8 +135,11 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
-    return super.buildTransferTx(params, await this.getPublicKey(params.signerAddress))
+  async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
+    return TransactionBuilder.from(this.nodeProvider).buildTransferTx(
+      params,
+      await this.getPublicKey(params.signerAddress)
+    )
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
@@ -143,10 +148,13 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildDeployContractTx(
+  async buildDeployContractTx(
     params: SignDeployContractTxParams
   ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
-    return super.buildDeployContractTx(params, await this.getPublicKey(params.signerAddress))
+    return TransactionBuilder.from(this.nodeProvider).buildDeployContractTx(
+      params,
+      await this.getPublicKey(params.signerAddress)
+    )
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
@@ -155,24 +163,24 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildExecuteScriptTx(
-    params: SignExecuteScriptTxParams
-  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
-    return super.buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress))
+  async buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+    return TransactionBuilder.from(this.nodeProvider).buildExecuteScriptTx(
+      params,
+      await this.getPublicKey(params.signerAddress)
+    )
   }
 
   // in general, wallet should show the decoded information to user for confirmation
   // please overwrite this function for real wallet
   async signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
-    const response = await this.buildUnsignedTx(params)
+    const response = await TransactionBuilder.from(this.nodeProvider).buildUnsignedTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
     return { signature, ...response }
   }
 
   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 }
   }
 
@@ -180,7 +188,7 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
 }
 
 export abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
-  abstract setSelectedAddress(address: string): Promise<void>
+  abstract setSelectedAccount(address: string): Promise<void>
 
   abstract getAccounts(): Promise<Account[]>
 
@@ -204,7 +212,7 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
   private _selectedAccount: T | undefined = undefined
   protected readonly _accounts = new Map<Address, T>()
 
-  getSelectedAccount(): Promise<T> {
+  protected unsafeGetSelectedAccount(): Promise<T> {
     if (this._selectedAccount === undefined) {
       throw Error('No account is selected yet')
     } else {
@@ -212,7 +220,7 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
     }
   }
 
-  setSelectedAddress(address: string): Promise<void> {
+  setSelectedAccount(address: string): Promise<void> {
     const accountOpt = this._accounts.get(address)
     if (accountOpt === undefined) {
       throw Error('The address is not in the accounts')
@@ -236,23 +244,36 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
   }
 }
 
-export function verifyHexString(hexString: string, publicKey: string, signature: string): boolean {
-  try {
-    const key = ec.keyFromPublic(publicKey, 'hex')
-    return key.verify(hexString, utils.signatureDecode(ec, signature))
-  } catch (error) {
-    return false
-  }
+export function extendMessage(message: string): string {
+  return 'Alephium Signed Message: ' + message
 }
 
-function extendMessage(message: string): string {
-  return 'Alephium Signed Message: ' + message
+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, publicKey: string, signature: string): boolean {
-  const extendedMessage = extendMessage(message)
-  const messageHash = blake.blake2b(extendedMessage, undefined, 32)
-  return verifyHexString(utils.binToHex(messageHash), publicKey, signature)
+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/tx-builder.ts

@@ -21,6 +21,7 @@ import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiToke
 import { addressFromPublicKey } from '../utils'
 import { toApiDestinations } from './signer'
 import {
+  KeyType,
   SignDeployContractTxParams,
   SignDeployContractTxResult,
   SignerAddress,
@@ -35,8 +36,10 @@ import {
 export abstract class TransactionBuilder {
   abstract get nodeProvider(): NodeProvider
 
-  static create(baseUrl: string, apiKey?: string) {
-    const nodeProvider = new NodeProvider(baseUrl, apiKey)
+  static from(nodeProvider: NodeProvider): TransactionBuilder
+  static from(baseUrl: string, apiKey?: string): TransactionBuilder
+  static from(param0: string | NodeProvider, param1?: string): TransactionBuilder {
+    const nodeProvider = typeof param0 === 'string' ? new NodeProvider(param0, param1) : (param0 as NodeProvider)
     return new (class extends TransactionBuilder {
       get nodeProvider(): NodeProvider {
         return nodeProvider
@@ -44,8 +47,8 @@ export abstract class TransactionBuilder {
     })()
   }
 
-  private static validatePublicKey(params: SignerAddress, publicKey: string) {
-    const address = addressFromPublicKey(publicKey)
+  private static validatePublicKey(params: SignerAddress, publicKey: string, keyType?: KeyType) {
+    const address = addressFromPublicKey(publicKey, keyType)
     if (address !== params.signerAddress) {
       throw new Error('Unmatched public key')
     }
@@ -55,11 +58,12 @@ export abstract class TransactionBuilder {
     params: SignTransferTxParams,
     publicKey: string
   ): Promise<Omit<SignTransferTxResult, 'signature'>> {
-    TransactionBuilder.validatePublicKey(params, publicKey)
+    TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { destinations, gasPrice, ...rest } = params
     const data: node.BuildTransaction = {
       fromPublicKey: publicKey,
+      fromPublicKeyType: params.signerKeyType,
       destinations: toApiDestinations(destinations),
       gasPrice: toApiNumber256Optional(gasPrice),
       ...rest
@@ -72,11 +76,12 @@ export abstract class TransactionBuilder {
     params: SignDeployContractTxParams,
     publicKey: string
   ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
-    TransactionBuilder.validatePublicKey(params, publicKey)
+    TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params
     const data: node.BuildDeployContractTx = {
       fromPublicKey: publicKey,
+      fromPublicKeyType: params.signerKeyType,
       initialAttoAlphAmount: toApiNumber256Optional(initialAttoAlphAmount),
       initialTokenAmounts: toApiTokens(initialTokenAmounts),
       issueTokenAmount: toApiNumber256Optional(issueTokenAmount),
@@ -92,11 +97,12 @@ export abstract class TransactionBuilder {
     params: SignExecuteScriptTxParams,
     publicKey: string
   ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
-    TransactionBuilder.validatePublicKey(params, publicKey)
+    TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { attoAlphAmount, tokens, gasPrice, ...rest } = params
     const data: node.BuildExecuteScriptTx = {
       fromPublicKey: publicKey,
+      fromPublicKeyType: params.signerKeyType,
       attoAlphAmount: toApiNumber256Optional(attoAlphAmount),
       tokens: toApiTokens(tokens),
       gasPrice: toApiNumber256Optional(gasPrice),

package/src/signer/types.ts

@@ -33,18 +33,22 @@ export interface Destination {
 }
 assertType<Eq<keyof Destination, keyof node.Destination>>
 
+export type KeyType = 'default' | 'bip340-schnorr'
+
 export interface Account {
+  keyType: KeyType
   address: string
   group: number
   publicKey: string
 }
 
-export type SignerAddress = { signerAddress: string }
-type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'targetBlockHash'> & SignerAddress
+export type SignerAddress = { signerAddress: string; signerKeyType?: KeyType }
+type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'fromPublicKeyType' | 'targetBlockHash'> & SignerAddress
 type SignResult<T> = Omit<T, 'gasPrice'> & { signature: string; gasPrice: Number256 }
 
 export interface SignTransferTxParams {
   signerAddress: string
+  signerKeyType?: KeyType
   destinations: Destination[]
   utxos?: OutputRef[]
   gasAmount?: number
@@ -64,6 +68,7 @@ assertType<Eq<SignTransferTxResult, SignResult<node.BuildTransactionResult>>>()
 
 export interface SignDeployContractTxParams {
   signerAddress: string
+  signerKeyType?: KeyType
   bytecode: string
   initialAttoAlphAmount?: Number256
   initialTokenAmounts?: Token[]
@@ -91,6 +96,7 @@ assertType<
 
 export interface SignExecuteScriptTxParams {
   signerAddress: string
+  signerKeyType?: KeyType
   bytecode: string
   attoAlphAmount?: Number256
   tokens?: Token[]
@@ -115,6 +121,7 @@ assertType<
 
 export interface SignUnsignedTxParams {
   signerAddress: string
+  signerKeyType?: KeyType
   unsignedTx: string
 }
 assertType<Eq<SignUnsignedTxParams, { unsignedTx: string } & SignerAddress>>()
@@ -129,11 +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
 }
@@ -151,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/transaction/sign-verify.ts

@@ -17,22 +17,17 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import * as utils from '../utils'
-import { ec as EC } from 'elliptic'
+import { KeyType } from '../signer'
 
-const ec = new EC('secp256k1')
-
-export function transactionSign(txHash: string, privateKey: string): string {
-  const keyPair = ec.keyFromPrivate(privateKey)
-  const signature = keyPair.sign(txHash)
-
-  return utils.encodeSignature(signature)
+export function transactionSign(txId: string, privateKey: string, keyType?: KeyType): string {
+  return utils.sign(txId, privateKey, keyType)
 }
 
-export function transactionVerifySignature(txHash: string, publicKey: string, signature: string): boolean {
-  try {
-    const key = ec.keyFromPublic(publicKey, 'hex')
-    return key.verify(txHash, utils.signatureDecode(ec, signature))
-  } catch (error) {
-    return false
-  }
+export function transactionVerifySignature(
+  txId: string,
+  publicKey: string,
+  signature: string,
+  keyType?: KeyType
+): boolean {
+  return utils.verifySignature(txId, publicKey, signature, keyType)
 }

package/src/utils/index.ts

@@ -21,3 +21,5 @@ export * from './bs58'
 export * from './djb2'
 export * from './utils'
 export * from './subscription'
+export * from './sign'
+export * from './number'

package/src/utils/number.fixture.ts

@@ -0,0 +1,187 @@
+/*
+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/>.
+*/
+export const tests = [
+  {
+    raw: 123456n,
+    decimal: 5,
+    exact: '1.23456',
+    alphFormat: '1.23',
+    tokenFormat: '1.2346'
+  },
+  {
+    raw: 12345612n,
+    decimal: 2,
+    exact: '123,456.12',
+    alphFormat: '123,456.12',
+    tokenFormat: '123,456.12'
+  },
+  {
+    raw: 123456123456n,
+    decimal: 6,
+    exact: '123,456.123456',
+    alphFormat: '123,456.12',
+    tokenFormat: '123,456.1235'
+  },
+  {
+    raw: 12n,
+    decimal: 2,
+    exact: '0.12',
+    alphFormat: '0.12',
+    tokenFormat: '0.12'
+  },
+  {
+    raw: 123456n,
+    decimal: 6,
+    exact: '0.123456',
+    alphFormat: '0.12',
+    tokenFormat: '0.1235'
+  },
+  {
+    raw: 123456n,
+    decimal: 7,
+    exact: '0.0123456',
+    alphFormat: '0.012',
+    tokenFormat: '0.0123'
+  },
+  {
+    raw: 123456n,
+    decimal: 8,
+    exact: '0.00123456',
+    alphFormat: '0.0012',
+    tokenFormat: '0.0012'
+  },
+  {
+    raw: 123456n,
+    decimal: 9,
+    exact: '0.000123456',
+    alphFormat: '0.00012',
+    tokenFormat: '0.00012'
+  },
+  {
+    raw: 123456n,
+    decimal: 11,
+    exact: '0.00000123456',
+    alphFormat: '0.0000012',
+    tokenFormat: '0.0000012'
+  },
+  {
+    raw: -123456n,
+    decimal: 11,
+    exact: '-0.00000123456',
+    alphFormat: '-0.0000012',
+    tokenFormat: '-0.0000012'
+  },
+  {
+    raw: 8923088n,
+    decimal: 10,
+    exact: '0.0008923088',
+    alphFormat: '0.00089',
+    tokenFormat: '0.00089'
+  },
+  {
+    raw: 885n,
+    decimal: 6,
+    exact: '0.000885',
+    alphFormat: '0.00089',
+    tokenFormat: '0.00089'
+  },
+  {
+    raw: 100000000000n,
+    decimal: 18,
+    exact: '0.0000001',
+    alphFormat: '0.0000001',
+    tokenFormat: '0.0000001'
+  },
+  {
+    raw: 1504000000000000000n,
+    decimal: 18,
+    exact: '1.504',
+    alphFormat: '1.50',
+    tokenFormat: '1.504'
+  },
+  {
+    raw: 1505000000000000000n,
+    decimal: 18,
+    exact: '1.505',
+    alphFormat: '1.51',
+    tokenFormat: '1.505'
+  },
+  {
+    raw: 1500050000000000000n,
+    decimal: 18,
+    exact: '1.50005',
+    alphFormat: '1.50',
+    tokenFormat: '1.5001'
+  },
+  {
+    raw: 100n,
+    decimal: 0,
+    exact: '100',
+    alphFormat: '100.00',
+    tokenFormat: '100.0'
+  },
+  {
+    raw: 123456789n,
+    decimal: 0,
+    exact: '123,456,789',
+    alphFormat: '123,456,789.00',
+    tokenFormat: '123,456,789.0'
+  },
+  {
+    raw: -123456789n,
+    decimal: 0,
+    exact: '-123,456,789',
+    alphFormat: '-123,456,789.00',
+    tokenFormat: '-123,456,789.0'
+  },
+  {
+    raw: 0n,
+    decimal: 0,
+    exact: '0',
+    alphFormat: '0.00',
+    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
+  }
+]