@alephium/web3 0.2.0-rc.6 → 0.2.0-rc.9

package/src/contract/contract.ts

@@ -17,16 +17,15 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Buffer } from 'buffer/'
-import * as cryptojs from 'crypto-js'
-import * as crypto from 'crypto'
+import { webcrypto as crypto } from 'crypto'
 import fs from 'fs'
 import { promises as fsPromises } from 'fs'
-import { NodeProvider } from '../api'
-import { node } from '../api'
+import { node, NodeProvider } from '../api'
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer'
 import * as ralph from './ralph'
 import { bs58, binToHex, contractIdFromAddress, assertType, Eq } from '../utils'
 import { CompileContractResult, CompileScriptResult } from '../api/api-alephium'
+import { getCurrentNodeProvider } from '../global'
 
 type FieldsSig = node.FieldsSig
 type EventSig = node.EventSig
@@ -39,16 +38,21 @@ enum SourceType {
   Interface = 3
 }
 
-export type CompilerOptions = {
+export type CompilerOptions = node.CompilerOptions & {
   errorOnWarnings: boolean
-  ignoreUnusedConstantsWarnings: boolean
 }
 
-export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = {
-  errorOnWarnings: true,
-  ignoreUnusedConstantsWarnings: true
+export const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions = {
+  ignoreUnusedConstantsWarnings: false,
+  ignoreUnusedVariablesWarnings: false,
+  ignoreUnusedFieldsWarnings: false,
+  ignoreUnusedPrivateFunctionsWarnings: false,
+  ignoreReadonlyCheckWarnings: false,
+  ignoreExternalCallCheckWarnings: false
 }
 
+export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = { errorOnWarnings: true, ...DEFAULT_NODE_COMPILER_OPTIONS }
+
 class TypedMatcher<T extends SourceType> {
   matcher: RegExp
   type: T
@@ -74,12 +78,17 @@ class SourceFile {
     return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json'
   }
 
-  constructor(type: SourceType, sourceCode: string, contractPath: string) {
+  constructor(type: SourceType, sourceCode: string, sourceCodeHash: string, contractPath: string) {
     this.type = type
     this.sourceCode = sourceCode
-    this.sourceCodeHash = cryptojs.SHA256(sourceCode).toString()
+    this.sourceCodeHash = sourceCodeHash
     this.contractPath = contractPath
   }
+
+  static async from(type: SourceType, sourceCode: string, contractPath: string): Promise<SourceFile> {
+    const sourceCodeHash = await crypto.subtle.digest('SHA-256', Buffer.from(sourceCode))
+    return new SourceFile(type, sourceCode, Buffer.from(sourceCodeHash).toString('hex'), contractPath)
+  }
 }
 
 class Compiled<T extends Artifact> {
@@ -97,19 +106,47 @@ class Compiled<T extends Artifact> {
 class ProjectArtifact {
   static readonly artifactFileName = '.project.json'
 
+  compilerOptionsUsed: node.CompilerOptions
   infos: Map<string, { sourceCodeHash: string; warnings: string[] }>
 
-  constructor(infos: Map<string, { sourceCodeHash: string; warnings: string[] }>) {
+  static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void {
+    if (Object.keys(compilerOptions).length != Object.keys(DEFAULT_NODE_COMPILER_OPTIONS).length) {
+      throw Error(`Not all compiler options are set: ${compilerOptions}`)
+    }
+
+    const combined = { ...compilerOptions, ...DEFAULT_NODE_COMPILER_OPTIONS }
+    if (Object.keys(combined).length !== Object.keys(DEFAULT_NODE_COMPILER_OPTIONS).length) {
+      throw Error(`There are unknown compiler options: ${compilerOptions}`)
+    }
+  }
+
+  constructor(
+    compilerOptionsUsed: node.CompilerOptions,
+    infos: Map<string, { sourceCodeHash: string; warnings: string[] }>
+  ) {
+    ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed)
+    this.compilerOptionsUsed = compilerOptionsUsed
     this.infos = infos
   }
 
   async saveToFile(rootPath: string): Promise<void> {
     const filepath = rootPath + '/' + ProjectArtifact.artifactFileName
-    const content = JSON.stringify(Object.fromEntries(this.infos), null, 2)
+    const artifact = { compilerOptionsUsed: this.compilerOptionsUsed, infos: Object.fromEntries(this.infos) }
+    const content = JSON.stringify(artifact, null, 2)
     return fsPromises.writeFile(filepath, content)
   }
 
-  sourceHasChanged(files: SourceFile[]): boolean {
+  needToReCompile(compilerOptions: node.CompilerOptions, files: SourceFile[]): boolean {
+    ProjectArtifact.checkCompilerOptionsParameter(compilerOptions)
+
+    const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
+      const usedOption = this.compilerOptionsUsed[`${key}`]
+      return usedOption === inputOption
+    })
+    if (!optionsMatched) {
+      return true
+    }
+
     if (files.length !== this.infos.size) {
       return true
     }
@@ -119,6 +156,7 @@ class ProjectArtifact {
         return true
       }
     }
+
     return false
   }
 
@@ -128,10 +166,10 @@ class ProjectArtifact {
       return undefined
     }
     const content = await fsPromises.readFile(filepath)
-    const files = new Map(
-      Object.entries<{ sourceCodeHash: string; warnings: string[] }>(JSON.parse(content.toString()))
-    )
-    return new ProjectArtifact(files)
+    const json = JSON.parse(content.toString())
+    const compilerOptionsUsed = json.compilerOptionsUsed as node.CompilerOptions
+    const files = new Map(Object.entries<{ sourceCodeHash: string; warnings: string[] }>(json.infos))
+    return new ProjectArtifact(compilerOptionsUsed, files)
   }
 }
 
@@ -139,6 +177,7 @@ export class Project {
   sourceFiles: SourceFile[]
   contracts: Compiled<Contract>[]
   scripts: Compiled<Script>[]
+  projectArtifact: ProjectArtifact
 
   readonly contractsRootPath: string
   readonly artifactsRootPath: string
@@ -160,13 +199,44 @@ export class Project {
     Project.scriptMatcher
   ]
 
+  static buildProjectArtifact(
+    sourceFiles: SourceFile[],
+    contracts: Compiled<Contract>[],
+    scripts: Compiled<Script>[],
+    compilerOptions: node.CompilerOptions
+  ): ProjectArtifact {
+    const files: Map<string, { sourceCodeHash: string; warnings: string[] }> = new Map()
+    contracts.forEach((c) => {
+      files.set(c.sourceFile.contractPath, {
+        sourceCodeHash: c.sourceFile.sourceCodeHash,
+        warnings: c.warnings
+      })
+    })
+    scripts.forEach((s) => {
+      files.set(s.sourceFile.contractPath, {
+        sourceCodeHash: s.sourceFile.sourceCodeHash,
+        warnings: s.warnings
+      })
+    })
+    const compiledSize = contracts.length + scripts.length
+    sourceFiles.slice(compiledSize).forEach((c) => {
+      files.set(c.contractPath, {
+        sourceCodeHash: c.sourceCodeHash,
+        warnings: []
+      })
+    })
+    return new ProjectArtifact(compilerOptions, files)
+  }
+
   private constructor(
     provider: NodeProvider,
     contractsRootPath: string,
     artifactsRootPath: string,
     sourceFiles: SourceFile[],
     contracts: Compiled<Contract>[],
-    scripts: Compiled<Script>[]
+    scripts: Compiled<Script>[],
+    errorOnWarnings: boolean,
+    projectArtifact: ProjectArtifact
   ) {
     this.nodeProvider = provider
     this.contractsRootPath = contractsRootPath
@@ -174,6 +244,14 @@ export class Project {
     this.sourceFiles = sourceFiles
     this.contracts = contracts
     this.scripts = scripts
+    this.projectArtifact = projectArtifact
+
+    if (errorOnWarnings) {
+      Project.checkCompilerWarnings(
+        [...contracts.map((c) => c.warnings).flat(), ...scripts.map((s) => s.warnings).flat()],
+        errorOnWarnings
+      )
+    }
   }
 
   private getContractPath(path: string): string {
@@ -184,15 +262,12 @@ export class Project {
       : this.contractsRootPath + '/' + path
   }
 
-  private static checkCompilerWarnings(warnings: string[], compilerOptions: CompilerOptions): void {
-    const remains = compilerOptions.ignoreUnusedConstantsWarnings
-      ? warnings.filter((s) => !s.includes('unused constants'))
-      : warnings
-    if (remains.length !== 0) {
+  static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void {
+    if (warnings.length !== 0) {
       const prefixPerWarning = '  - '
-      const warningString = prefixPerWarning + remains.join('\n' + prefixPerWarning)
-      const output = 'Compilation warnings:\n' + warningString + '\n'
-      if (compilerOptions.errorOnWarnings) {
+      const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning)
+      const output = `Compilation warnings:\n` + warningString + '\n'
+      if (errorOnWarnings) {
         throw new Error(output)
       } else {
         console.log(output)
@@ -200,23 +275,21 @@ export class Project {
     }
   }
 
-  static contract(path: string, compilerOptions?: Partial<CompilerOptions>): Contract {
+  static contract(path: string): Contract {
     const contractPath = Project.currentProject.getContractPath(path)
     const contract = Project.currentProject.contracts.find((c) => c.sourceFile.contractPath === contractPath)
     if (typeof contract === 'undefined') {
       throw new Error(`Contract ${contractPath} does not exist`)
     }
-    Project.checkCompilerWarnings(contract.warnings, { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions })
     return contract.artifact
   }
 
-  static script(path: string, compilerOptions?: Partial<CompilerOptions>): Script {
+  static script(path: string): Script {
     const contractPath = Project.currentProject.getContractPath(path)
     const script = Project.currentProject.scripts.find((c) => c.sourceFile.contractPath === contractPath)
     if (typeof script === 'undefined') {
       throw new Error(`Script ${contractPath} does not exist`)
     }
-    Project.checkCompilerWarnings(script.warnings, { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions })
     return script.artifact
   }
 
@@ -236,6 +309,7 @@ export class Project {
     for (const script of this.scripts) {
       await saveToFile(script)
     }
+    await this.projectArtifact.saveToFile(this.artifactsRootPath)
   }
 
   contractByCodeHash(codeHash: string): Contract {
@@ -246,40 +320,18 @@ export class Project {
     return contract.artifact
   }
 
-  private async saveProjectArtifactToFile(): Promise<void> {
-    const files: Map<string, { sourceCodeHash: string; warnings: string[] }> = new Map()
-    this.contracts.forEach((c) => {
-      files.set(c.sourceFile.contractPath, {
-        sourceCodeHash: c.sourceFile.sourceCodeHash,
-        warnings: c.warnings
-      })
-    })
-    this.scripts.forEach((s) => {
-      files.set(s.sourceFile.contractPath, {
-        sourceCodeHash: s.sourceFile.sourceCodeHash,
-        warnings: s.warnings
-      })
-    })
-    const compiledSize = this.contracts.length + this.scripts.length
-    this.sourceFiles.slice(compiledSize).forEach((c) => {
-      files.set(c.contractPath, {
-        sourceCodeHash: c.sourceCodeHash,
-        warnings: []
-      })
-    })
-    const projectArtifact = new ProjectArtifact(files)
-    await projectArtifact.saveToFile(this.artifactsRootPath)
-  }
-
   private static async compile(
     provider: NodeProvider,
     files: SourceFile[],
     contractsRootPath: string,
-    artifactsRootPath: string
+    artifactsRootPath: string,
+    errorOnWarnings: boolean,
+    compilerOptions: node.CompilerOptions
   ): Promise<Project> {
     const sourceStr = files.map((f) => f.sourceCode).join('\n')
     const result = await provider.contracts.postContractsCompileProject({
-      code: sourceStr
+      code: sourceStr,
+      compilerOptions: compilerOptions
     })
     const contracts: Compiled<Contract>[] = []
     const scripts: Compiled<Script>[] = []
@@ -293,9 +345,18 @@ export class Project {
       const script = Script.fromCompileResult(scriptResult)
       scripts.push(new Compiled(sourceFile, script, scriptResult.warnings))
     })
-    const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts)
+    const projectArtifact = Project.buildProjectArtifact(files, contracts, scripts, compilerOptions)
+    const project = new Project(
+      provider,
+      contractsRootPath,
+      artifactsRootPath,
+      files,
+      contracts,
+      scripts,
+      errorOnWarnings,
+      projectArtifact
+    )
     await project.saveArtifactsToFile()
-    await project.saveProjectArtifactToFile()
     return project
   }
 
@@ -304,7 +365,9 @@ export class Project {
     files: SourceFile[],
     projectArtifact: ProjectArtifact,
     contractsRootPath: string,
-    artifactsRootPath: string
+    artifactsRootPath: string,
+    errorOnWarnings: boolean,
+    compilerOptions: node.CompilerOptions
   ): Promise<Project> {
     try {
       const contracts: Compiled<Contract>[] = []
@@ -324,10 +387,20 @@ export class Project {
           scripts.push(new Compiled(file, artifact, warnings))
         }
       }
-      return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts)
+
+      return new Project(
+        provider,
+        contractsRootPath,
+        artifactsRootPath,
+        files,
+        contracts,
+        scripts,
+        errorOnWarnings,
+        projectArtifact
+      )
     } catch (error) {
       console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`)
-      return Project.compile(provider, files, contractsRootPath, artifactsRootPath)
+      return Project.compile(provider, files, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions)
     }
   }
 
@@ -349,7 +422,7 @@ export class Project {
     }
     const matcherIndex = results.indexOf(1)
     const type = this.matchers[`${matcherIndex}`].type
-    return new SourceFile(type, sourceStr, contractPath)
+    return SourceFile.from(type, sourceStr, contractPath)
   }
 
   private static async loadSourceFiles(contractsRootPath: string): Promise<SourceFile[]> {
@@ -377,21 +450,34 @@ export class Project {
   }
 
   static async build(
-    provider: NodeProvider,
+    compilerOptionsPartial: Partial<CompilerOptions> = {},
     contractsRootPath = 'contracts',
     artifactsRootPath = 'artifacts'
   ): Promise<void> {
+    const provider = getCurrentNodeProvider()
     const sourceFiles = await Project.loadSourceFiles(contractsRootPath)
+    const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
     const projectArtifact = await ProjectArtifact.from(artifactsRootPath)
-    if (typeof projectArtifact === 'undefined' || projectArtifact.sourceHasChanged(sourceFiles)) {
-      Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath)
+    if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
+      console.log(`Compile contracts in folder "${contractsRootPath}"`)
+      Project.currentProject = await Project.compile(
+        provider,
+        sourceFiles,
+        contractsRootPath,
+        artifactsRootPath,
+        errorOnWarnings,
+        nodeCompilerOptions
+      )
     } else {
+      console.log(`Load compiled contracts from folder "${artifactsRootPath}"`)
       Project.currentProject = await Project.loadArtifacts(
         provider,
         sourceFiles,
         projectArtifact,
         contractsRootPath,
-        artifactsRootPath
+        artifactsRootPath,
+        errorOnWarnings,
+        nodeCompilerOptions
       )
     }
   }
@@ -502,8 +588,10 @@ export class Contract extends Artifact {
     }
   }
 
+  // no need to be cryptographically strong random
   static randomAddress(): string {
-    const bytes = crypto.randomBytes(33)
+    const bytes = new Uint8Array(33)
+    crypto.getRandomValues(bytes)
     bytes[0] = 3
     return bs58.encode(bytes)
   }

package/src/{test/index.ts → global.ts}

@@ -16,17 +16,21 @@ 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 '../api'
-import { NodeWallet } from '../signer'
+import { NodeProvider } from './api'
 
-export const testWalletName = 'alephium-web3-test-only-wallet'
-export const testAddress = '1DrDyTr9RpRsQnDnXo2YRiPzPW4ooHX5LLoqXrqfMrpQH'
-export const testPassword = 'alph'
+let _currentNodeProvider: NodeProvider | undefined = undefined
 
-export async function testWallet(provider: NodeProvider): Promise<NodeWallet> {
-  const wallet = new NodeWallet(provider, testWalletName)
-  await wallet.unlock(testPassword)
-  return wallet
+export function setCurrentNodeProvider(provider: NodeProvider | string): void {
+  if (typeof provider == 'string') {
+    _currentNodeProvider = new NodeProvider(provider)
+  } else {
+    _currentNodeProvider = provider
+  }
 }
 
-export * from './privatekey-wallet'
+export function getCurrentNodeProvider(): NodeProvider {
+  if (typeof _currentNodeProvider === 'undefined') {
+    throw Error('No node provider is set.')
+  }
+  return _currentNodeProvider
+}

package/src/index.ts

@@ -23,3 +23,6 @@ export * from './utils'
 export * from './transaction'
 
 export * from './constants'
+export * 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

@@ -23,6 +23,7 @@ import * as utils from '../utils'
 import { Eq, assertType } from '../utils'
 import blake from 'blakejs'
 import { Token } from '../api/api-alephium'
+import { getCurrentNodeProvider } from '../global'
 
 const ec = new EC('secp256k1')
 
@@ -167,8 +168,8 @@ export abstract class SignerWithNodeProvider implements SignerProvider {
     }
   }
 
-  constructor(provider: NodeProvider, alwaysSubmitTx: boolean) {
-    this.provider = provider
+  constructor(alwaysSubmitTx: boolean) {
+    this.provider = getCurrentNodeProvider()
     this.alwaysSubmitTx = alwaysSubmitTx
   }
 

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/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,13 +17,13 @@ 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>
@@ -40,7 +40,7 @@ export abstract class Subscription<Message> {
   protected cancelled: boolean
 
   constructor(options: SubscribeOptions<Message>) {
-    this.provider = options.provider
+    this.provider = getCurrentNodeProvider()
     this.pollingInterval = options.pollingInterval
     this.messageCallback = options.messageCallback
     this.errorCallback = options.errorCallback

package/src/utils/utils.ts

@@ -51,7 +51,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 +66,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 +85,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 +103,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 +111,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 +120,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 +129,7 @@ const groupOfP2mpkhAddress = (address: Uint8Array): number => {
 }
 
 // Pay to script hash address
-const groupOfP2shAddress = (address: Uint8Array): number => {
+function groupOfP2shAddress(address: Uint8Array): number {
   return groupOfAddressBytes(address)
 }
 

package/templates/base/package.json

@@ -3,7 +3,7 @@
   "version": "0.1.0",
   "license": "GPL",
   "config": {
-    "alephium_version": "1.5.0-rc5"
+    "alephium_version": "1.5.0-rc7"
   },
   "scripts": {
     "build": "rm -rf dist && npx tsc --build .",
@@ -12,7 +12,7 @@
     "stop-devnet": "node scripts/stop-devnet.js"
   },
   "dependencies": {
-    "@alephium/web3": "0.2.0-rc.6"
+    "@alephium/web3": "0.2.0-rc.9"
   },
   "devDependencies": {
     "@types/elliptic": "^6.4.13",

package/templates/base/src/greeter.ts

@@ -2,21 +2,22 @@
  * greeter.ts
  */
 
-import { NodeProvider, Contract, Script, TestContractParams } from '@alephium/web3'
-import { testWallet } from '@alephium/web3/test'
+import { TestContractParams, setCurrentNodeProvider, Project } from '@alephium/web3'
+import { testNodeWallet } from '@alephium/web3/test'
 
 async function greet() {
-  const provider = new NodeProvider('http://127.0.0.1:22973')
+  setCurrentNodeProvider('http://127.0.0.1:22973')
+  await Project.build()
 
-  const greeter = await Contract.fromSource(provider, 'greeter.ral')
+  const greeter = Project.contract('greeter/greeter.ral')
 
   const testParams: TestContractParams = {
     initialFields: { btcPrice: 1 }
   }
-  const testResult = await greeter.testPublicMethod(provider, 'greet', testParams)
+  const testResult = await greeter.testPublicMethod('greet', testParams)
   console.log(testResult)
 
-  const signer = await testWallet(provider)
+  const signer = await testNodeWallet()
 
   const deployTx = await greeter.transactionForDeployment(signer, { initialFields: testParams.initialFields })
   const greeterContractId = deployTx.contractId
@@ -26,7 +27,7 @@ async function greet() {
   const submitResult = await signer.submitTransaction(deployTx.unsignedTx, deployTx.txId)
   console.log(submitResult)
 
-  const main = await Script.fromSource(provider, 'greeter_main.ral')
+  const main = Project.script('greeter_main.ral')
 
   const mainScriptTx = await main.transactionForDeployment(signer, {
     initialFields: { greeterContractId: greeterContractId }

package/templates/react/package.json

@@ -2,7 +2,7 @@
   "name": "my-dapp",
   "version": "0.1.0",
   "config": {
-    "alephium_version": "1.5.0-rc5"
+    "alephium_version": "1.5.0-rc7"
   },
   "dependencies": {
     "@testing-library/jest-dom": "^5.16.4",
@@ -12,7 +12,7 @@
     "@types/node": "^16.11.26",
     "@types/react": "^18.0.3",
     "@types/react-dom": "^18.0.0",
-    "@alephium/web3": "0.2.0-rc.6",
+    "@alephium/web3": "0.2.0-rc.9",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "react-scripts": "5.0.1",