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

package/src/contract/contract.ts

@@ -46,12 +46,16 @@ class SourceFile {
   }
 }
 
+type FieldsSig = node.FieldsSig
+type EventSig = node.EventSig
+type FunctionSig = node.FunctionSig
+
 export abstract class Common {
   readonly sourceCodeSha256: string
-  readonly functions: node.FunctionSig[]
+  readonly functions: FunctionSig[]
 
   static readonly importRegex = new RegExp('^import "([^"/]+/(([^"]+)/)?)?[a-z][a-z_0-9]*.ral"', 'mg')
-  static readonly contractRegex = new RegExp('^TxContract [A-Z][a-zA-Z0-9]*', 'mg')
+  static readonly contractRegex = new RegExp('^(Abstract[ ]+)?Contract [A-Z][a-zA-Z0-9]*', 'mg')
   static readonly interfaceRegex = new RegExp('^Interface [A-Z][a-zA-Z0-9]* \\{', 'mg')
   static readonly scriptRegex = new RegExp('^TxScript [A-Z][a-zA-Z0-9]*', 'mg')
 
@@ -70,7 +74,7 @@ export abstract class Common {
     }
   }
 
-  constructor(sourceCodeSha256: string, functions: node.FunctionSig[]) {
+  constructor(sourceCodeSha256: string, functions: FunctionSig[]) {
     this.sourceCodeSha256 = sourceCodeSha256
     this.functions = functions
   }
@@ -152,7 +156,14 @@ export abstract class Common {
     provider: NodeProvider,
     sourceFile: SourceFile,
     loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>,
-    compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string) => Promise<T>
+    compile: (
+      provider: NodeProvider,
+      sourceFile: SourceFile,
+      contractStr: string,
+      contractHash: string,
+      errorOnWarnings: boolean
+    ) => Promise<T>,
+    errorOnWarnings: boolean
   ): Promise<T> {
     Common.checkFileNameExtension(sourceFile.contractPath)
 
@@ -162,7 +173,7 @@ export abstract class Common {
     if (typeof existingContract !== 'undefined') {
       return existingContract as unknown as T
     } else {
-      return compile(provider, sourceFile, contractStr, contractHash)
+      return compile(provider, sourceFile, contractStr, contractHash, errorOnWarnings)
     }
   }
 
@@ -175,21 +186,46 @@ export abstract class Common {
   }
 
   abstract buildByteCodeToDeploy(initialFields?: Fields): string
+
+  publicFunctions(): string[] {
+    return this.functions.filter((func) => func.isPublic).map((func) => func.name)
+  }
+
+  usingPreapprovedAssetsFunctions(): string[] {
+    return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name)
+  }
+
+  usingAssetsInContractFunctions(): string[] {
+    return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name)
+  }
+
+  protected static checkCompilerWarnings(compiled: { warnings: string[] }, errorOnWarnings: boolean): void {
+    if (compiled.warnings.length !== 0) {
+      const prefixPerWarning = '  - '
+      const warningString = prefixPerWarning + compiled.warnings.join('\n' + prefixPerWarning)
+      const output = 'Compilation warnings:\n' + warningString + '\n'
+      if (errorOnWarnings) {
+        throw new Error(output)
+      } else {
+        console.log(output)
+      }
+    }
+  }
 }
 
 export class Contract extends Common {
   readonly bytecode: string
   readonly codeHash: string
-  readonly fieldsSig: node.FieldsSig
-  readonly eventsSig: node.EventSig[]
+  readonly fieldsSig: FieldsSig
+  readonly eventsSig: EventSig[]
 
   constructor(
     sourceCodeSha256: string,
     bytecode: string,
     codeHash: string,
-    fieldsSig: node.FieldsSig,
-    eventsSig: node.EventSig[],
-    functions: node.FunctionSig[]
+    fieldsSig: FieldsSig,
+    eventsSig: EventSig[],
+    functions: FunctionSig[]
   ) {
     super(sourceCodeSha256, functions)
     this.bytecode = bytecode
@@ -223,7 +259,7 @@ export class Contract extends Common {
     return Common._loadContractStr(sourceFile, [], (code) => Contract.checkCodeType(sourceFile.contractPath, code))
   }
 
-  static async fromSource(provider: NodeProvider, path: string): Promise<Contract> {
+  static async fromSource(provider: NodeProvider, path: string, errorOnWarnings = true): Promise<Contract> {
     if (!fs.existsSync(Common._artifactsFolder())) {
       fs.mkdirSync(Common._artifactsFolder(), { recursive: true })
     }
@@ -232,7 +268,8 @@ export class Contract extends Common {
       provider,
       sourceFile,
       (sourceFile) => Contract.loadContractStr(sourceFile),
-      Contract.compile
+      Contract.compile,
+      errorOnWarnings
     )
     this._putArtifactToCache(contract)
     return contract
@@ -242,9 +279,12 @@ export class Contract extends Common {
     provider: NodeProvider,
     sourceFile: SourceFile,
     contractStr: string,
-    contractHash: string
+    contractHash: string,
+    errorOnWarnings: boolean
   ): Promise<Contract> {
     const compiled = await provider.contracts.postContractsCompileContract({ code: contractStr })
+    Common.checkCompilerWarnings(compiled, errorOnWarnings)
+
     const artifact = new Contract(
       contractHash,
       compiled.bytecode,
@@ -341,7 +381,7 @@ export class Contract extends Common {
 
     const methodIndex =
       typeof params.testMethodIndex !== 'undefined' ? params.testMethodIndex : this.getMethodIndex(funcName)
-    const isPublic = this.functions[`${methodIndex}`].signature.indexOf('pub ') !== -1
+    const isPublic = this.functions[`${methodIndex}`].isPublic
     if (isPublic === expectPublic) {
       const result = await this.fromTestContractResult(methodIndex, apiResult)
       return result
@@ -430,7 +470,7 @@ export class Contract extends Common {
     throw new Error(`Unknown code with code hash: ${codeHash}`)
   }
 
-  static async getFieldsSig(state: node.ContractState): Promise<node.FieldsSig> {
+  static async getFieldsSig(state: node.ContractState): Promise<FieldsSig> {
     return Contract.fromCodeHash(state.codeHash).then((contract) => contract.fieldsSig)
   }
 
@@ -448,16 +488,14 @@ export class Contract extends Common {
     }
   }
 
-  static ContractCreatedEvent: node.EventSig = {
+  static ContractCreatedEvent: EventSig = {
     name: 'ContractCreated',
-    signature: 'event ContractCreated(address:Address)',
     fieldNames: ['address'],
     fieldTypes: ['Address']
   }
 
-  static ContractDestroyedEvent: node.EventSig = {
+  static ContractDestroyedEvent: EventSig = {
     name: 'ContractDestroyed',
-    signature: 'event ContractDestroyed(address:Address)',
     fieldNames: ['address'],
     fieldTypes: ['Address']
   }
@@ -466,7 +504,7 @@ export class Contract extends Common {
     event: node.ContractEventByTxId,
     codeHash: string | undefined
   ): Promise<ContractEventByTxId> {
-    let eventSig: node.EventSig
+    let eventSig: EventSig
 
     if (event.eventIndex == -1) {
       eventSig = this.ContractCreatedEvent
@@ -543,14 +581,9 @@ export class Contract extends Common {
 
 export class Script extends Common {
   readonly bytecodeTemplate: string
-  readonly fieldsSig: node.FieldsSig
+  readonly fieldsSig: FieldsSig
 
-  constructor(
-    sourceCodeSha256: string,
-    bytecodeTemplate: string,
-    fieldsSig: node.FieldsSig,
-    functions: node.FunctionSig[]
-  ) {
+  constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]) {
     super(sourceCodeSha256, functions)
     this.bytecodeTemplate = bytecodeTemplate
     this.fieldsSig = fieldsSig
@@ -571,18 +604,26 @@ export class Script extends Common {
     return Common._loadContractStr(sourceFile, [], (code) => Script.checkCodeType(sourceFile.contractPath, code))
   }
 
-  static async fromSource(provider: NodeProvider, path: string): Promise<Script> {
+  static async fromSource(provider: NodeProvider, path: string, errorOnWarnings = true): Promise<Script> {
     const sourceFile = this.getSourceFile(path, [])
-    return Common._from(provider, sourceFile, (sourceFile) => Script.loadContractStr(sourceFile), Script.compile)
+    return Common._from(
+      provider,
+      sourceFile,
+      (sourceFile) => Script.loadContractStr(sourceFile),
+      Script.compile,
+      errorOnWarnings
+    )
   }
 
   private static async compile(
     provider: NodeProvider,
     sourceFile: SourceFile,
     scriptStr: string,
-    contractHash: string
+    contractHash: string,
+    errorOnWarnings = true
   ): Promise<Script> {
     const compiled = await provider.contracts.postContractsCompileScript({ code: scriptStr })
+    Common.checkCompilerWarnings(compiled, errorOnWarnings)
     const artifact = new Script(contractHash, compiled.bytecodeTemplate, compiled.fields, compiled.functions)
     await artifact._saveToFile(sourceFile)
     return artifact
@@ -895,7 +936,7 @@ export interface ContractState {
   initialStateHash?: string
   codeHash: string
   fields: Fields
-  fieldsSig: node.FieldsSig
+  fieldsSig: FieldsSig
   asset: Asset
 }
 
@@ -918,12 +959,12 @@ function toApiContractState(state: ContractState): node.ContractState {
   }
 }
 
-function toApiFields(fields: Fields, fieldsSig: node.FieldsSig): node.Val[] {
+function toApiFields(fields: Fields, fieldsSig: FieldsSig): node.Val[] {
   return toApiVals(fields, fieldsSig.names, fieldsSig.types)
 }
 
-function toApiArgs(args: Arguments, funcSig: node.FunctionSig): node.Val[] {
-  return toApiVals(args, funcSig.argNames, funcSig.argTypes)
+function toApiArgs(args: Arguments, funcSig: FunctionSig): node.Val[] {
+  return toApiVals(args, funcSig.paramNames, funcSig.paramTypes)
 }
 
 function toApiVals(fields: Fields, names: string[], types: string[]): node.Val[] {

package/src/contract/events.ts

@@ -31,7 +31,7 @@ export class EventSubscription extends Subscription<ContractEvent> {
     this.startPolling()
   }
 
-  override startPolling() {
+  override startPolling(): void {
     this.eventEmitter.on('tick', async () => {
       await this.polling()
     })
@@ -42,7 +42,7 @@ export class EventSubscription extends Subscription<ContractEvent> {
     return this.fromCount
   }
 
-  override async polling() {
+  override async polling(): Promise<void> {
     try {
       const events = await this.provider.events.getEventsContractContractaddress(this.contractAddress, {
         start: this.fromCount

package/src/contract/ralph.test.ts

@@ -133,9 +133,9 @@ describe('contract', function () {
   it('should test buildScriptByteCode', async () => {
     const variables = { x: true, y: 0x05, z: 'ff', a: '1C2RAVWSuaXw8xtUxqVERR7ChKBE1XgscNFw73NSHE1v3' }
     const fieldsSig: node.FieldsSig = {
-      signature: 'Not really',
       names: ['x', 'y', 'z', 'a'],
-      types: ['Bool', 'U256', 'ByteVec', 'Address']
+      types: ['Bool', 'U256', 'ByteVec', 'Address'],
+      isMutable: [false, false, false, false]
     }
     const bytecode = ralph.buildScriptByteCode('-{0}-{1}-{2}-{3}-', variables, fieldsSig)
     expect(bytecode).toEqual('-03-1305-1401ff-1500a3cd757be03c7dac8d48bf79e2a7d6e735e018a9c054b99138c7b29738c437ec-')
@@ -150,9 +150,9 @@ describe('contract', function () {
       e: [false, true]
     }
     const fieldsSig: node.FieldsSig = {
-      signature: 'Not really',
       names: ['a', 'b', 'c', 'd', 'e'],
-      types: ['I256', 'U256', 'ByteVec', 'Address', '[Bool;2]']
+      types: ['I256', 'U256', 'ByteVec', 'Address', '[Bool;2]'],
+      isMutable: [false, false, false, false]
     }
     const encoded = ralph.buildContractByteCode('ff', fields, fieldsSig)
     expect(encoded).toEqual(

package/src/transaction/status.ts

@@ -33,7 +33,7 @@ export class TxStatusSubscription extends Subscription<TxStatus> {
     this.startPolling()
   }
 
-  override async polling() {
+  override async polling(): Promise<void> {
     try {
       const txStatus = await this.provider.transactions.getTransactionsStatus({
         txId: this.txId,

package/src/utils/subscription.ts

@@ -49,7 +49,7 @@ export abstract class Subscription<Message> {
     this.eventEmitter = new EventEmitter()
   }
 
-  startPolling() {
+  startPolling(): void {
     this.eventEmitter.on('tick', async () => {
       await this.polling()
 

package/src/utils/utils.test.ts

@@ -151,7 +151,7 @@ describe('utils', function () {
         '0a38bc48fbb4300f1e305b201cd6129372d867122efb814d871d18c0bfe43b56',
         '4f51cd1f0af97cf5ec9c7a3397eaeea549d55a93c216e54f2ab4a8cf29f6f865'
       )
-    ).toBe('293c948c81c5a9495178fff8b8c9f29f4f3e09e1728c40e9253c87adf5e18770')
+    ).toBe('0e28f15ca290002c31d691aa008aa56ac12356b0380efb6c88fff929b6a268a9')
   })
 
   it('should convert from string to hex and back', () => {

package/src/utils/utils.ts

@@ -190,7 +190,7 @@ export function contractIdFromTx(txId: string, outputIndex: number): string {
 }
 
 export function subContractId(parentContractId: string, pathInHex: string): string {
-  const data = Buffer.concat([hexToBinUnsafe(pathInHex), hexToBinUnsafe(parentContractId)])
+  const data = Buffer.concat([hexToBinUnsafe(parentContractId), hexToBinUnsafe(pathInHex)])
 
   return binToHex(blake.blake2b(blake.blake2b(data, undefined, 32), undefined, 32))
 }
@@ -203,11 +203,11 @@ export function stringToHex(str: string): string {
   return hex
 }
 
-export function hexToString(str: any): string {
-  return Buffer.from(str.toString(), 'hex').toString()
+export function hexToString(str: string): string {
+  return Buffer.from(str, 'hex').toString()
 }
 
-export function timeout(ms: number) {
+export function timeout(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 

package/templates/base/package.json

@@ -3,7 +3,7 @@
   "version": "0.1.0",
   "license": "GPL",
   "config": {
-    "alephium_version": "1.5.0-rc0"
+    "alephium_version": "1.5.0-rc4"
   },
   "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.0"
+    "@alephium/web3": "0.2.0-rc.3"
   },
   "devDependencies": {
     "@types/elliptic": "^6.4.13",

package/templates/react/package.json

@@ -2,7 +2,7 @@
   "name": "my-dapp",
   "version": "0.1.0",
   "config": {
-    "alephium_version": "1.5.0-rc0"
+    "alephium_version": "1.5.0-rc4"
   },
   "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.0",
+    "@alephium/web3": "0.2.0-rc.3",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "react-scripts": "5.0.1",

package/test/contract.test.ts

@@ -175,4 +175,23 @@ describe('contract', function () {
     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/transaction.test.ts

@@ -56,7 +56,7 @@ describe('transactions', function () {
     await timeout(1500)
     expect(txStatus).toMatchObject({ type: 'TxNotFound' })
 
-    const subSubmitResult = await signer.submitTransaction(subDeployTx.unsignedTx, subDeployTx.txId)
+    await signer.submitTransaction(subDeployTx.unsignedTx, subDeployTx.txId)
     await timeout(1500)
     expect(txStatus).toMatchObject({ type: 'Confirmed' })