[NONEVM-3135] Contract tests - Unit test Deployable (#411)

patricios-space · web-flow · commit 08209efcf3f3 · 2025-12-09T09:39:58.000-03:00
* test: deployable opcodes and init

* test: init and send

* test: authorization

* fix: typo

* fix: duplicated test

* fix: rm unnecesary await

* fix: typo

* fix: marc fn async

* fix: deployable coverage
diff --git a/contracts/contracts/deployable/types.tolk b/contracts/contracts/deployable/types.tolk
@@ -21,7 +21,7 @@ struct (0xba466447) Deployable_Initialize {
     stateInit: ContractState;
 }
 // This message initializes the Deployable contract and immediately sends a message to itself to execute some logic. It allows to carry the message value.
-struct (0xe95e1156) Deployable_InitializeAndSend {
+struct (0xb0ec5157) Deployable_InitializeAndSend {
     stateInit: ContractState;
     selfMessage: Deployable_Message;
 }
diff --git a/contracts/tests/coverage/coverage.ts b/contracts/tests/coverage/coverage.ts
@@ -11,6 +11,7 @@ export const CoverageContractName = {
   merkleroot: 'merkleroot',
   send_executor: 'send_executor',
   receive_executor: 'receive_executor',
+  deployable: 'deployable',
 } as const
 export type CoverageConfigNames = keyof typeof CoverageContractName
 
diff --git a/contracts/tests/coverage/scriptMergeCoverageIntoHtmlReports.ts b/contracts/tests/coverage/scriptMergeCoverageIntoHtmlReports.ts
@@ -1,7 +1,7 @@
 import { Coverage } from '@ton/sandbox'
 import { readFileSync, readdirSync, writeFileSync } from 'fs'
 import { join } from 'path'
-import * as coverage from './Coverage'
+import * as coverage from './coverage'
 
 const offRampSuffix = `${coverage.CoverageContractName.offramp}.json`
 const routerSuffix = `${coverage.CoverageContractName.router}.json`
@@ -10,6 +10,7 @@ const merkleRootSuffix = `${coverage.CoverageContractName.merkleroot}.json`
 const onRampSuffix = `${coverage.CoverageContractName.onramp}.json`
 const sendExecutorSuffix = `${coverage.CoverageContractName.send_executor}.json`
 const receiveExecutorSuffix = `${coverage.CoverageContractName.receive_executor}.json`
+const deployableSuffix = `${coverage.CoverageContractName.deployable}.json`
 
 const offRampCoverageResults: Coverage[] = []
 const routerCoverageResults: Coverage[] = []
@@ -18,6 +19,7 @@ const merkleRootCoverageResults: Coverage[] = []
 const onrampCoverageResults: Coverage[] = []
 const sendExecutorCoverageResults: Coverage[] = []
 const receiveExecutorCoverageResults: Coverage[] = []
+const deployableCoverageResults: Coverage[] = []
 
 const coverageDir = './.coverage'
 
@@ -48,6 +50,9 @@ for (const file of files) {
   } else if (file.endsWith(receiveExecutorSuffix)) {
     const coverage = Coverage.fromJson(readFileSync(filePath, 'utf-8'))
     receiveExecutorCoverageResults.push(coverage)
+  } else if (file.endsWith(deployableSuffix)) {
+    const coverage = Coverage.fromJson(readFileSync(filePath, 'utf-8'))
+    deployableCoverageResults.push(coverage)
   }
 }
 
@@ -64,6 +69,7 @@ const merkleRootMerged = mergeResults(merkleRootCoverageResults)
 const onRampMerged = mergeResults(onrampCoverageResults)
 const sendExecutorMerged = mergeResults(sendExecutorCoverageResults)
 const receiveExecutorMerged = mergeResults(receiveExecutorCoverageResults)
+const deployableMerged = mergeResults(deployableCoverageResults)
 
 // Generate HTML reports
 if (offRampMerged) {
@@ -121,3 +127,11 @@ if (receiveExecutorMerged) {
   )
   console.log('Generated receiveexecutor-coverage.html')
 }
+
+if (deployableMerged) {
+  writeFileSync(
+    `./.coverage/${coverage.CoverageContractName.deployable}.html`,
+    deployableMerged.report('html'),
+  )
+  console.log('Generated deployable-coverage.html')
+}
diff --git a/contracts/tests/lib/deployable/Deployable.spec.ts b/contracts/tests/lib/deployable/Deployable.spec.ts
@@ -0,0 +1,183 @@
+import { beginCell, Cell, toNano } from '@ton/core'
+import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox'
+import { crc32 } from 'zlib'
+
+import * as coverage from '../../coverage/coverage'
+import { generateRandomContractId } from '../../../src/utils'
+
+import * as counter from '../../../wrappers/examples/Counter'
+import * as dep from '../../../wrappers/libraries/Deployable'
+
+describe('Deployable - Opcodes', () => {
+  it('should match opcodes', () => {
+    expect(dep.Opcodes.initialize).toBe(crc32('Deployable_Initialize'))
+    expect(dep.Opcodes.initializeAndSend).toBe(crc32('Deployable_InitializeAndSend'))
+  })
+})
+
+describe('Deployable - Unit Tests', () => {
+  let blockchain: Blockchain
+  let deployer: SandboxContract<TreasuryContract>
+  let deployableCode: Cell
+  let counterCode: Cell
+  let deployable: SandboxContract<dep.ContractClient>
+
+  beforeAll(async () => {
+    deployableCode = await dep.ContractClient.code()
+    counterCode = await counter.ContractClient.code()
+
+    blockchain = await Blockchain.create()
+    blockchain.verbosity.debugLogs = true
+
+    if (process.env['COVERAGE'] === 'true') {
+      blockchain.enableCoverage()
+      blockchain.verbosity.print = false
+      blockchain.verbosity.vmLogs = 'vm_logs_verbose'
+    }
+  })
+
+  beforeEach(async () => {
+    deployer = await blockchain.treasury('deployer')
+
+    const data: dep.DeployableStorage = {
+      owner: deployer.address,
+      id: beginCell().storeStringTail('DeployableTests').storeUint(generateRandomContractId(), 32),
+    }
+
+    deployable = blockchain.openContract(dep.ContractClient.createFromConfig(data, deployableCode))
+  })
+
+  it('should initialize and replace code and data', async () => {
+    const data = counter.builder.data.contractData
+      .encode({
+        id: Number(generateRandomContractId()),
+        value: 0,
+        ownable: {
+          owner: deployer.address,
+          pendingOwner: undefined,
+        },
+      })
+      .asCell()
+    const result = await deployable.sendInitialize(deployer.getSender(), toNano('0.05'), {
+      stateInit: {
+        code: counterCode,
+        data,
+      },
+    })
+    expect(result.transactions).toHaveTransaction({
+      to: deployable.address,
+      deploy: true,
+      success: true,
+    })
+
+    const counterContract = blockchain.openContract(
+      counter.ContractClient.newAt(deployable.address),
+    )
+    expect(await counterContract.getValue()).toBe(0)
+
+    const resultIncrease = await counterContract.sendSetCount(
+      deployer.getSender(),
+      toNano('0.01'),
+      {
+        queryId: 1n,
+        newCount: 42,
+      },
+    )
+    expect(resultIncrease.transactions).toHaveTransaction({
+      to: counterContract.address,
+      success: true,
+    })
+    expect(await counterContract.getValue()).toBe(42)
+  })
+
+  it('should initialize and send a message to self', async () => {
+    const data = counter.builder.data.contractData
+      .encode({
+        id: Number(generateRandomContractId()),
+        value: 0,
+        ownable: {
+          owner: deployable.address,
+          pendingOwner: undefined,
+        },
+      })
+      .asCell()
+    const result = await deployable.sendInitializeAndSend(deployer.getSender(), toNano('0.05'), {
+      stateInit: {
+        code: await counter.ContractClient.code(),
+        data,
+      },
+      selfMessage: {
+        value: toNano('0.02'),
+        body: counter.builder.message.in.setCount
+          .encode({
+            queryId: 1n,
+            newCount: 42,
+          })
+          .asCell(),
+      },
+    })
+    expect(result.transactions).toHaveTransaction({
+      to: deployable.address,
+      deploy: true,
+      success: true,
+    })
+    expect(result.transactions).toHaveTransaction({
+      from: deployable.address,
+      to: deployable.address,
+      success: true,
+      op: counter.opcodes.in.SetCount,
+    })
+
+    const counterContract = blockchain.openContract(
+      counter.ContractClient.newAt(deployable.address),
+    )
+    expect(await counterContract.getValue()).toBe(42)
+  })
+
+  it('should not allow non-owner to initialize', async () => {
+    const other = await blockchain.treasury('other')
+
+    const result = await deployable.sendInitialize(other.getSender(), toNano('0.05'), {
+      stateInit: {
+        code: Cell.EMPTY,
+        data: Cell.EMPTY,
+      },
+    })
+    expect(result.transactions).toHaveTransaction({
+      to: deployable.address,
+      success: false,
+      exitCode: dep.Errors.ErrorNotOwner,
+    })
+  })
+
+  it('should not allow non-owner to initialize and send', async () => {
+    const other = await blockchain.treasury('other')
+
+    const result = await deployable.sendInitializeAndSend(other.getSender(), toNano('0.05'), {
+      stateInit: {
+        code: Cell.EMPTY,
+        data: Cell.EMPTY,
+      },
+      selfMessage: {
+        value: 0n,
+        body: Cell.EMPTY,
+      },
+    })
+    expect(result.transactions).toHaveTransaction({
+      to: deployable.address,
+      success: false,
+      exitCode: dep.Errors.ErrorNotOwner,
+    })
+  })
+
+  afterAll(async () => {
+    if (process.env['COVERAGE'] === 'true') {
+      await coverage.generateCoverageArtifacts(blockchain, 'deployable_unit_tests', [
+        {
+          code: deployableCode,
+          name: 'deployable',
+        },
+      ])
+    }
+  })
+})
diff --git a/contracts/wrappers/examples/Counter.ts b/contracts/wrappers/examples/Counter.ts
@@ -10,9 +10,11 @@ import {
   SendMode,
   Slice,
 } from '@ton/core'
-import * as typeAndVersion from '../libraries/versioning/TypeAndVersion'
-import * as ownable2step from '../libraries/access/Ownable2Step'
+import { compile } from '@ton/blueprint'
+
 import { CellCodec } from '../utils'
+import * as ownable2step from '../libraries/access/Ownable2Step'
+import * as typeAndVersion from '../libraries/versioning/TypeAndVersion'
 
 /// @dev Message to set the counter value.
 export type SetCount = {
@@ -164,6 +166,10 @@ export class ContractClient implements Contract, typeAndVersion.Interface {
     })
   }
 
+  static async code(): Promise<Cell> {
+    return await compile('examples.Counter')
+  }
+
   async getValue(provider: ContractProvider): Promise<number> {
     const result = await provider.get('value', [])
     return result.stack.readNumber()
diff --git a/contracts/wrappers/libraries/Deployable.ts b/contracts/wrappers/libraries/Deployable.ts
@@ -10,6 +10,8 @@ import {
   SendMode,
   Slice,
 } from '@ton/core'
+import { compile } from '@ton/blueprint'
+
 import { CellCodec } from '../utils'
 
 export type DeployableStorage = {
@@ -113,11 +115,11 @@ export const builder = {
 
 export abstract class Opcodes {
   static initialize = 0xba466447
-  static initializeAndSend = 0xe95e1156
+  static initializeAndSend = 0xb0ec5157
 }
 
 export enum Errors {
-  ErrorNotOwner = 0x1,
+  ErrorNotOwner = 37400,
 }
 
 export class ContractClient implements Contract {
@@ -136,6 +138,10 @@ export class ContractClient implements Contract {
     return new ContractClient(contractAddress(workchain, init), init)
   }
 
+  static async code(): Promise<Cell> {
+    return compile('Deployable')
+  }
+
   async sendInitialize(provider: ContractProvider, via: Sender, value: bigint, msg: Initialize) {
     await provider.internal(via, {
       value: value,

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ struct (0xba466447) Deployable_Initialize {`
`21`	`21`	`stateInit: ContractState;`
`22`	`22`	`}`
`23`	`23`	`// This message initializes the Deployable contract and immediately sends a message to itself to execute some logic. It allows to carry the message value.`
`24`		`-struct (0xe95e1156) Deployable_InitializeAndSend {`
	`24`	`+struct (0xb0ec5157) Deployable_InitializeAndSend {`
`25`	`25`	`stateInit: ContractState;`
`26`	`26`	`selfMessage: Deployable_Message;`
`27`	`27`	`}`