@alephium/web3 0.1.0-rc.3 → 0.1.0-rc.3-hc

package/src/api/api-explorer.ts

@@ -23,6 +23,8 @@ export interface AddressInfo {
 
   /** @format uint256 */
   lockedBalance: string
+
+  /** @format int32 */
   txNumber: number
 }
 
@@ -31,13 +33,22 @@ export interface BadRequest {
 }
 
 export interface BlockEntryLite {
+  /** @format block-hash */
   hash: string
 
   /** @format int64 */
   timestamp: number
+
+  /** @format int32 */
   chainFrom: number
+
+  /** @format int32 */
   chainTo: number
+
+  /** @format int32 */
   height: number
+
+  /** @format int32 */
   txNumber: number
   mainChain: boolean
 
@@ -46,13 +57,18 @@ export interface BlockEntryLite {
 }
 
 export interface ConfirmedTransaction {
+  /** @format 32-byte-hash */
   hash: string
+
+  /** @format block-hash */
   blockHash: string
 
   /** @format int64 */
   timestamp: number
   inputs?: Input[]
   outputs?: Output[]
+
+  /** @format int32 */
   gasAmount: number
 
   /** @format uint256 */
@@ -68,13 +84,15 @@ export interface ExplorerInfo {
 export interface Hashrate {
   /** @format int64 */
   timestamp: number
-  hashrate: string
-  value: string
+  hashrate: number
+  value: number
 }
 
 export interface Input {
   outputRef: OutputRef
   unlockScript?: string
+
+  /** @format 32-byte-hash */
   txHashRef: string
   address: string
 
@@ -87,6 +105,7 @@ export interface InternalServerError {
 }
 
 export interface ListBlocks {
+  /** @format int32 */
   total: number
   blocks?: BlockEntryLite[]
 }
@@ -97,6 +116,7 @@ export interface NotFound {
 }
 
 export interface Output {
+  /** @format int32 */
   hint: number
 
   /** @format 32-byte-hash */
@@ -108,10 +128,13 @@ export interface Output {
 
   /** @format int64 */
   lockTime?: number
+
+  /** @format 32-byte-hash */
   spent?: string
 }
 
 export interface OutputRef {
+  /** @format int32 */
   hint: number
 
   /** @format 32-byte-hash */
@@ -119,7 +142,10 @@ export interface OutputRef {
 }
 
 export interface PerChainCount {
+  /** @format int32 */
   chainFrom: number
+
+  /** @format int32 */
   chainTo: number
 
   /** @format int64 */
@@ -127,7 +153,10 @@ export interface PerChainCount {
 }
 
 export interface PerChainDuration {
+  /** @format int32 */
   chainFrom: number
+
+  /** @format int32 */
   chainTo: number
 
   /** @format int64 */
@@ -138,7 +167,10 @@ export interface PerChainDuration {
 }
 
 export interface PerChainHeight {
+  /** @format int32 */
   chainFrom: number
+
+  /** @format int32 */
   chainTo: number
 
   /** @format int64 */
@@ -187,13 +219,18 @@ export interface TokenSupply {
 }
 
 export interface Transaction {
+  /** @format 32-byte-hash */
   hash: string
+
+  /** @format block-hash */
   blockHash: string
 
   /** @format int64 */
   timestamp: number
   inputs?: Input[]
   outputs?: Output[]
+
+  /** @format int32 */
   gasAmount: number
 
   /** @format uint256 */
@@ -221,11 +258,18 @@ export interface Unauthorized {
 }
 
 export interface UnconfirmedTransaction {
+  /** @format 32-byte-hash */
   hash: string
+
+  /** @format int32 */
   chainFrom: number
+
+  /** @format int32 */
   chainTo: number
   inputs?: UInput[]
   outputs?: UOutput[]
+
+  /** @format int32 */
   gasAmount: number
 
   /** @format uint256 */
@@ -647,7 +691,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request GET:/infos/supply/total-alph
      */
     getInfosSupplyTotalAlph: (params: RequestParams = {}) =>
-      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/infos/supply/total-alph`,
         method: 'GET',
         ...params
@@ -661,7 +705,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request GET:/infos/supply/circulating-alph
      */
     getInfosSupplyCirculatingAlph: (params: RequestParams = {}) =>
-      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/infos/supply/circulating-alph`,
         method: 'GET',
         ...params
@@ -675,7 +719,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request GET:/infos/supply/reserved-alph
      */
     getInfosSupplyReservedAlph: (params: RequestParams = {}) =>
-      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/infos/supply/reserved-alph`,
         method: 'GET',
         ...params
@@ -689,7 +733,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request GET:/infos/supply/locked-alph
      */
     getInfosSupplyLockedAlph: (params: RequestParams = {}) =>
-      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/infos/supply/locked-alph`,
         method: 'GET',
         ...params

package/src/contract/events.ts

@@ -16,64 +16,33 @@ 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 EventEmitter from 'eventemitter3'
-import { node } from '../api'
-import { NodeProvider } from '../api'
+import { ContractEvent } from '../api/api-alephium'
+import { Subscription, SubscribeOptions } from '../utils'
 
-type EventCallback = (event: node.ContractEvent) => Promise<void>
-type ErrorCallback = (error: any, subscription: Subscription) => Promise<void>
-
-export interface SubscribeOptions {
-  provider: NodeProvider
-  contractAddress: string
-  fromCount?: number
-  pollingInterval: number
-  eventCallback: EventCallback
-  errorCallback: ErrorCallback
-}
-
-export class Subscription {
-  provider: NodeProvider
+export class EventSubscription extends Subscription<ContractEvent> {
   readonly contractAddress: string
-  pollingInterval: number
-
   private fromCount: number
-  private eventCallback: EventCallback
-  private errorCallback: ErrorCallback
-  private task: ReturnType<typeof setTimeout> | undefined
-  private cancelled: boolean
-  private eventEmitter: EventEmitter
 
-  constructor(options: SubscribeOptions) {
-    this.provider = options.provider
-    this.contractAddress = options.contractAddress
-    this.fromCount = typeof options.fromCount === 'undefined' ? 0 : options.fromCount
-    this.pollingInterval = options.pollingInterval
-    this.eventCallback = options.eventCallback
-    this.errorCallback = options.errorCallback
-    this.task = undefined
-    this.cancelled = false
+  constructor(options: SubscribeOptions<ContractEvent>, contractAddress: string, fromCount?: number) {
+    super(options)
+    this.contractAddress = contractAddress
+    this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount
 
-    this.eventEmitter = new EventEmitter()
+    this.startPolling()
+  }
+
+  override startPolling() {
     this.eventEmitter.on('tick', async () => {
-      await this.fetchEvents()
+      await this.polling()
     })
     this.eventEmitter.emit('tick')
   }
 
-  unsubscribe(): void {
-    this.eventEmitter.removeAllListeners()
-    this.cancelled = true
-    if (typeof this.task !== 'undefined') {
-      clearTimeout(this.task)
-    }
-  }
-
   currentEventCount(): number {
     return this.fromCount
   }
 
-  private async fetchEvents() {
+  override async polling() {
     try {
       const events = await this.provider.events.getEventsContractContractaddress(this.contractAddress, {
         start: this.fromCount
@@ -87,16 +56,20 @@ export class Subscription {
         return
       }
 
-      const promises = events.events.map((event) => this.eventCallback(event))
+      const promises = events.events.map((event) => this.messageCallback(event))
       await Promise.all(promises)
       this.fromCount = events.nextStart
-      await this.fetchEvents()
+      await this.polling()
     } catch (err) {
       await this.errorCallback(err, this)
     }
   }
 }
 
-export function subscribe(options: SubscribeOptions): Subscription {
-  return new Subscription(options)
+export function subscribeToEvents(
+  options: SubscribeOptions<ContractEvent>,
+  contractAddress: string,
+  fromCount?: number
+): EventSubscription {
+  return new EventSubscription(options, contractAddress, fromCount)
 }

package/src/index.ts

@@ -20,5 +20,6 @@ export * from './api'
 export * from './contract'
 export * from './signer'
 export * from './utils'
+export * from './transaction'
 
 export * from './constants'

package/src/transaction/index.ts

@@ -0,0 +1,20 @@
+/*
+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 * from './sign-verify'
+export * from './status'

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

@@ -19,7 +19,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import EC from 'elliptic'
 import assert from 'assert'
 
-import { transactionSign, transactionVerifySignature } from './transaction'
+import { transactionSign, transactionVerifySignature } from './sign-verify'
 
 describe('transaction', function () {
   it('should verify signature', () => {

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

@@ -18,7 +18,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import { ec as EC } from 'elliptic'
 
-import * as utils from './utils'
+import * as utils from '../utils'
 
 const ec = new EC('secp256k1')
 

package/src/transaction/status.ts

@@ -0,0 +1,58 @@
+/*
+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 { TxStatus } from '../api/api-alephium'
+import { Subscription, SubscribeOptions } from '../utils'
+
+export class TxStatusSubscription extends Subscription<TxStatus> {
+  readonly txId: string
+  readonly fromGroup?: number
+  readonly toGroup?: number
+
+  constructor(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number) {
+    super(options)
+    this.txId = txId
+    this.fromGroup = fromGroup
+    this.toGroup = toGroup
+
+    this.startPolling()
+  }
+
+  override async polling() {
+    try {
+      const txStatus = await this.provider.transactions.getTransactionsStatus({
+        txId: this.txId,
+        fromGroup: this.fromGroup,
+        toGroup: this.toGroup
+      })
+
+      await this.messageCallback(txStatus)
+    } catch (err) {
+      await this.errorCallback(err, this)
+    }
+  }
+}
+
+export function subscribeToTxStatus(
+  options: SubscribeOptions<TxStatus>,
+  txId: string,
+  fromGroup?: number,
+  toGroup?: number
+): TxStatusSubscription {
+  return new TxStatusSubscription(options, txId, fromGroup, toGroup)
+}

package/src/utils/index.ts

@@ -20,5 +20,5 @@ export * from './address'
 export * from './bs58'
 export * from './djb2'
 export * from './password-crypto'
-export * from './transaction'
 export * from './utils'
+export * from './subscription'

package/src/utils/subscription.ts

@@ -0,0 +1,72 @@
+/*
+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 EventEmitter from 'eventemitter3'
+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>
+  protected errorCallback: ErrorCallback<Message>
+  protected task: ReturnType<typeof setTimeout> | undefined
+  protected eventEmitter: EventEmitter
+  protected cancelled: boolean
+
+  constructor(options: SubscribeOptions<Message>) {
+    this.provider = options.provider
+    this.pollingInterval = options.pollingInterval
+    this.messageCallback = options.messageCallback
+    this.errorCallback = options.errorCallback
+    this.task = undefined
+    this.cancelled = false
+    this.eventEmitter = new EventEmitter()
+  }
+
+  startPolling() {
+    this.eventEmitter.on('tick', async () => {
+      await this.polling()
+
+      if (!this.cancelled) {
+        this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval)
+      }
+    })
+    this.eventEmitter.emit('tick')
+  }
+
+  unsubscribe(): void {
+    this.eventEmitter.removeAllListeners()
+    this.cancelled = true
+    if (typeof this.task !== 'undefined') {
+      clearTimeout(this.task)
+    }
+  }
+
+  abstract polling(): Promise<void>
+}

package/test/events.test.ts

@@ -17,11 +17,12 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { NodeProvider } from '../src/api'
-import { subscribe, Subscription } from '../src/contract/events'
+import { subscribeToEvents } from '../src/contract/events'
 import { Contract, Script } from '../src/contract'
 import { NodeWallet, SignExecuteScriptTxParams } from '../src/signer'
-import { node } from '../src/api'
+import { ContractEvent } from '../src/api/api-alephium'
 import { testWallet } from '../src/test'
+import { SubscribeOptions } from '../src/utils'
 
 describe('events', function () {
   async function deployContract(provider: NodeProvider, signer: NodeWallet): Promise<[string, string]> {
@@ -56,22 +57,21 @@ describe('events', function () {
     const signer = await testWallet(provider)
 
     const [contractAddress, contractId] = await deployContract(provider, signer)
-    const events: Array<node.ContractEvent> = []
-    const subscriptOptions = {
+    const events: Array<ContractEvent> = []
+    const subscriptOptions: SubscribeOptions<ContractEvent> = {
       provider: provider,
-      contractAddress: contractAddress,
       pollingInterval: 500,
-      eventCallback: (event: node.ContractEvent): Promise<void> => {
+      messageCallback: (event: ContractEvent): Promise<void> => {
         events.push(event)
         return Promise.resolve()
       },
-      errorCallback: (error: any, subscription: Subscription): Promise<void> => {
+      errorCallback: (error: any, subscription): Promise<void> => {
         console.log(error)
         subscription.unsubscribe()
         return Promise.resolve()
       }
     }
-    const subscription = subscribe(subscriptOptions)
+    const subscription = subscribeToEvents(subscriptOptions, contractAddress)
     const script = await Script.fromSource(provider, 'main.ral')
     const scriptTxParams = await script.paramsForDeployment({
       initialFields: { addContractId: contractId },
@@ -90,29 +90,28 @@ describe('events', function () {
     expect(subscription.currentEventCount()).toEqual(events.length)
 
     subscription.unsubscribe()
-  })
+  }, 15000)
 
   it('should cancel event subscription', async () => {
     const provider = new NodeProvider('http://127.0.0.1:22973')
     const signer = await testWallet(provider)
 
     const [contractAddress, contractId] = await deployContract(provider, signer)
-    const events: Array<node.ContractEvent> = []
+    const events: Array<ContractEvent> = []
     const subscriptOptions = {
       provider: provider,
-      contractAddress: contractAddress,
       pollingInterval: 500,
-      eventCallback: (event: node.ContractEvent): Promise<void> => {
+      messageCallback: (event: ContractEvent): Promise<void> => {
         events.push(event)
         return Promise.resolve()
       },
-      errorCallback: (error: any, subscription: Subscription): Promise<void> => {
+      errorCallback: (error: any, subscription): Promise<void> => {
         console.log(error)
         subscription.unsubscribe()
         return Promise.resolve()
       }
     }
-    const subscription = subscribe(subscriptOptions)
+    const subscription = subscribeToEvents(subscriptOptions, contractAddress)
     const script = await Script.fromSource(provider, 'main.ral')
     const scriptTx0 = await script.transactionForDeployment(signer, {
       initialFields: { addContractId: contractId }

package/test/transaction.test.ts

@@ -0,0 +1,72 @@
+/*
+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 { NodeProvider } from '../src/api'
+import { subscribeToTxStatus } from '../src/transaction/status'
+import { Contract } from '../src/contract'
+import { TxStatus } from '../src/api/api-alephium'
+import { testWallet } from '../src/test'
+import { SubscribeOptions } from '../src/utils'
+
+describe('transactions', function () {
+  it('should subscribe transaction status', async () => {
+    const provider = new NodeProvider('http://127.0.0.1:22973')
+    const sub = await Contract.fromSource(provider, 'sub.ral')
+    const signer = await testWallet(provider)
+    const subDeployTx = await sub.transactionForDeployment(signer, {
+      initialFields: { result: 0 },
+      initialTokenAmounts: []
+    })
+
+    let txStatus: TxStatus | undefined = undefined
+    let counter = 0
+    const subscriptOptions: SubscribeOptions<TxStatus> = {
+      provider: provider,
+      pollingInterval: 500,
+      messageCallback: (status: TxStatus): Promise<void> => {
+        txStatus = status
+        counter = counter + 1
+        return Promise.resolve()
+      },
+      errorCallback: (error: any, subscription): Promise<void> => {
+        console.log(error)
+        subscription.unsubscribe()
+        return Promise.resolve()
+      }
+    }
+
+    const counterBeforeSubscribe = counter
+
+    const subscription = subscribeToTxStatus(subscriptOptions, subDeployTx.txId)
+    await new Promise((resolve) => setTimeout(resolve, 1500))
+    expect(txStatus).toMatchObject({ type: 'TxNotFound' })
+
+    const subSubmitResult = await signer.submitTransaction(subDeployTx.unsignedTx, subDeployTx.txId)
+    await new Promise((resolve) => setTimeout(resolve, 1500))
+    expect(txStatus).toMatchObject({ type: 'Confirmed' })
+
+    expect(counterBeforeSubscribe).toBeLessThan(counter)
+
+    subscription.unsubscribe()
+
+    const counterAfterUnsubscribe = counter
+    await new Promise((resolve) => setTimeout(resolve, 1500))
+    expect(txStatus).toMatchObject({ type: 'Confirmed' })
+    expect(counterAfterUnsubscribe).toEqual(counter)
+  })
+})