@alephium/web3 0.1.0 → 0.2.0-test.0

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/src/utils/utils.test.ts

@@ -154,7 +154,8 @@ describe('utils', function () {
     ).toBe('293c948c81c5a9495178fff8b8c9f29f4f3e09e1728c40e9253c87adf5e18770')
   })
 
-  it('should convert from string to hex', () => {
+  it('should convert from string to hex and back', () => {
     expect(utils.stringToHex('Hello Alephium!')).toBe('48656c6c6f20416c65706869756d21')
+    expect(utils.hexToString('48656c6c6f20416c65706869756d21')).toBe('Hello Alephium!')
   })
 })

package/src/utils/utils.ts

@@ -203,6 +203,14 @@ export function stringToHex(str: string): string {
   return hex
 }
 
+export function hexToString(str: any): string {
+  return Buffer.from(str.toString(), 'hex').toString()
+}
+
+export function timeout(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
 type _Eq<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false
 export type Eq<X, Y> = _Eq<{ [P in keyof X]: X[P] }, { [P in keyof Y]: Y[P] }>
 // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars

package/test/contract.test.ts

@@ -22,13 +22,14 @@ import * as path from 'path'
 import { NodeProvider } from '../src/api'
 import { Contract, Script, TestContractParams } from '../src/contract'
 import { testWallet } from '../src/test'
+import { addressFromContractId } from '../src/utils'
 
 describe('contract', function () {
   async function testSuite1() {
     const provider = new NodeProvider('http://127.0.0.1:22973')
 
-    const add = await Contract.fromSource(provider, 'add.ral')
-    const sub = await Contract.fromSource(provider, 'sub.ral')
+    const add = await Contract.fromSource(provider, 'add/add.ral')
+    const sub = await Contract.fromSource(provider, 'sub/sub.ral')
 
     const subState = sub.toState({ result: 0 }, { alphAmount: BigInt('1000000000000000000') })
     const testParams: TestContractParams = {
@@ -61,6 +62,7 @@ describe('contract', function () {
       initialTokenAmounts: []
     })
     const subContractId = subDeployTx.contractId
+    const subContractAddress = addressFromContractId(subContractId)
     expect(subDeployTx.fromGroup).toEqual(0)
     expect(subDeployTx.toGroup).toEqual(0)
     const subSubmitResult = await signer.submitTransaction(subDeployTx.unsignedTx, subDeployTx.txId)
@@ -80,8 +82,16 @@ describe('contract', function () {
     expect(addSubmitResult.txId).toEqual(addDeployTx.txId)
 
     const addContractId = addDeployTx.contractId
-    const main = await Script.fromSource(provider, 'main.ral')
+    const addContractAddress = addressFromContractId(addContractId)
+
+    // Check state for add/sub before main script is executed
+    let fetchedSubState = await sub.fetchState(provider, subContractAddress, 0)
+    expect(fetchedSubState.fields.result).toEqual(0)
+    let fetchedAddState = await add.fetchState(provider, addContractAddress, 0)
+    expect(fetchedAddState.fields.subContractId).toEqual(subContractId)
+    expect(fetchedAddState.fields.result).toEqual(0)
 
+    const main = await Script.fromSource(provider, 'main.ral')
     const mainScriptTx = await main.transactionForDeployment(signer, {
       initialFields: { addContractId: addContractId }
     })
@@ -90,12 +100,19 @@ describe('contract', function () {
     const mainSubmitResult = await signer.submitTransaction(mainScriptTx.unsignedTx, mainScriptTx.txId)
     expect(mainSubmitResult.fromGroup).toEqual(0)
     expect(mainSubmitResult.toGroup).toEqual(0)
+
+    // Check state for add/sub after main script is executed
+    fetchedSubState = await sub.fetchState(provider, subContractAddress, 0)
+    expect(fetchedSubState.fields.result).toEqual(1)
+    fetchedAddState = await add.fetchState(provider, addContractAddress, 0)
+    expect(fetchedAddState.fields.subContractId).toEqual(subContractId)
+    expect(fetchedAddState.fields.result).toEqual(3)
   }
 
   async function testSuite2() {
     const provider = new NodeProvider('http://127.0.0.1:22973')
 
-    const greeter = await Contract.fromSource(provider, 'greeter.ral')
+    const greeter = await Contract.fromSource(provider, 'greeter/greeter.ral')
 
     const testParams: TestContractParams = {
       initialFields: { btcPrice: 1 }
@@ -151,11 +168,11 @@ describe('contract', function () {
   }
 
   it('should load contract from json', async () => {
-    loadContract('./artifacts/add.ral.json')
-    loadContract('./artifacts/sub.ral.json')
+    loadContract('./artifacts/add/add.ral.json')
+    loadContract('./artifacts/sub/sub.ral.json')
     loadScript('./artifacts/main.ral.json')
 
-    loadContract('./artifacts/greeter.ral.json')
+    loadContract('./artifacts/greeter/greeter.ral.json')
     loadScript('./artifacts/greeter_main.ral.json')
   })
 })

package/test/events.test.ts

@@ -17,15 +17,16 @@ 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, timeout } from '../src/utils'
 
 describe('events', function () {
   async function deployContract(provider: NodeProvider, signer: NodeWallet): Promise<[string, string]> {
-    const sub = await Contract.fromSource(provider, 'sub.ral')
+    const sub = await Contract.fromSource(provider, 'sub/sub.ral')
     const subDeployTx = await sub.transactionForDeployment(signer, {
       initialFields: { result: 0 },
       initialTokenAmounts: []
@@ -34,7 +35,7 @@ describe('events', function () {
     const subSubmitResult = await signer.submitTransaction(subDeployTx.unsignedTx, subDeployTx.txId)
     expect(subSubmitResult.txId).toEqual(subDeployTx.txId)
 
-    const add = await Contract.fromSource(provider, 'add.ral')
+    const add = await Contract.fromSource(provider, 'add/add.ral')
     const addDeployTx = await add.transactionForDeployment(signer, {
       initialFields: { subContractId: subContractId, result: 0 },
       initialTokenAmounts: []
@@ -56,29 +57,28 @@ 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 },
       signerAddress: (await signer.getAccounts())[0].address
     })
     await executeScript(scriptTxParams, signer, 3)
-    await new Promise((resolve) => setTimeout(resolve, 3000))
+    await timeout(3000)
 
     expect(events.length).toEqual(3)
     events.forEach((event) => {
@@ -90,35 +90,34 @@ 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 }
     })
     await signer.submitTransaction(scriptTx0.unsignedTx, scriptTx0.txId)
-    await new Promise((resolve) => setTimeout(resolve, 1500))
+    await timeout(1500)
     subscription.unsubscribe()
 
     expect(events.length).toEqual(1)
@@ -133,7 +132,7 @@ describe('events', function () {
       initialFields: { addContractId: contractId }
     })
     await signer.submitTransaction(scriptTx1.unsignedTx, scriptTx1.txId)
-    await new Promise((resolve) => setTimeout(resolve, 1500))
+    await timeout(1500)
     expect(events.length).toEqual(1)
   })
 })

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, timeout } 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 timeout(1500)
+    expect(txStatus).toMatchObject({ type: 'TxNotFound' })
+
+    const subSubmitResult = await signer.submitTransaction(subDeployTx.unsignedTx, subDeployTx.txId)
+    await timeout(1500)
+    expect(txStatus).toMatchObject({ type: 'Confirmed' })
+
+    expect(counterBeforeSubscribe).toBeLessThan(counter)
+
+    subscription.unsubscribe()
+
+    const counterAfterUnsubscribe = counter
+    await timeout(1500)
+    expect(txStatus).toMatchObject({ type: 'Confirmed' })
+    expect(counterAfterUnsubscribe).toEqual(counter)
+  }, 10000)
+})