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

package/templates/react/src/App.tsx

@@ -1,42 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import './App.css'
-
-import { explorer, Contract, Script } from '@alephium/web3'
-import contractJson from './artifacts/greeter.ral.json'
-import scriptJson from './artifacts/greeter_main.ral.json'
-
-function Dashboard() {
-  const api = new explorer.Api<null>({ baseUrl: 'https://mainnet-backend.alephium.org' })
-  const contract = Contract.fromJson(contractJson).toString()
-  const script = Script.fromJson(scriptJson).toString()
-  const [blocks, setBlocks] = useState('')
-
-  useEffect(() => {
-    async function fetchBlocks() {
-      const blocks = (await api.blocks.getBlocks({ page: 1 })).total
-      setBlocks(JSON.stringify(blocks))
-    }
-
-    fetchBlocks()
-  })
-
-  return (
-    <div>
-      <p>blocks: {blocks}</p>
-      <p>contract: {contract}</p>
-      <p>script: {script}</p>
-    </div>
-  )
-}
-
-function App() {
-  return (
-    <div className='App'>
-      <header className='App-header'>
-        <Dashboard />
-      </header>
-    </div>
-  )
-}
-
-export default App

package/templates/react/src/artifacts/greeter.ral.json

@@ -1,26 +0,0 @@
-{
-  "sourceCodeSha256": "10fe90ccf08b6b3fd2a653bd4258628f5dd165788cc48a83f9d6ff8039404588",
-  "functions": [
-    {
-      "name": "greet",
-      "signature": "pub greet()->(U256)",
-      "argNames": [],
-      "argTypes": [],
-      "returnTypes": [
-        "U256"
-      ]
-    }
-  ],
-  "bytecode": "010109010000000102a00002",
-  "codeHash": "39debc1122591f4c96e2f807632acc6d137ea9bba303a4e04476cd8cade35242",
-  "fieldsSig": {
-    "signature": "TxContract Greeter(btcPrice:U256)",
-    "names": [
-      "btcPrice"
-    ],
-    "types": [
-      "U256"
-    ]
-  },
-  "eventsSig": []
-}

package/templates/react/src/artifacts/greeter_main.ral.json

@@ -1,22 +0,0 @@
-{
-  "sourceCodeSha256": "c1f3b4c4a8c6832d0c9b3e2c7c623de85331d8b0d853daf2acc4288e5655aff7",
-  "functions": [
-    {
-      "name": "main",
-      "signature": "pub payable main()->()",
-      "argNames": [],
-      "argTypes": [],
-      "returnTypes": []
-    }
-  ],
-  "bytecodeTemplate": "0101010002000e{0}1700160001000d2f4d{0}1701160101000d2f4d",
-  "fieldsSig": {
-    "signature": "TxScript Main(greeterContractId:ByteVec)",
-    "names": [
-      "greeterContractId"
-    ],
-    "types": [
-      "ByteVec"
-    ]
-  }
-}

package/templates/shared/.eslintrc.json

@@ -1,12 +0,0 @@
-{
-  "extends": ["prettier", "plugin:react/recommended"],
-  "rules": {
-    "header/header": [0]
-  },
-  "parserOptions": {
-    "project": "tsconfig.json",
-    "ecmaVersion": 2020,
-    "sourceType": "module"
-  },
-  "parser": "@typescript-eslint/parser"
-}

package/test/contract.test.ts

@@ -1,197 +0,0 @@
-/*
-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 * as fs from 'fs'
-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/add.ral')
-    const sub = await Contract.fromSource(provider, 'sub/sub.ral')
-
-    const subState = sub.toState({ result: 0 }, { alphAmount: BigInt('1000000000000000000') })
-    const testParams: TestContractParams = {
-      initialFields: { subContractId: subState.contractId, result: 0 },
-      testArgs: { array: [2, 1] },
-      existingContracts: [subState]
-    }
-    const testResult = await add.testPublicMethod(provider, 'add', testParams)
-    expect(testResult.returns).toEqual([[3, 1]])
-    expect(testResult.contracts[0].codeHash).toEqual(sub.codeHash)
-    expect(testResult.contracts[0].fields.result).toEqual(1)
-    expect(testResult.contracts[1].codeHash).toEqual(add.codeHash)
-    expect(testResult.contracts[1].fields.subContractId).toEqual(subState.contractId)
-    expect(testResult.contracts[1].fields.result).toEqual(3)
-    const events = testResult.events.sort((a, b) => a.name.localeCompare(b.name))
-    expect(events[0].name).toEqual('Add')
-    expect(events[0].fields.x).toEqual(2)
-    expect(events[0].fields.y).toEqual(1)
-    expect(events[1].name).toEqual('Sub')
-    expect(events[1].fields.x).toEqual(2)
-    expect(events[1].fields.y).toEqual(1)
-
-    const testResultPrivate = await add.testPrivateMethod(provider, 'addPrivate', testParams)
-    expect(testResultPrivate.returns).toEqual([[3, 1]])
-
-    const signer = await testWallet(provider)
-
-    const subDeployTx = await sub.transactionForDeployment(signer, {
-      initialFields: { result: 0 },
-      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)
-    expect(subSubmitResult.fromGroup).toEqual(0)
-    expect(subSubmitResult.toGroup).toEqual(0)
-    expect(subSubmitResult.txId).toEqual(subDeployTx.txId)
-
-    const addDeployTx = await add.transactionForDeployment(signer, {
-      initialFields: { subContractId: subContractId, result: 0 },
-      initialTokenAmounts: []
-    })
-    expect(addDeployTx.fromGroup).toEqual(0)
-    expect(addDeployTx.toGroup).toEqual(0)
-    const addSubmitResult = await signer.submitTransaction(addDeployTx.unsignedTx, addDeployTx.txId)
-    expect(addSubmitResult.fromGroup).toEqual(0)
-    expect(addSubmitResult.toGroup).toEqual(0)
-    expect(addSubmitResult.txId).toEqual(addDeployTx.txId)
-
-    const addContractId = addDeployTx.contractId
-    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 }
-    })
-    expect(mainScriptTx.fromGroup).toEqual(0)
-    expect(mainScriptTx.toGroup).toEqual(0)
-    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/greeter.ral')
-
-    const testParams: TestContractParams = {
-      initialFields: { btcPrice: 1 }
-    }
-    const testResult = await greeter.testPublicMethod(provider, 'greet', testParams)
-    expect(testResult.returns).toEqual([1])
-    expect(testResult.contracts[0].codeHash).toEqual(greeter.codeHash)
-    expect(testResult.contracts[0].fields.btcPrice).toEqual(1)
-
-    const signer = await testWallet(provider)
-
-    const deployTx = await greeter.transactionForDeployment(signer, {
-      initialFields: { btcPrice: 1 },
-      initialTokenAmounts: []
-    })
-    expect(deployTx.fromGroup).toEqual(0)
-    expect(deployTx.toGroup).toEqual(0)
-    const submitResult = await signer.submitTransaction(deployTx.unsignedTx, deployTx.txId)
-    expect(submitResult.fromGroup).toEqual(0)
-    expect(submitResult.toGroup).toEqual(0)
-    expect(submitResult.txId).toEqual(deployTx.txId)
-
-    const greeterContractId = deployTx.contractId
-    const main = await Script.fromSource(provider, 'greeter_main.ral')
-
-    const mainScriptTx = await main.transactionForDeployment(signer, {
-      initialFields: { greeterContractId: greeterContractId }
-    })
-    expect(mainScriptTx.fromGroup).toEqual(0)
-    expect(mainScriptTx.toGroup).toEqual(0)
-    const mainSubmitResult = await signer.submitTransaction(mainScriptTx.unsignedTx, mainScriptTx.txId)
-    expect(mainSubmitResult.fromGroup).toEqual(0)
-    expect(mainSubmitResult.toGroup).toEqual(0)
-  }
-
-  it('should test contracts', async () => {
-    await testSuite1()
-    await testSuite2()
-  })
-
-  function loadJson(fileName: string) {
-    const filePath = path.resolve(process.cwd() + path.sep + fileName)
-    const rawData = fs.readFileSync(filePath).toString()
-    return JSON.parse(rawData)
-  }
-
-  function loadContract(fileName: string) {
-    Contract.fromJson(loadJson(fileName))
-  }
-
-  function loadScript(fileName: string) {
-    Script.fromJson(loadJson(fileName))
-  }
-
-  it('should load contract from json', async () => {
-    loadContract('./artifacts/add/add.ral.json')
-    loadContract('./artifacts/sub/sub.ral.json')
-    loadScript('./artifacts/main.ral.json')
-
-    loadContract('./artifacts/greeter/greeter.ral.json')
-    loadScript('./artifacts/greeter_main.ral.json')
-  })
-
-  it('should extract metadata of contracts', async () => {
-    const provider = new NodeProvider('http://127.0.0.1:22973')
-    const contract = await Contract.fromSource(provider, 'test/metadata.ral')
-    expect(contract.functions.map((func) => func.name)).toEqual(['foo', 'bar', 'baz'])
-    expect(contract.publicFunctions()).toEqual(['foo'])
-    expect(contract.usingPreapprovedAssetsFunctions()).toEqual(['foo'])
-    expect(contract.usingAssetsInContractFunctions()).toEqual(['bar'])
-  })
-
-  it('should handle compiler warnings', async () => {
-    const provider = new NodeProvider('http://127.0.0.1:22973')
-    const contract = await Contract.fromSource(provider, 'test/warnings.ral', false)
-    expect(contract.publicFunctions()).toEqual(['foo'])
-
-    await expect(Contract.fromSource(provider, 'test/warnings.ral')).rejects.toThrowError(
-      'Compilation warnings:\n  - Found unused variables in function foo: foo.y\n  - Found unused fields: b'
-    )
-  })
-})

package/test/events.test.ts

@@ -1,138 +0,0 @@
-/*
-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 { subscribeToEvents } from '../src/contract/events'
-import { Contract, Script } from '../src/contract'
-import { NodeWallet, SignExecuteScriptTxParams } from '../src/signer'
-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/sub.ral')
-    const subDeployTx = await sub.transactionForDeployment(signer, {
-      initialFields: { result: 0 },
-      initialTokenAmounts: []
-    })
-    const subContractId = subDeployTx.contractId
-    const subSubmitResult = await signer.submitTransaction(subDeployTx.unsignedTx, subDeployTx.txId)
-    expect(subSubmitResult.txId).toEqual(subDeployTx.txId)
-
-    const add = await Contract.fromSource(provider, 'add/add.ral')
-    const addDeployTx = await add.transactionForDeployment(signer, {
-      initialFields: { subContractId: subContractId, result: 0 },
-      initialTokenAmounts: []
-    })
-    const addSubmitResult = await signer.submitTransaction(addDeployTx.unsignedTx, addDeployTx.txId)
-    expect(addSubmitResult.txId).toEqual(addDeployTx.txId)
-    return [addDeployTx.contractAddress, addDeployTx.contractId]
-  }
-
-  async function executeScript(params: SignExecuteScriptTxParams, signer: NodeWallet, times: number) {
-    for (let i = 0; i < times; i++) {
-      const scriptTx = await signer.buildScriptTx(params)
-      await signer.submitTransaction(scriptTx.unsignedTx, scriptTx.txId)
-    }
-  }
-
-  it('should subscribe contract events', 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<ContractEvent> = []
-    const subscriptOptions: SubscribeOptions<ContractEvent> = {
-      provider: provider,
-      pollingInterval: 500,
-      messageCallback: (event: ContractEvent): Promise<void> => {
-        events.push(event)
-        return Promise.resolve()
-      },
-      errorCallback: (error: any, subscription): Promise<void> => {
-        console.log(error)
-        subscription.unsubscribe()
-        return Promise.resolve()
-      }
-    }
-    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 timeout(3000)
-
-    expect(events.length).toEqual(3)
-    events.forEach((event) => {
-      expect(event.fields).toEqual([
-        { type: 'U256', value: '2' },
-        { type: 'U256', value: '1' }
-      ])
-    })
-    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<ContractEvent> = []
-    const subscriptOptions = {
-      provider: provider,
-      pollingInterval: 500,
-      messageCallback: (event: ContractEvent): Promise<void> => {
-        events.push(event)
-        return Promise.resolve()
-      },
-      errorCallback: (error: any, subscription): Promise<void> => {
-        console.log(error)
-        subscription.unsubscribe()
-        return Promise.resolve()
-      }
-    }
-    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 timeout(1500)
-    subscription.unsubscribe()
-
-    expect(events.length).toEqual(1)
-    expect(events[0].txId).toEqual(scriptTx0.txId)
-    expect(events[0].fields).toEqual([
-      { type: 'U256', value: '2' },
-      { type: 'U256', value: '1' }
-    ])
-    expect(subscription.currentEventCount()).toEqual(events.length)
-
-    const scriptTx1 = await script.transactionForDeployment(signer, {
-      initialFields: { addContractId: contractId }
-    })
-    await signer.submitTransaction(scriptTx1.unsignedTx, scriptTx1.txId)
-    await timeout(1500)
-    expect(events.length).toEqual(1)
-  })
-})

package/test/transaction.test.ts

@@ -1,72 +0,0 @@
-/*
-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/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' })
-
-    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)
-})