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

package/src/contract/events.ts

@@ -16,14 +16,15 @@ 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 { ContractEvent } from '../api/api-alephium'
+import { web3 } from '..'
+import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
-export class EventSubscription extends Subscription<ContractEvent> {
+export class EventSubscription extends Subscription<node.ContractEvent> {
   readonly contractAddress: string
   private fromCount: number
 
-  constructor(options: SubscribeOptions<ContractEvent>, contractAddress: string, fromCount?: number) {
+  constructor(options: SubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number) {
     super(options)
     this.contractAddress = contractAddress
     this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount
@@ -44,7 +45,7 @@ export class EventSubscription extends Subscription<ContractEvent> {
 
   override async polling(): Promise<void> {
     try {
-      const events = await this.provider.events.getEventsContractContractaddress(this.contractAddress, {
+      const events = await web3.getCurrentNodeProvider().events.getEventsContractContractaddress(this.contractAddress, {
         start: this.fromCount
       })
       if (this.cancelled) {
@@ -67,7 +68,7 @@ export class EventSubscription extends Subscription<ContractEvent> {
 }
 
 export function subscribeToEvents(
-  options: SubscribeOptions<ContractEvent>,
+  options: SubscribeOptions<node.ContractEvent>,
   contractAddress: string,
   fromCount?: number
 ): EventSubscription {

package/src/contract/ralph.ts

@@ -17,9 +17,9 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Buffer } from 'buffer/'
+import { Val } from '../api'
 import { bs58, isHexString } from '../utils'
-import { node } from '../api'
-import { Fields, Val } from './contract'
+import { Fields, FieldsSig } from './contract'
 
 const bigIntZero = BigInt(0)
 
@@ -236,7 +236,7 @@ export function encodeScriptField(tpe: string, value: Val): Uint8Array {
 
 const scriptFieldRegex = /\{([0-9]*)\}/g
 
-export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: node.FieldsSig): string {
+export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: FieldsSig): string {
   return bytecodeTemplate.replace(scriptFieldRegex, (_, fieldIndex: string) => {
     const fieldName = fieldsSig.names[`${fieldIndex}`]
     const fieldType = fieldsSig.types[`${fieldIndex}`]
@@ -249,7 +249,7 @@ export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fi
   })
 }
 
-export function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: node.FieldsSig): string {
+export function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: FieldsSig): string {
   const fieldsEncoded = fieldsSig.names.flatMap((fieldName, fieldIndex) => {
     const fieldType = fieldsSig.types[`${fieldIndex}`]
     if (fieldName in fields) {
@@ -343,6 +343,31 @@ function invalidVal(tpe: string, value: Val): Error {
   return Error(`Invalid API value ${value} for type ${tpe}`)
 }
 
+export function buildDebugBytecode(bytecode: string, bytecodePatch: string): string {
+  if (bytecodePatch === '') {
+    return bytecode
+  }
+
+  const pattern = /[=+-][0-9a-f]*/g
+  let result = ''
+  let index = 0
+  for (const parts of bytecodePatch.matchAll(pattern)) {
+    const part = parts[0]
+    const diffType = part[0]
+    if (diffType === '=') {
+      const length = parseInt(part.substring(1))
+      result = result + bytecode.slice(index, index + length)
+      index = index + length
+    } else if (diffType === '+') {
+      result = result + part.substring(1)
+    } else {
+      const length = parseInt(part.substring(1))
+      index = index + length
+    }
+  }
+  return result
+}
+
 // export function buildContractByteCode(
 //   compiled: node.TemplateContractByteCode,
 //   templateVariables: TemplateVariables

package/src/{transaction/sign-verify.ts → global.ts}

@@ -16,24 +16,23 @@ 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 { NodeProvider } from './api'
 
-import * as utils from '../utils'
+let _currentNodeProvider: NodeProvider | undefined = undefined
 
-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.signatureEncode(signature)
+export function setCurrentNodeProvider(provider: NodeProvider): void
+export function setCurrentNodeProvider(baseUrl: string, apiKey?: string): void
+export function setCurrentNodeProvider(provider: NodeProvider | string, apiKey?: string): void {
+  if (typeof provider == 'string') {
+    _currentNodeProvider = new NodeProvider(provider, apiKey)
+  } else {
+    _currentNodeProvider = provider
+  }
 }
 
-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 getCurrentNodeProvider(): NodeProvider {
+  if (typeof _currentNodeProvider === 'undefined') {
+    throw Error('No node provider is set.')
   }
+  return _currentNodeProvider
 }

package/src/index.ts

@@ -16,6 +16,10 @@ 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'
@@ -23,3 +27,6 @@ export * from './utils'
 export * from './transaction'
 
 export * from './constants'
+export * as web3 from './global'
+
+export * as utils from './utils'

package/src/signer/index.ts

@@ -17,4 +17,3 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 export * from './signer'
-export * from './node-wallet'

package/src/signer/signer.ts

@@ -17,12 +17,22 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { ec as EC } from 'elliptic'
-import { NodeProvider } from '../api'
+import {
+  fromApiNumber256,
+  fromApiTokens,
+  Number256,
+  toApiNumber256,
+  toApiNumber256Optional,
+  toApiTokens,
+  Token
+} from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
 import { Eq, assertType } from '../utils'
 import blake from 'blakejs'
-import { Token } from '../api/api-alephium'
+import { web3 } from '..'
+
+export type OutputRef = node.OutputRef
 
 const ec = new EC('secp256k1')
 
@@ -49,13 +59,13 @@ export type GetAccountsResult = Account[]
 
 export interface SignTransferTxParams {
   signerAddress: string
-  destinations: node.Destination[]
-  utxos?: node.OutputRef[]
+  destinations: Destination[]
+  utxos?: OutputRef[]
   gasAmount?: number
-  gasPrice?: string
+  gasPrice?: Number256
   submitTx?: boolean
 }
-assertType<Eq<SignTransferTxParams, TxBuildParams<node.BuildTransaction>>>()
+assertType<Eq<keyof SignTransferTxParams, keyof TxBuildParams<node.BuildTransaction>>>()
 export interface SignTransferTxResult {
   fromGroup: number
   toGroup: number
@@ -68,14 +78,14 @@ assertType<Eq<SignTransferTxResult, SignResult>>()
 export interface SignDeployContractTxParams {
   signerAddress: string
   bytecode: string
-  initialAttoAlphAmount?: string
+  initialAttoAlphAmount?: Number256
   initialTokenAmounts?: Token[]
-  issueTokenAmount?: string
+  issueTokenAmount?: Number256
   gasAmount?: number
-  gasPrice?: string
+  gasPrice?: Number256
   submitTx?: boolean
 }
-assertType<Eq<SignDeployContractTxParams, TxBuildParams<node.BuildDeployContractTx>>>()
+assertType<Eq<keyof SignDeployContractTxParams, keyof TxBuildParams<node.BuildDeployContractTx>>>()
 export interface SignDeployContractTxResult {
   fromGroup: number
   toGroup: number
@@ -91,12 +101,12 @@ export interface SignExecuteScriptTxParams {
   signerAddress: string
   bytecode: string
   attoAlphAmount?: string
-  tokens?: node.Token[]
+  tokens?: Token[]
   gasAmount?: number
   gasPrice?: string
   submitTx?: boolean
 }
-assertType<Eq<SignExecuteScriptTxParams, TxBuildParams<node.BuildExecuteScriptTx>>>()
+assertType<Eq<keyof SignExecuteScriptTxParams, keyof TxBuildParams<node.BuildExecuteScriptTx>>>()
 export interface SignExecuteScriptTxResult {
   fromGroup: number
   toGroup: number
@@ -152,7 +162,6 @@ export interface SignerProvider {
 }
 
 export abstract class SignerWithNodeProvider implements SignerProvider {
-  readonly provider: NodeProvider
   alwaysSubmitTx: boolean
 
   abstract getAccounts(): Promise<Account[]>
@@ -167,20 +176,26 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
     }
   }
 
-  constructor(provider: NodeProvider, alwaysSubmitTx: boolean) {
-    this.provider = provider
+  abstract setActiveAccount(addressIndex: number): Promise<void>
+  abstract setActiveAccount(address: string): Promise<void>
+  abstract setActiveAccount(input: unknown): Promise<void>
+
+  abstract getActiveAccount(): Promise<Account>
+
+  constructor(alwaysSubmitTx: boolean) {
     this.alwaysSubmitTx = alwaysSubmitTx
   }
 
-  private async defaultSignerAddress(): Promise<string> {
-    return (await this.getAccounts())[0].address
-  }
+  async submitTransaction(unsignedTx: string, signerAddress?: string): Promise<SubmissionResult> {
+    const decoded = await web3
+      .getCurrentNodeProvider()
+      .transactions.postTransactionsDecodeUnsignedTx({ unsignedTx: unsignedTx })
+    const txId = decoded.unsignedTx.txId
 
-  async submitTransaction(unsignedTx: string, txHash: string, signerAddress?: string): Promise<SubmissionResult> {
-    const address = typeof signerAddress !== 'undefined' ? signerAddress : await this.defaultSignerAddress()
-    const signature = await this.signRaw(address, txHash)
+    const address = typeof signerAddress !== 'undefined' ? signerAddress : (await this.getActiveAccount()).address
+    const signature = await this.signRaw(address, txId)
     const params: node.SubmitTransaction = { unsignedTx: unsignedTx, signature: signature }
-    return this.provider.transactions.postTransactionsSubmit(params)
+    return web3.getCurrentNodeProvider().transactions.postTransactionsSubmit(params)
   }
 
   private shouldSubmitTx(params: SubmitTx): boolean {
@@ -206,7 +221,12 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
   }
 
   async buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult> {
-    return this.provider.transactions.postTransactionsBuild(await this.usePublicKey(params))
+    const data: node.BuildTransaction = {
+      ...(await this.usePublicKey(params)),
+      destinations: toApiDestinations(params.destinations),
+      gasPrice: toApiNumber256Optional(params.gasPrice)
+    }
+    return web3.getCurrentNodeProvider().transactions.postTransactionsBuild(data)
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
@@ -220,7 +240,14 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
   }
 
   async buildContractCreationTx(params: SignDeployContractTxParams): Promise<node.BuildDeployContractTxResult> {
-    return this.provider.contracts.postContractsUnsignedTxDeployContract(await this.usePublicKey(params))
+    const data: node.BuildDeployContractTx = {
+      ...(await this.usePublicKey(params)),
+      initialAttoAlphAmount: toApiNumber256Optional(params.initialAttoAlphAmount),
+      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
+      issueTokenAmount: toApiNumber256Optional(params.issueTokenAmount),
+      gasPrice: toApiNumber256Optional(params.gasPrice)
+    }
+    return web3.getCurrentNodeProvider().contracts.postContractsUnsignedTxDeployContract(data)
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
@@ -229,14 +256,18 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
   }
 
   async buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult> {
-    return this.provider.contracts.postContractsUnsignedTxExecuteScript(await this.usePublicKey(params))
+    const data: node.BuildExecuteScriptTx = {
+      ...(await this.usePublicKey(params)),
+      tokens: toApiTokens(params.tokens)
+    }
+    return web3.getCurrentNodeProvider().contracts.postContractsUnsignedTxExecuteScript(data)
   }
 
   // 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 data = { unsignedTx: params.unsignedTx }
-    const decoded = await this.provider.transactions.postTransactionsDecodeUnsignedTx(data)
+    const decoded = await web3.getCurrentNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data)
     return this.handleSign(
       {
         fromGroup: decoded.fromGroup,
@@ -257,7 +288,7 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
     const signature = await this.signRaw(response.signerAddress, response.txId)
     // submit the tx if required
     if (submitTx) {
-      await this.provider.transactions.postTransactionsSubmit({
+      await web3.getCurrentNodeProvider().transactions.postTransactionsSubmit({
         unsignedTx: response.unsignedTx,
         signature: signature
       })
@@ -311,3 +342,24 @@ export function verifySignedMessage(message: string, publicKey: string, signatur
   const messageHash = blake.blake2b(extendedMessage, undefined, 32)
   return verifyHexString(utils.binToHex(messageHash), publicKey, signature)
 }
+
+export interface Destination {
+  address: string
+  attoAlphAmount: Number256
+  tokens?: Token[]
+  lockTime?: number
+  message?: string
+}
+assertType<Eq<keyof Destination, keyof node.Destination>>
+
+export function toApiDestination(data: Destination): node.Destination {
+  return { ...data, attoAlphAmount: toApiNumber256(data.attoAlphAmount), tokens: toApiTokens(data.tokens) }
+}
+
+export function toApiDestinations(data: Destination[]): node.Destination[] {
+  return data.map(toApiDestination)
+}
+
+export function fromApiDestination(data: node.Destination): Destination {
+  return { ...data, attoAlphAmount: fromApiNumber256(data.attoAlphAmount), tokens: fromApiTokens(data.tokens) }
+}

package/src/transaction/index.ts

@@ -16,5 +16,4 @@ 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 * from './sign-verify'
 export * from './status'

package/src/transaction/status.ts

@@ -16,9 +16,12 @@ 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 { TxStatus } from '../api/api-alephium'
+import { web3 } from '..'
+import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
+export type TxStatus = node.TxStatus
+
 export class TxStatusSubscription extends Subscription<TxStatus> {
   readonly txId: string
   readonly fromGroup?: number
@@ -35,7 +38,7 @@ export class TxStatusSubscription extends Subscription<TxStatus> {
 
   override async polling(): Promise<void> {
     try {
-      const txStatus = await this.provider.transactions.getTransactionsStatus({
+      const txStatus = await web3.getCurrentNodeProvider().transactions.getTransactionsStatus({
         txId: this.txId,
         fromGroup: this.fromGroup,
         toGroup: this.toGroup

package/src/utils/bs58.ts

@@ -23,4 +23,15 @@ const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
 export const bs58 = basex(ALPHABET)
 
+export function isBase58(s: string): boolean {
+  if (s === '' || s.trim() === '') {
+    return false
+  }
+  try {
+    return bs58.encode(bs58.decode(s)) === s
+  } catch (err) {
+    return false
+  }
+}
+
 export default bs58

package/src/utils/index.ts

@@ -19,6 +19,5 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 export * from './address'
 export * from './bs58'
 export * from './djb2'
-export * from './password-crypto'
 export * from './utils'
 export * from './subscription'

package/src/utils/subscription.ts

@@ -17,20 +17,19 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import EventEmitter from 'eventemitter3'
+import { getCurrentNodeProvider } from '../global'
 import { NodeProvider } from '../api'
 
 type MessageCallback<Message> = (message: Message) => Promise<void>
 type ErrorCallback<Message> = (error: any, subscription: Subscription<Message>) => Promise<void>
 
 export interface SubscribeOptions<Message> {
-  provider: NodeProvider
   pollingInterval: number
   messageCallback: MessageCallback<Message>
   errorCallback: ErrorCallback<Message>
 }
 
 export abstract class Subscription<Message> {
-  provider: NodeProvider
   pollingInterval: number
 
   protected messageCallback: MessageCallback<Message>
@@ -40,7 +39,6 @@ export abstract class Subscription<Message> {
   protected cancelled: boolean
 
   constructor(options: SubscribeOptions<Message>) {
-    this.provider = options.provider
     this.pollingInterval = options.pollingInterval
     this.messageCallback = options.messageCallback
     this.errorCallback = options.errorCallback

package/src/utils/utils.ts

@@ -24,21 +24,9 @@ import { Buffer } from 'buffer/'
 
 import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import djb2 from './djb2'
-import * as node from '../api/api-alephium'
-import * as explorer from '../api/api-explorer'
 
 const ec = new EC('secp256k1')
 
-export function convertHttpResponse<T>(
-  response: node.HttpResponse<T, { detail: string }> | explorer.HttpResponse<T, { detail: string }>
-): T {
-  if (response.error) {
-    throw new Error(response.error.detail)
-  } else {
-    return response.data
-  }
-}
-
 export function signatureEncode(signature: EC.Signature): string {
   let sNormalized = signature.s
   if (ec.n && signature.s.cmp(ec.nh) === 1) {
@@ -51,7 +39,7 @@ export function signatureEncode(signature: EC.Signature): string {
 }
 
 // the signature should be in hex string format for 64 bytes
-export const signatureDecode = (ec: EC, signature: string): SignatureInput => {
+export function signatureDecode(ec: EC, signature: string): SignatureInput {
   if (signature.length !== 128) {
     throw new Error('Invalid signature length')
   }
@@ -66,7 +54,7 @@ export const signatureDecode = (ec: EC, signature: string): SignatureInput => {
   }
 }
 
-const xorByte = (intValue: number) => {
+export function xorByte(intValue: number): number {
   const byte0 = (intValue >> 24) & 0xff
   const byte1 = (intValue >> 16) & 0xff
   const byte2 = (intValue >> 8) & 0xff
@@ -85,7 +73,7 @@ enum AddressType {
   P2C = 0x03
 }
 
-export const groupOfAddress = (address: string): number => {
+export function groupOfAddress(address: string): number {
   const decoded = bs58.decode(address)
 
   if (decoded.length == 0) throw new Error('Address string is empty')
@@ -103,7 +91,7 @@ export const groupOfAddress = (address: string): number => {
   }
 }
 
-const groupOfAddressBytes = (bytes: Uint8Array): number => {
+function groupOfAddressBytes(bytes: Uint8Array): number {
   const hint = djb2(bytes) | 1
   const hash = xorByte(hint)
   const group = hash % TOTAL_NUMBER_OF_GROUPS
@@ -111,7 +99,7 @@ const groupOfAddressBytes = (bytes: Uint8Array): number => {
 }
 
 // Pay to public key hash address
-const groupOfP2pkhAddress = (address: Uint8Array): number => {
+function groupOfP2pkhAddress(address: Uint8Array): number {
   if (address.length != 32) {
     throw new Error(`Invalid p2pkh address length: ${address.length}`)
   }
@@ -120,7 +108,7 @@ const groupOfP2pkhAddress = (address: Uint8Array): number => {
 }
 
 // Pay to multiple public key hash address
-const groupOfP2mpkhAddress = (address: Uint8Array): number => {
+function groupOfP2mpkhAddress(address: Uint8Array): number {
   if ((address.length - 2) % 32 != 0) {
     throw new Error(`Invalid p2mpkh address length: ${address.length}`)
   }
@@ -129,7 +117,7 @@ const groupOfP2mpkhAddress = (address: Uint8Array): number => {
 }
 
 // Pay to script hash address
-const groupOfP2shAddress = (address: Uint8Array): number => {
+function groupOfP2shAddress(address: Uint8Array): number {
   return groupOfAddressBytes(address)
 }
 
@@ -163,6 +151,10 @@ export function binToHex(bin: Uint8Array): string {
   return Buffer.from(bin).toString('hex')
 }
 
+export function groupOfPrivateKey(privateKey: string): number {
+  return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey)))
+}
+
 export function publicKeyFromPrivateKey(privateKey: string): string {
   const key = ec.keyFromPrivate(privateKey)
   return key.getPublic(true, 'hex')

package/.eslintrc.json

@@ -1,21 +0,0 @@
-{
-  "plugins": ["security", "header"],
-  "extends": [
-    "prettier",
-    "plugin:prettier/recommended",
-    "plugin:security/recommended",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "parser": "@typescript-eslint/parser",
-  "rules": {
-    "header/header": [2, "scripts/header.js"]
-  },
-  "overrides": [
-    {
-      "files": ["*.ts"],
-      "rules": {
-        "security/detect-non-literal-fs-filename": "off"
-      }
-    }
-  ]
-}