@layerzerolabs/layerzero-v2-ton 3.0.72 → 3.0.74

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @layerzerolabs/layerzero-v2-ton
 
+## 3.0.74
+
+### Patch Changes
+
+- cca7389: refactor ton unit tests
+
+## 3.0.73
+
+### Patch Changes
+
+- 41cec93: Publish new package for TON sdk
+
 ## 3.0.72
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/layerzero-v2-ton",
-  "version": "3.0.72",
+  "version": "3.0.74",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -37,6 +37,7 @@
     "tests/testMain.fc",
     "tests/baseContractTest.fc",
     "tests/baseSerdeTest.fc",
+    "tests/utils/**/*.ts",
     "src/multisig/bocs/MultiSig.compiled.json",
     "src/multisig/bocs/MultiSigOrder.compiled.json"
   ],

package/tests/utils/UnitTestHelpers.ts

@@ -0,0 +1,121 @@
+import { Cell, toNano } from '@ton/core'
+import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox'
+
+import { UnitTestWrapper } from './UnitTestWrapper'
+import { GlobalTestResults } from './types/GlobalTestResults'
+
+import '@ton/test-utils'
+
+export const throwIfFailedTest = (testName: string, testCases: { [key: string]: boolean }): string => {
+    const passedTests = Object.keys(testCases).filter((test) => testCases[test])
+    const failedTests = Object.keys(testCases).filter((test) => !testCases[test])
+
+    let printStr = testName + '\n'
+    if (passedTests.length > 0) {
+        printStr += `\x1b[32m ✓ ${passedTests.length} tests passed.\n`
+    }
+
+    if (failedTests.length > 0) {
+        printStr += `\x1b[31m ❌ ${failedTests.length} tests failed:\n`
+        failedTests.forEach((test) => {
+            printStr += `  - ${test}\n`
+        })
+        throw new Error(printStr)
+    }
+    return printStr
+}
+
+export const getTestSummary = (testName: string, testCases: { [key: string]: boolean }): string => {
+    const passedTests = Object.keys(testCases).filter((test) => testCases[test])
+    const failedTests = Object.keys(testCases).filter((test) => !testCases[test])
+
+    let printStr = testName + '\n'
+    if (passedTests.length > 0) {
+        printStr += `\x1b[32m ✓ ${passedTests.length} tests passed.\n`
+    }
+
+    if (failedTests.length > 0) {
+        printStr += `\x1b[31m ❌ ${failedTests.length} tests failed:\n`
+        failedTests.forEach((test) => {
+            printStr += `  - ${test}\n`
+        })
+    }
+    return printStr
+}
+
+export const runUnitTests = (testName: string, code: Cell, globalTestResults: GlobalTestResults): GlobalTestResults => {
+    describe(testName, () => {
+        let blockchain: Blockchain
+        let testCase: SandboxContract<UnitTestWrapper>
+        let deployer: SandboxContract<TreasuryContract>
+
+        beforeEach(async () => {
+            blockchain = await Blockchain.create()
+
+            testCase = blockchain.openContract(UnitTestWrapper.createFromConfig({}, code))
+
+            deployer = await blockchain.treasury('deployer')
+
+            const deployResult = await testCase.sendDeploy(deployer.getSender(), toNano('1'))
+
+            expect(deployResult.transactions).toHaveTransaction({
+                from: deployer.address,
+                to: testCase.address,
+                deploy: true,
+                success: true,
+            })
+        })
+
+        it(testName, async () => {
+            let done = false
+            const test_results: { [key: string]: boolean } = {}
+            for (let testNum = 0n; !done; testNum++) {
+                // the check is done inside beforeEach
+                // blockchain and testCase are ready to use
+                const result = await testCase.sendTest(deployer.getSender(), toNano('10000'), testNum)
+                // search the json stringified result for the string "unhandled out-of-gas exception"
+                const txns = result.transactions
+
+                let unhandledException = false
+                // starting from -1 because the first one is the external message from wallet to contract
+                txns.forEach((item) => {
+                    if (item.vmLogs.toString().includes('unhandled out-of-gas exception')) {
+                        console.log(`Test number ${testNum} OUT OF GAS`)
+                    }
+                    if (item.vmLogs.toString().includes('default exception handler')) {
+                        console.error(`Unhandled exception in ${testName} test ${testNum}`)
+                        unhandledException = true
+                    }
+                })
+
+                done = result.externals.some((item) => {
+                    const event_topic = item.info.dest?.value
+                    if (event_topic == 1n) {
+                        return true
+                    }
+                    return false
+                })
+                if (!done) {
+                    const contractTestName = await testCase.getTestName(deployer.getSender(), testNum)
+                    let success = true
+                    result.events.forEach((item) => {
+                        // TODO fix this
+                        // @ts-expect-error type mismatch
+                        if (item.bounced as boolean) {
+                            success = false
+                        }
+                    })
+                    if (contractTestName in test_results) {
+                        throw new Error(`Duplicate test name ${contractTestName}`)
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    test_results[contractTestName] = success && !unhandledException
+                    globalTestResults[testName] = test_results
+                    expect(success)
+                }
+            }
+        })
+    })
+
+    return globalTestResults
+}

package/tests/utils/UnitTestWrapper.ts

@@ -0,0 +1,52 @@
+import { Address, Cell, Contract, ContractProvider, SendMode, Sender, beginCell, contractAddress } from '@ton/core'
+
+export interface UnitTestConfig {}
+
+export function testCaseConfigToCell(config: UnitTestConfig): Cell {
+    return beginCell().endCell()
+}
+
+export class UnitTestWrapper implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: { code: Cell; data: Cell }
+    ) {}
+
+    static createFromAddress(address: Address): UnitTestWrapper {
+        return new UnitTestWrapper(address)
+    }
+
+    static createFromConfig(config: UnitTestConfig, code: Cell, workchain = 0): UnitTestWrapper {
+        const data = testCaseConfigToCell(config)
+        const init = { code, data }
+        return new UnitTestWrapper(contractAddress(workchain, init), init)
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void> {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        })
+    }
+
+    async sendTest(provider: ContractProvider, via: Sender, value: bigint, testNum = 0n): Promise<void> {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            // opcode, query_id, failed_count, success_count
+            body: beginCell()
+                .storeUint(testNum, 32)
+                .storeUint(1, 64) // query_id
+                .storeUint(BigInt('0x' + via.address!.hash.toString('hex')), 256)
+                .storeCoins(0)
+                .storeRef(beginCell().endCell())
+                .endCell(),
+        })
+    }
+
+    async getTestName(provider: ContractProvider, via: Sender, testNum = 0n): Promise<string> {
+        const { stack } = await provider.get('get_test_name', [{ type: 'int', value: testNum }])
+        return stack.readString()
+    }
+}

package/tests/utils/types/GlobalTestResults.ts

@@ -0,0 +1,3 @@
+export interface GlobalTestResults {
+    [key: string]: { [key: string]: boolean }
+}