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

package/dist/src/api/api-alephium.d.ts

@@ -311,11 +311,13 @@ export interface CompileContractResult {
     fields: FieldsSig;
     functions: FunctionSig[];
     events: EventSig[];
+    warnings: string[];
 }
 export interface CompileScriptResult {
     bytecodeTemplate: string;
     fields: FieldsSig;
     functions: FunctionSig[];
+    warnings: string[];
 }
 export interface Confirmed {
     /** @format block-hash */
@@ -409,7 +411,6 @@ export interface Destination {
 export declare type DiscoveryAction = Reachable | Unreachable;
 export interface EventSig {
     name: string;
-    signature: string;
     fieldNames: string[];
     fieldTypes: string[];
 }
@@ -417,9 +418,9 @@ export interface FetchResponse {
     blocks: BlockEntry[][];
 }
 export interface FieldsSig {
-    signature: string;
     names: string[];
     types: string[];
+    isMutable: boolean[];
 }
 export interface FixedAssetOutput {
     /** @format int32 */
@@ -438,9 +439,12 @@ export interface FixedAssetOutput {
 }
 export interface FunctionSig {
     name: string;
-    signature: string;
-    argNames: string[];
-    argTypes: string[];
+    usePreapprovedAssets: boolean;
+    useAssetsInContract: boolean;
+    isPublic: boolean;
+    paramNames: string[];
+    paramTypes: string[];
+    paramIsMutable: boolean[];
     returnTypes: string[];
 }
 export interface Group {

package/dist/src/contract/contract.d.ts

@@ -8,9 +8,12 @@ declare class SourceFile {
     readonly artifactPath: string;
     constructor(dirs: string[], fileName: string);
 }
+declare type FieldsSig = node.FieldsSig;
+declare type EventSig = node.EventSig;
+declare type FunctionSig = node.FunctionSig;
 export declare abstract class Common {
     readonly sourceCodeSha256: string;
-    readonly functions: node.FunctionSig[];
+    readonly functions: FunctionSig[];
     static readonly importRegex: RegExp;
     static readonly contractRegex: RegExp;
     static readonly interfaceRegex: RegExp;
@@ -19,7 +22,7 @@ export declare abstract class Common {
     static artifactCacheCapacity: number;
     protected static _getArtifactFromCache(codeHash: string): Contract | Script | undefined;
     protected static _putArtifactToCache(contract: Contract): void;
-    constructor(sourceCodeSha256: string, functions: node.FunctionSig[]);
+    constructor(sourceCodeSha256: string, functions: FunctionSig[]);
     protected static _artifactsFolder(): string;
     static getSourceFile(path: string, _dirs: string[]): SourceFile;
     protected static _handleImports(pathes: string[], contractStr: string, importsCache: string[]): Promise<string>;
@@ -27,19 +30,25 @@ export declare abstract class Common {
     static checkFileNameExtension(fileName: string): void;
     protected static _from<T extends {
         sourceCodeSha256: string;
-    }>(provider: NodeProvider, sourceFile: SourceFile, loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string) => Promise<T>): Promise<T>;
+    }>(provider: NodeProvider, sourceFile: SourceFile, loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string, errorOnWarnings: boolean) => Promise<T>, errorOnWarnings: boolean): Promise<T>;
     protected _saveToFile(sourceFile: SourceFile): Promise<void>;
     abstract buildByteCodeToDeploy(initialFields?: Fields): string;
+    publicFunctions(): string[];
+    usingPreapprovedAssetsFunctions(): string[];
+    usingAssetsInContractFunctions(): string[];
+    protected static checkCompilerWarnings(compiled: {
+        warnings: string[];
+    }, errorOnWarnings: boolean): void;
 }
 export declare class Contract extends Common {
     readonly bytecode: string;
     readonly codeHash: string;
-    readonly fieldsSig: node.FieldsSig;
-    readonly eventsSig: node.EventSig[];
-    constructor(sourceCodeSha256: string, bytecode: string, codeHash: string, fieldsSig: node.FieldsSig, eventsSig: node.EventSig[], functions: node.FunctionSig[]);
+    readonly fieldsSig: FieldsSig;
+    readonly eventsSig: EventSig[];
+    constructor(sourceCodeSha256: string, bytecode: string, codeHash: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[]);
     static checkCodeType(fileName: string, contractStr: string): void;
     private static loadContractStr;
-    static fromSource(provider: NodeProvider, path: string): Promise<Contract>;
+    static fromSource(provider: NodeProvider, path: string, errorOnWarnings?: boolean): Promise<Contract>;
     private static compile;
     static fromJson(artifact: any): Contract;
     static fromArtifactFile(path: string): Promise<Contract>;
@@ -56,10 +65,10 @@ export declare class Contract extends Common {
     toApiContractStates(states?: ContractState[]): node.ContractState[] | undefined;
     toTestContract(funcName: string, params: TestContractParams): node.TestContract;
     static fromCodeHash(codeHash: string): Promise<Contract>;
-    static getFieldsSig(state: node.ContractState): Promise<node.FieldsSig>;
+    static getFieldsSig(state: node.ContractState): Promise<FieldsSig>;
     fromApiContractState(state: node.ContractState): Promise<ContractState>;
-    static ContractCreatedEvent: node.EventSig;
-    static ContractDestroyedEvent: node.EventSig;
+    static ContractCreatedEvent: EventSig;
+    static ContractDestroyedEvent: EventSig;
     static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): Promise<ContractEventByTxId>;
     fromTestContractResult(methodIndex: number, result: node.TestContractResult): Promise<TestContractResult>;
     paramsForDeployment(params: BuildDeployContractTx): Promise<SignDeployContractTxParams>;
@@ -68,11 +77,11 @@ export declare class Contract extends Common {
 }
 export declare class Script extends Common {
     readonly bytecodeTemplate: string;
-    readonly fieldsSig: node.FieldsSig;
-    constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: node.FieldsSig, functions: node.FunctionSig[]);
+    readonly fieldsSig: FieldsSig;
+    constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]);
     static checkCodeType(fileName: string, contractStr: string): void;
     private static loadContractStr;
-    static fromSource(provider: NodeProvider, path: string): Promise<Script>;
+    static fromSource(provider: NodeProvider, path: string, errorOnWarnings?: boolean): Promise<Script>;
     private static compile;
     static fromJson(artifact: any): Script;
     static fromArtifactFile(path: string): Promise<Script>;
@@ -107,7 +116,7 @@ export interface ContractState {
     initialStateHash?: string;
     codeHash: string;
     fields: Fields;
-    fieldsSig: node.FieldsSig;
+    fieldsSig: FieldsSig;
     asset: Asset;
 }
 export interface TestContractParams {

package/dist/src/contract/contract.js

@@ -135,7 +135,7 @@ class Common {
             throw new Error('Smart contract file name should end with ".ral"');
         }
     }
-    static async _from(provider, sourceFile, loadContractStr, compile) {
+    static async _from(provider, sourceFile, loadContractStr, compile, errorOnWarnings) {
         Common.checkFileNameExtension(sourceFile.contractPath);
         const contractStr = await loadContractStr(sourceFile, []);
         const contractHash = cryptojs.SHA256(contractStr).toString();
@@ -144,7 +144,7 @@ class Common {
             return existingContract;
         }
         else {
-            return compile(provider, sourceFile, contractStr, contractHash);
+            return compile(provider, sourceFile, contractStr, contractHash, errorOnWarnings);
         }
     }
     _saveToFile(sourceFile) {
@@ -154,6 +154,28 @@ class Common {
         }
         return fs_2.promises.writeFile(sourceFile.artifactPath, this.toString());
     }
+    publicFunctions() {
+        return this.functions.filter((func) => func.isPublic).map((func) => func.name);
+    }
+    usingPreapprovedAssetsFunctions() {
+        return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name);
+    }
+    usingAssetsInContractFunctions() {
+        return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name);
+    }
+    static checkCompilerWarnings(compiled, errorOnWarnings) {
+        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);
+            }
+        }
+    }
 }
 exports.Common = Common;
 Common.importRegex = new RegExp('^import "([^"/]+/(([^"]+)/)?)?[a-z][a-z_0-9]*.ral"', 'mg');
@@ -193,17 +215,18 @@ class Contract extends Common {
     static async loadContractStr(sourceFile) {
         return Common._loadContractStr(sourceFile, [], (code) => Contract.checkCodeType(sourceFile.contractPath, code));
     }
-    static async fromSource(provider, path) {
+    static async fromSource(provider, path, errorOnWarnings = true) {
         if (!fs_1.default.existsSync(Common._artifactsFolder())) {
             fs_1.default.mkdirSync(Common._artifactsFolder(), { recursive: true });
         }
         const sourceFile = this.getSourceFile(path, []);
-        const contract = await Common._from(provider, sourceFile, (sourceFile) => Contract.loadContractStr(sourceFile), Contract.compile);
+        const contract = await Common._from(provider, sourceFile, (sourceFile) => Contract.loadContractStr(sourceFile), Contract.compile, errorOnWarnings);
         this._putArtifactToCache(contract);
         return contract;
     }
-    static async compile(provider, sourceFile, contractStr, contractHash) {
+    static async compile(provider, sourceFile, contractStr, contractHash, errorOnWarnings) {
         const compiled = await provider.contracts.postContractsCompileContract({ code: contractStr });
+        Common.checkCompilerWarnings(compiled, errorOnWarnings);
         const artifact = new Contract(contractHash, compiled.bytecode, compiled.codeHash, compiled.fields, compiled.events, compiled.functions);
         await artifact._saveToFile(sourceFile);
         return artifact;
@@ -265,7 +288,7 @@ class Contract extends Common {
         const apiParams = this.toTestContract(funcName, params);
         const apiResult = await provider.contracts.postContractsTestContract(apiParams);
         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;
@@ -424,13 +447,11 @@ class Contract extends Common {
 exports.Contract = Contract;
 Contract.ContractCreatedEvent = {
     name: 'ContractCreated',
-    signature: 'event ContractCreated(address:Address)',
     fieldNames: ['address'],
     fieldTypes: ['Address']
 };
 Contract.ContractDestroyedEvent = {
     name: 'ContractDestroyed',
-    signature: 'event ContractDestroyed(address:Address)',
     fieldNames: ['address'],
     fieldTypes: ['Address']
 };
@@ -455,12 +476,13 @@ class Script extends Common {
     static async loadContractStr(sourceFile) {
         return Common._loadContractStr(sourceFile, [], (code) => Script.checkCodeType(sourceFile.contractPath, code));
     }
-    static async fromSource(provider, path) {
+    static async fromSource(provider, path, errorOnWarnings = true) {
         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);
     }
-    static async compile(provider, sourceFile, scriptStr, contractHash) {
+    static async compile(provider, sourceFile, scriptStr, contractHash, errorOnWarnings = true) {
         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;
@@ -752,7 +774,7 @@ function toApiFields(fields, fieldsSig) {
     return toApiVals(fields, fieldsSig.names, fieldsSig.types);
 }
 function toApiArgs(args, funcSig) {
-    return toApiVals(args, funcSig.argNames, funcSig.argTypes);
+    return toApiVals(args, funcSig.paramNames, funcSig.paramTypes);
 }
 function toApiVals(fields, names, types) {
     return names.map((name, index) => {

package/dist/src/utils/utils.d.ts

@@ -20,8 +20,8 @@ export declare function addressFromContractId(contractId: string): string;
 export declare function contractIdFromTx(txId: string, outputIndex: number): string;
 export declare function subContractId(parentContractId: string, pathInHex: string): string;
 export declare function stringToHex(str: string): string;
-export declare function hexToString(str: any): string;
-export declare function timeout(ms: number): Promise<unknown>;
+export declare function hexToString(str: string): string;
+export declare function timeout(ms: number): Promise<void>;
 declare type _Eq<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export declare type Eq<X, Y> = _Eq<{
     [P in keyof X]: X[P];

package/dist/src/utils/utils.js

@@ -195,7 +195,7 @@ function stringToHex(str) {
 }
 exports.stringToHex = stringToHex;
 function hexToString(str) {
-    return buffer_1.Buffer.from(str.toString(), 'hex').toString();
+    return buffer_1.Buffer.from(str, 'hex').toString();
 }
 exports.hexToString = hexToString;
 function timeout(ms) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.2.0-rc.2",
+  "version": "0.2.0-rc.3",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,7 +27,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "1.5.0-rc2",
+    "alephium_version": "1.5.0-rc4",
     "explorer_backend_version": "1.7.1"
   },
   "scripts": {

package/src/api/api-alephium.ts

@@ -429,12 +429,14 @@ export interface CompileContractResult {
   fields: FieldsSig
   functions: FunctionSig[]
   events: EventSig[]
+  warnings: string[]
 }
 
 export interface CompileScriptResult {
   bytecodeTemplate: string
   fields: FieldsSig
   functions: FunctionSig[]
+  warnings: string[]
 }
 
 export interface Confirmed {
@@ -561,7 +563,6 @@ export type DiscoveryAction = Reachable | Unreachable
 
 export interface EventSig {
   name: string
-  signature: string
   fieldNames: string[]
   fieldTypes: string[]
 }
@@ -571,9 +572,9 @@ export interface FetchResponse {
 }
 
 export interface FieldsSig {
-  signature: string
   names: string[]
   types: string[]
+  isMutable: boolean[]
 }
 
 export interface FixedAssetOutput {
@@ -599,9 +600,12 @@ export interface FixedAssetOutput {
 
 export interface FunctionSig {
   name: string
-  signature: string
-  argNames: string[]
-  argTypes: string[]
+  usePreapprovedAssets: boolean
+  useAssetsInContract: boolean
+  isPublic: boolean
+  paramNames: string[]
+  paramTypes: string[]
+  paramIsMutable: boolean[]
   returnTypes: string[]
 }
 

package/src/contract/contract.ts

@@ -46,9 +46,13 @@ 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('^(Abstract[ ]+)?Contract [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.ts

@@ -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))
 }