@alephium/web3 0.1.0-rc.3-hc → 0.2.0-rc.1

package/src/api/api-explorer.ts

@@ -847,6 +847,36 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         path: `/utils/sanity-check`,
         method: 'PUT',
         ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Update global log level, accepted: TRACE, DEBUG, INFO, WARN, ERROR
+     *
+     * @tags Utils
+     * @name PutUtilsUpdateGlobalLoglevel
+     * @request PUT:/utils/update-global-loglevel
+     */
+    putUtilsUpdateGlobalLoglevel: (data: 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', params: RequestParams = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/utils/update-global-loglevel`,
+        method: 'PUT',
+        body: data,
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Update logging file, only logback.xml is accepted
+     *
+     * @tags Utils
+     * @name PutUtilsUpdateLogConfig
+     * @request PUT:/utils/update-log-config
+     */
+    putUtilsUpdateLogConfig: (data: string, params: RequestParams = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/utils/update-log-config`,
+        method: 'PUT',
+        body: data,
+        ...params
       }).then(convertHttpResponse)
   }
 }

package/src/contract/contract.ts

@@ -27,12 +27,31 @@ import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodePr
 import * as ralph from './ralph'
 import { bs58, binToHex, contractIdFromAddress, assertType, Eq } from '../utils'
 
+class SourceFile {
+  readonly dirs: string[]
+  readonly dirPath: string
+  readonly contractPath: string
+  readonly artifactPath: string
+
+  constructor(dirs: string[], fileName: string) {
+    this.dirs = dirs
+    this.dirPath = dirs.length === 0 ? '' : dirs.join('/') + '/'
+    if (fileName.endsWith('.json')) {
+      this.contractPath = './contracts/' + this.dirPath + fileName.slice(0, -5)
+      this.artifactPath = './artifacts/' + this.dirPath + fileName
+    } else {
+      this.contractPath = './contracts/' + this.dirPath + fileName
+      this.artifactPath = './artifacts/' + this.dirPath + fileName + '.json'
+    }
+  }
+}
+
 export abstract class Common {
   readonly sourceCodeSha256: string
   readonly functions: node.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 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')
   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')
 
@@ -56,38 +75,53 @@ export abstract class Common {
     this.functions = functions
   }
 
-  protected static _contractPath(fileName: string): string {
-    if (fileName.endsWith('.json')) {
-      return `./contracts/${fileName.slice(0, -5)}`
-    } else {
-      return `./contracts/${fileName}`
-    }
+  protected static _artifactsFolder(): string {
+    return './artifacts/'
   }
 
-  protected static _artifactPath(fileName: string): string {
-    if (fileName.endsWith('.json')) {
-      return `./artifacts/${fileName}`
-    } else {
-      return `./artifacts/${fileName}.json`
+  static getSourceFile(path: string, _dirs: string[]): SourceFile {
+    const parts = path.split('/')
+    const dirs = Array.from(_dirs)
+    if (parts.length === 1) {
+      return new SourceFile(dirs, path)
     }
+    parts.slice(0, parts.length - 1).forEach((part) => {
+      switch (part) {
+        case '.': {
+          break
+        }
+        case '..': {
+          if (dirs.length === 0) {
+            throw new Error('Invalid file path: ' + path)
+          }
+          dirs.pop()
+          break
+        }
+        default: {
+          dirs.push(part)
+        }
+      }
+    })
+    return new SourceFile(dirs, parts[parts.length - 1])
   }
 
-  protected static _artifactsFolder(): string {
-    return './artifacts/'
-  }
-
-  protected static async _handleImports(contractStr: string, importsCache: string[]): Promise<string> {
+  protected static async _handleImports(
+    pathes: string[],
+    contractStr: string,
+    importsCache: string[]
+  ): Promise<string> {
     const localImportsCache: string[] = []
     let result = contractStr.replace(Common.importRegex, (match) => {
       localImportsCache.push(match)
       return ''
     })
     for (const myImport of localImportsCache) {
-      const fileName = myImport.slice(8, -1)
-      if (!importsCache.includes(fileName)) {
-        importsCache.push(fileName)
-        const importContractStr = await Common._loadContractStr(fileName, importsCache, (code) =>
-          Contract.checkCodeType(fileName, code)
+      const relativePath = myImport.slice(8, -1)
+      const importSourceFile = this.getSourceFile(relativePath, pathes)
+      if (!importsCache.includes(importSourceFile.contractPath)) {
+        importsCache.push(importSourceFile.contractPath)
+        const importContractStr = await Common._loadContractStr(importSourceFile, importsCache, (code) =>
+          Contract.checkCodeType(importSourceFile.contractPath, code)
         )
         result = result.concat('\n', importContractStr)
       }
@@ -96,16 +130,16 @@ export abstract class Common {
   }
 
   protected static async _loadContractStr(
-    fileName: string,
+    sourceFile: SourceFile,
     importsCache: string[],
-    validate: (fileName: string) => void
+    validate: (code: string) => void
   ): Promise<string> {
-    const contractPath = this._contractPath(fileName)
+    const contractPath = sourceFile.contractPath
     const contractBuffer = await fsPromises.readFile(contractPath)
     const contractStr = contractBuffer.toString()
 
     validate(contractStr)
-    return Common._handleImports(contractStr, importsCache)
+    return Common._handleImports(sourceFile.dirs, contractStr, importsCache)
   }
 
   static checkFileNameExtension(fileName: string): void {
@@ -116,25 +150,28 @@ export abstract class Common {
 
   protected static async _from<T extends { sourceCodeSha256: string }>(
     provider: NodeProvider,
-    fileName: string,
-    loadContractStr: (fileName: string, importsCache: string[]) => Promise<string>,
-    compile: (provider: NodeProvider, fileName: string, contractStr: string, contractHash: string) => Promise<T>
+    sourceFile: SourceFile,
+    loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>,
+    compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string) => Promise<T>
   ): Promise<T> {
-    Common.checkFileNameExtension(fileName)
+    Common.checkFileNameExtension(sourceFile.contractPath)
 
-    const contractStr = await loadContractStr(fileName, [])
+    const contractStr = await loadContractStr(sourceFile, [])
     const contractHash = cryptojs.SHA256(contractStr).toString()
     const existingContract = this._getArtifactFromCache(contractHash)
     if (typeof existingContract !== 'undefined') {
       return existingContract as unknown as T
     } else {
-      return compile(provider, fileName, contractStr, contractHash)
+      return compile(provider, sourceFile, contractStr, contractHash)
     }
   }
 
-  protected _saveToFile(fileName: string): Promise<void> {
-    const artifactPath = Common._artifactPath(fileName)
-    return fsPromises.writeFile(artifactPath, this.toString())
+  protected _saveToFile(sourceFile: SourceFile): Promise<void> {
+    const folder = Common._artifactsFolder() + sourceFile.dirPath
+    if (!fs.existsSync(folder)) {
+      fs.mkdirSync(folder, { recursive: true })
+    }
+    return fsPromises.writeFile(sourceFile.artifactPath, this.toString())
   }
 
   abstract buildByteCodeToDeploy(initialFields?: Fields): string
@@ -163,32 +200,38 @@ export class Contract extends Common {
 
   static checkCodeType(fileName: string, contractStr: string): void {
     const interfaceMatches = contractStr.match(Contract.interfaceRegex)
-    if (interfaceMatches) {
-      return
-    }
-
     const contractMatches = contractStr.match(Contract.contractRegex)
-    if (contractMatches === null) {
+    if (interfaceMatches === null && contractMatches === null) {
       throw new Error(`No contract found in: ${fileName}`)
-    } else if (contractMatches.length > 1) {
-      throw new Error(`Multiple contracts in: ${fileName}`)
-    } else {
-      return
+    }
+    if (interfaceMatches && contractMatches) {
+      throw new Error(`Multiple contracts and interfaces in: ${fileName}`)
+    }
+    if (interfaceMatches === null) {
+      if (contractMatches !== null && contractMatches.length > 1) {
+        throw new Error(`Multiple contracts in: ${fileName}`)
+      }
+    }
+    if (contractMatches === null) {
+      if (interfaceMatches !== null && interfaceMatches.length > 1) {
+        throw new Error(`Multiple interfaces in: ${fileName}`)
+      }
     }
   }
 
-  private static async loadContractStr(fileName: string, importsCache: string[]): Promise<string> {
-    return Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code))
+  private static async loadContractStr(sourceFile: SourceFile): Promise<string> {
+    return Common._loadContractStr(sourceFile, [], (code) => Contract.checkCodeType(sourceFile.contractPath, code))
   }
 
-  static async fromSource(provider: NodeProvider, fileName: string): Promise<Contract> {
+  static async fromSource(provider: NodeProvider, path: string): Promise<Contract> {
     if (!fs.existsSync(Common._artifactsFolder())) {
       fs.mkdirSync(Common._artifactsFolder(), { recursive: true })
     }
+    const sourceFile = this.getSourceFile(path, [])
     const contract = await Common._from(
       provider,
-      fileName,
-      (fileName, importCaches) => Contract.loadContractStr(fileName, importCaches),
+      sourceFile,
+      (sourceFile) => Contract.loadContractStr(sourceFile),
       Contract.compile
     )
     this._putArtifactToCache(contract)
@@ -197,7 +240,7 @@ export class Contract extends Common {
 
   private static async compile(
     provider: NodeProvider,
-    fileName: string,
+    sourceFile: SourceFile,
     contractStr: string,
     contractHash: string
   ): Promise<Contract> {
@@ -210,7 +253,7 @@ export class Contract extends Common {
       compiled.events,
       compiled.functions
     )
-    await artifact._saveToFile(fileName)
+    await artifact._saveToFile(sourceFile)
     return artifact
   }
 
@@ -239,13 +282,19 @@ export class Contract extends Common {
   }
 
   // support both 'code.ral' and 'code.ral.json'
-  static async fromArtifactFile(fileName: string): Promise<Contract> {
-    const artifactPath = Contract._artifactPath(fileName)
+  static async fromArtifactFile(path: string): Promise<Contract> {
+    const sourceFile = this.getSourceFile(path, [])
+    const artifactPath = sourceFile.artifactPath
     const content = await fsPromises.readFile(artifactPath)
     const artifact = JSON.parse(content.toString())
     return Contract.fromJson(artifact)
   }
 
+  async fetchState(provider: NodeProvider, address: string, group: number): Promise<ContractState> {
+    const state = await provider.contracts.getContractsAddressState(address, { group: group })
+    return this.fromApiContractState(state)
+  }
+
   override toString(): string {
     return JSON.stringify(
       {
@@ -518,28 +567,24 @@ export class Script extends Common {
     }
   }
 
-  private static async loadContractStr(fileName: string, importsCache: string[]): Promise<string> {
-    return Common._loadContractStr(fileName, importsCache, (code) => Script.checkCodeType(fileName, code))
+  private static async loadContractStr(sourceFile: SourceFile): Promise<string> {
+    return Common._loadContractStr(sourceFile, [], (code) => Script.checkCodeType(sourceFile.contractPath, code))
   }
 
-  static async fromSource(provider: NodeProvider, fileName: string): Promise<Script> {
-    return Common._from(
-      provider,
-      fileName,
-      (fileName, importsCache) => Script.loadContractStr(fileName, importsCache),
-      Script.compile
-    )
+  static async fromSource(provider: NodeProvider, path: string): Promise<Script> {
+    const sourceFile = this.getSourceFile(path, [])
+    return Common._from(provider, sourceFile, (sourceFile) => Script.loadContractStr(sourceFile), Script.compile)
   }
 
   private static async compile(
     provider: NodeProvider,
-    fileName: string,
+    sourceFile: SourceFile,
     scriptStr: string,
     contractHash: string
   ): Promise<Script> {
     const compiled = await provider.contracts.postContractsCompileScript({ code: scriptStr })
     const artifact = new Script(contractHash, compiled.bytecodeTemplate, compiled.fields, compiled.functions)
-    await artifact._saveToFile(fileName)
+    await artifact._saveToFile(sourceFile)
     return artifact
   }
 
@@ -556,8 +601,9 @@ export class Script extends Common {
     return new Script(artifact.sourceCodeSha256, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions)
   }
 
-  static async fromArtifactFile(fileName: string): Promise<Script> {
-    const artifactPath = Common._artifactPath(fileName)
+  static async fromArtifactFile(path: string): Promise<Script> {
+    const sourceFile = this.getSourceFile(path, [])
+    const artifactPath = sourceFile.artifactPath
     const content = await fsPromises.readFile(artifactPath)
     const artifact = JSON.parse(content.toString())
     return this.fromJson(artifact)

package/src/signer/signer.ts

@@ -42,7 +42,7 @@ export interface Account {
 
 export type SubmitTx = { submitTx?: boolean }
 export type SignerAddress = { signerAddress: string }
-type TxBuildParams<T> = Omit<T, 'fromPublicKey'> & SignerAddress & SubmitTx
+type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'targetBlockHash'> & SignerAddress & SubmitTx
 
 export type GetAccountsParams = undefined
 export type GetAccountsResult = Account[]

package/src/utils/utils.test.ts

@@ -151,10 +151,11 @@ describe('utils', function () {
         '0a38bc48fbb4300f1e305b201cd6129372d867122efb814d871d18c0bfe43b56',
         '4f51cd1f0af97cf5ec9c7a3397eaeea549d55a93c216e54f2ab4a8cf29f6f865'
       )
-    ).toBe('293c948c81c5a9495178fff8b8c9f29f4f3e09e1728c40e9253c87adf5e18770')
+    ).toBe('0e28f15ca290002c31d691aa008aa56ac12356b0380efb6c88fff929b6a268a9')
   })
 
-  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

@@ -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,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/templates/base/package.json

@@ -3,7 +3,7 @@
   "version": "0.1.0",
   "license": "GPL",
   "config": {
-    "alephium_version": "1.4.0-rc2"
+    "alephium_version": "1.5.0-rc0"
   },
   "scripts": {
     "build": "rm -rf dist && npx tsc --build .",
@@ -12,7 +12,7 @@
     "stop-devnet": "node scripts/stop-devnet.js"
   },
   "dependencies": {
-    "@alephium/web3": "0.1.0-rc.3"
+    "@alephium/web3": "0.2.0-rc.1"
   },
   "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.4.0-rc2"
+    "alephium_version": "1.5.0-rc0"
   },
   "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.1.0-rc.3",
+    "@alephium/web3": "0.2.0-rc.1",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "react-scripts": "5.0.1",

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

@@ -22,11 +22,11 @@ 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 } from '../src/utils'
+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: []
@@ -35,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: []
@@ -78,7 +78,7 @@ describe('events', function () {
       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) => {
@@ -117,7 +117,7 @@ describe('events', function () {
       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)
@@ -132,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

@@ -21,12 +21,12 @@ 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 } from '../src/utils'
+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 sub = await Contract.fromSource(provider, 'sub/sub.ral')
     const signer = await testWallet(provider)
     const subDeployTx = await sub.transactionForDeployment(signer, {
       initialFields: { result: 0 },
@@ -53,11 +53,11 @@ describe('transactions', function () {
     const counterBeforeSubscribe = counter
 
     const subscription = subscribeToTxStatus(subscriptOptions, subDeployTx.txId)
-    await new Promise((resolve) => setTimeout(resolve, 1500))
+    await timeout(1500)
     expect(txStatus).toMatchObject({ type: 'TxNotFound' })
 
     const subSubmitResult = await signer.submitTransaction(subDeployTx.unsignedTx, subDeployTx.txId)
-    await new Promise((resolve) => setTimeout(resolve, 1500))
+    await timeout(1500)
     expect(txStatus).toMatchObject({ type: 'Confirmed' })
 
     expect(counterBeforeSubscribe).toBeLessThan(counter)
@@ -65,8 +65,8 @@ describe('transactions', function () {
     subscription.unsubscribe()
 
     const counterAfterUnsubscribe = counter
-    await new Promise((resolve) => setTimeout(resolve, 1500))
+    await timeout(1500)
     expect(txStatus).toMatchObject({ type: 'Confirmed' })
     expect(counterAfterUnsubscribe).toEqual(counter)
-  })
+  }, 10000)
 })