@layerzerolabs/ton-sdk-tools 3.0.22-ton.1 → 3.0.24-ton.0

package/dist/index.cjs

@@ -1234,7 +1234,7 @@ var BaseWrapper = class {
 function generateCommonTestUtils(directory, filename) {
   const savedCode = `import fs from 'fs'
 
-import { Address, Builder, Cell, Dictionary, SendMode, TupleItemCell, TupleItemInt, beginCell, toNano } from '@ton/core'
+import { Address, Builder, Cell, Dictionary, SendMode, TupleItem, TupleItemCell, TupleItemInt, beginCell, toNano } from '@ton/core'
 import {
     Blockchain,
     BlockchainTransaction,
@@ -1277,7 +1277,6 @@ import {
     OPCODES,
     TonContractWrapper,
     TonObjectUnwrapper,
-    bigintToAsciiString,
     deconstructorMap,
     keyMap,
 } from '../../src'
@@ -1287,12 +1286,10 @@ export const ActionTypes: { [key: string]: bigint } = {
     aba: BigInt(2),
 }
 
-export interface PacketsInFlight {
+export interface PacketInFlight {
     fromEid: bigint
     toEid: bigint
     mdPacketSent: MdPacketSent
-    // nonce: bigint
-    // lzPacket: Cell
 }
 
 export interface SendOptions {
@@ -1313,7 +1310,6 @@ export const newTonObjectsContainer: { items: { [key: string]: unknown } } = {
 
 export const PUBLIC_KEY_BYTE_LENGTH = 64
 export const SIGNATURE_BYTE_LENGTH = 65
-export const PUBLIC_KEY_HASH_BITS = 256
 const SEED_SIZE = 32
 
 // ==============================PROTOCOL SETUP GAS==============================
@@ -1619,6 +1615,21 @@ export async function createLzPacketFromPacketEncodedOverrideNonce(
     ).cell
 }
 
+export async function createLzPacketFromPacketEncodedOverrideNonceAndGuid(
+    encodedPacket: Cell,
+    newNonce: bigint,
+    allStorages: SandboxContract<TonContractWrapper>
+): Promise<Cell> {
+    return (
+        (
+            await allStorages.getViewFunction('decodeAndOverrideNonceAndGuid<PacketV1>', [
+                { type: 'cell', cell: encodedPacket },
+                { type: 'int', value: newNonce },
+            ])
+        ).pop() as TupleItemCell
+    ).cell
+}
+
 export async function overrideNonceAndGuid(
     encodedPacket: Cell,
     newNonce: bigint,
@@ -1626,7 +1637,7 @@ export async function overrideNonceAndGuid(
 ): Promise<Cell> {
     return (
         (
-            await allStorages.getViewFunction('overrideNonceAndGuid<PacketV1>', [
+            await allStorages.getViewFunction('decodeAndOverrideNonceAndGuidSerialized<PacketV1>', [
                 { type: 'cell', cell: encodedPacket },
                 { type: 'int', value: newNonce },
             ])
@@ -1993,6 +2004,47 @@ export async function assertFirstUncommitedNonce(
     expect(firstUncommittedNonce.value).toEqual(expectedValue - BigInt(1)) // _viewInboundNonce subtracts 1 from actual value
 }
 
+export async function assertCommittableView(
+    ulnConnection: SandboxContract<TonContractWrapper>,
+    nonce: bigint,
+    packet: Cell,
+    defaultUlnReceiveConfig: Cell
+): Promise<bigint> {
+    return (
+        (
+            await ulnConnection.getViewFunction('committableView', [
+                { type: 'int', value: nonce },
+                { type: 'cell', cell: packet },
+                { type: 'cell', cell: defaultUlnReceiveConfig },
+            ])
+        ).pop() as TupleItemInt
+    ).value
+}
+
+export async function assertVerifiedView(
+    contract: ExtendedContract<TonContractWrapper>,
+    dvnAddress: bigint,
+    nonce: bigint,
+    packetHash: bigint,
+    requiredConfirmations: bigint
+): Promise<bigint> {
+    const args: TupleItem[] = [
+        { type: 'int', value: dvnAddress },
+        { type: 'int', value: nonce },
+        { type: 'int', value: packetHash },
+        { type: 'int', value: requiredConfirmations },
+    ]
+    return (await contract.getViewFunction('verifiedView', args)).readBigNumber()
+}
+
+export async function getExecutionStatus(
+    contract: ExtendedContract<TonContractWrapper>,
+    incomingNonce: bigint
+): Promise<bigint> {
+    const args: TupleItem[] = [{ type: 'int', value: incomingNonce }]
+    return (await contract.getViewFunction('_viewExecutionStatus', args)).readBigNumber()
+}
+
 export function addLibToBlockchain(blockchain: Blockchain, newLib: Cell): void {
     let libsDict: Dictionary<bigint, Cell>
     if (blockchain.libs) {
@@ -2655,15 +2707,13 @@ export async function assertZroBalance(
     expect(channelTS.zroBalance).toEqual(expectedValue)
 }
 
-export function syncClTypeof(obj: Cell): string {
-    if (obj.bits.length === 0) {
-        return 'NULL'
-    }
-    try {
-        return bigintToAsciiString(obj.beginParse().preloadUintBig(80))
-    } catch (e) {
-        return 'UNKNOWN'
+export function isValidAscii(input: string): boolean {
+    for (var i=0; i < input.length; i++) {
+        if (input.charCodeAt(i)>127) {
+            return false;
+        }
     }
+    return true;
 }
 
 export async function txDecoder(
@@ -2740,8 +2790,7 @@ export async function runtimeDecoder(contract: SandboxContract<TonContractWrappe
                     newCellFieldType = 'cl::t::cellRef'
                 } else {
                     // Check if newCellFieldType is valid ASCII
-                    // eslint-disable-next-line no-control-regex
-                    if (!/^[p{ASCII}]+$/u.test(newCellFieldType)) {
+                    if (!isValidAscii(newCellFieldType)) {
                         newCellFieldType = 'cl::t::cellRef'
                     } else {
                         newCellFieldType = keyMap[newCellFieldType] ?? newCellFieldType
@@ -3149,15 +3198,21 @@ import UlnManagerArtifact from '@layerzerolabs/layerzero-v2-ton/build/UlnManager
 import { Profile, addressToBigInt, cellFromArtifact } from '@layerzerolabs/ton-sdk-tools'
 
 import {
+    ActionTypes,
     OAppFixture,
     OAppFlowGas,
+    OutOfOrder,
+    PacketInFlight,
     ProtocolFixture,
     SIGNATURE_BYTE_LENGTH,
     addMsgLibToController,
+    assertCommittableView,
+    assertVerifiedView,
     createLzPacketFromPacketEncoded,
     createVerifierDictSet,
     emptyObject,
     generateRandomVerifierSet,
+    lzReceiveAndExpect,
     protocolSetupGas,
     publicKeyToHash,
     requireDefined,
@@ -3167,7 +3222,9 @@ import {
     setDefaultEndpointConfig,
     wireChannels,
 } from './auto-utils-common'
+import { ExpectedCounts, assertInboundCount, assertOutboundCount, incrementCounterAndExpectULN } from './utils'
 import {
+    ERRORS,
     ExtendedContract,
     LzDict,
     LzEventHandler,
@@ -3181,6 +3238,12 @@ const ULN_MANAGER_DEFAULT_VERSION = BigInt(1)
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const ULN_MANAGER_CUSTOM_VERSION = BigInt(2)
 
+export const TRUE = BigInt(-1)
+export const FALSE = BigInt(0)
+export const UlnConnectionVerificationStatusVerifying = BigInt(0)
+export const UlnConnectionVerificationStatusCommittable = BigInt(1)
+export const ChannelExecutionStatusExecutable = BigInt(2)
+
 export interface SendDvnConfig {
     numReqDvns: bigint
     numOptDvns: bigint
@@ -3227,6 +3290,8 @@ export interface ProtocolFixtureULN extends ProtocolFixture {
     receiveDvnFixturesCustom: DvnFixture[]
     executorFixtures: ExecutorFixture
     priceFeedCacheFixture: PricedfeedCacheFixture
+    defaultUlnSendConfig: Cell
+    defaultUlnReceiveConfig: Cell
 }
 
 // ===============================INTERFACES===============================
@@ -3257,6 +3322,211 @@ export function serializeDvns(dvnList: bigint[]): Cell {
     return linkedList.endCell()
 }
 
+// ================================Out of order helper functions================================
+
+export async function generateFromPacketsInFlight(
+    outOfOrder: OutOfOrder,
+    fixtures: Map<bigint, OAppFixtureULN>,
+    expectedCounts: Map<bigint, ExpectedCounts>,
+    packetsInFlight: Map<bigint, PacketInFlight[]>,
+    multiSigOwner1: SandboxContract<TreasuryContract>,
+    eventHandler: LzEventHandler
+): Promise<PacketInFlight[]> {
+    let fromPacketsInFlight: PacketInFlight[] | undefined = []
+
+    for (const action of outOfOrder.actions) {
+        const fromEidBigInt = BigInt(action.fromEid)
+        const fromFixture = fixtures.get(fromEidBigInt)
+        const fromExpectedCounts = expectedCounts.get(fromEidBigInt)
+        fromPacketsInFlight = packetsInFlight.get(fromEidBigInt)
+
+        if (!fromFixture || !fromExpectedCounts || !fromPacketsInFlight) {
+            throw new Error('Fixture, ExpectedCount, or PacketsInFlight not found')
+        }
+
+        const mdPacketSent = await incrementCounterAndExpectULN(
+            {
+                dstEid: action.toEid,
+                actionType: ActionTypes[action.actionType],
+                extraOptions: beginCell().endCell(),
+                nativeFee: toNano('0.000006240'),
+                zroFee: toNano('0'),
+            },
+            multiSigOwner1,
+            eventHandler,
+            fromFixture.msglibConnection,
+            fromFixture
+        )
+
+        await assertOutboundCount(fromFixture.oApp, action.toEid, ++fromExpectedCounts.outbound)
+
+        fromPacketsInFlight.push({
+            fromEid: action.fromEid,
+            toEid: action.toEid,
+            mdPacketSent,
+        })
+    }
+    return fromPacketsInFlight
+}
+
+export async function getRandomLzPacket(
+    allStorages: SandboxContract<TonContractWrapper>,
+    fromPacketsInFlight: PacketInFlight[],
+    fixtures: Map<bigint, OAppFixtureULN>,
+    expectedCounts: Map<bigint, ExpectedCounts>,
+    pooos: Map<bigint, number[]>
+): Promise<{
+    randomPacketIndex: number
+    randomPacketInFlight: PacketInFlight
+    toFixture: OAppFixtureULN
+    toExpectedCounts: ExpectedCounts
+    lzPacket: Cell
+    toPooo: number[]
+}> {
+    if (fromPacketsInFlight.length === 0) {
+        throw new Error('No packets in flight available')
+    }
+
+    const randomPacketIndex = Math.floor(Math.random() * fromPacketsInFlight.length)
+    const randomPacketInFlight = fromPacketsInFlight[randomPacketIndex]
+
+    const toEidBigInt = BigInt(randomPacketInFlight.toEid)
+    const toFixture = fixtures.get(toEidBigInt)
+    const toExpectedCounts = expectedCounts.get(toEidBigInt)
+    const toPooo = pooos.get(toEidBigInt)
+
+    if (!toFixture || !toExpectedCounts || !toPooo) {
+        throw new Error('Fixture, ExpectedCount, or POOO not found')
+    }
+
+    const lzPacket = await createLzPacketFromPacketEncoded(randomPacketInFlight.mdPacketSent.packetEncoded, allStorages)
+
+    return {
+        randomPacketIndex,
+        randomPacketInFlight,
+        toFixture,
+        toExpectedCounts,
+        lzPacket,
+        toPooo,
+    }
+}
+
+export async function handleVerify(
+    toFixture: OAppFixtureULN,
+    randomPacketInFlight: PacketInFlight,
+    lzPacket: Cell,
+    allStorages: SandboxContract<TonContractWrapper>,
+    eventHandler: LzEventHandler
+): Promise<void> {
+    let isVerified = true
+    for (const dvnFixture of toFixture.receiveDvnFixturesCustom) {
+        const isVerifiedView = await assertVerifiedView(
+            toFixture.msglibConnection,
+            addressToBigInt(dvnFixture.proxy.address),
+            randomPacketInFlight.mdPacketSent.nonce,
+            BigInt('0x' + lzPacket.hash().toString('hex')),
+            BigInt(1) // requiredConfirmations
+        )
+
+        if (isVerifiedView == FALSE) {
+            isVerified = false
+        }
+    }
+
+    if (!isVerified) {
+        await ulnVerifyAndExpect(
+            allStorages,
+            randomPacketInFlight.mdPacketSent,
+            toFixture,
+            toFixture.receiveDvnFixturesCustom,
+            toFixture.msglibManager,
+            toFixture.msglibConnection,
+            eventHandler
+        )
+    }
+}
+
+export async function handleCommit(
+    toFixture: OAppFixtureULN,
+    randomPacketInFlight: PacketInFlight,
+    lzPacketWithGuid: Cell,
+    multiSigOwner1: SandboxContract<TreasuryContract>,
+    eventHandler: LzEventHandler
+): Promise<void> {
+    const status = await assertCommittableView(
+        toFixture.msglibConnection,
+        randomPacketInFlight.mdPacketSent.nonce,
+        lzPacketWithGuid,
+        toFixture.defaultUlnReceiveConfig
+    )
+
+    if (status == UlnConnectionVerificationStatusCommittable) {
+        await commitVerificationAndExpect(lzPacketWithGuid, multiSigOwner1, eventHandler, toFixture)
+    }
+}
+
+export async function handleLzReceive(
+    isExecutable: boolean,
+    nonces: bigint[],
+    toFixture: OAppFixtureULN,
+    randomPacketInFlight: PacketInFlight,
+    multiSigOwner1: SandboxContract<TreasuryContract>,
+    allStorages: SandboxContract<TonContractWrapper>,
+    lzReceivePrepareValue: bigint,
+    eventHandler: LzEventHandler,
+    toExpectedCounts: ExpectedCounts,
+    randomPacketIndex: number | undefined,
+    fromPacketsInFlight: PacketInFlight[] | undefined,
+    totalPacketsDelivered?: number,
+    opcode = OPCODES.Channel_OP_LZ_RECEIVE_PREPARE,
+    profileGasFile = 'lz-receive-uln'
+): Promise<number | undefined> {
+    if (isExecutable) {
+        for (const nonce of nonces) {
+            await lzReceiveAndExpect({
+                lzReceivePrepareMd: await allStorages.getNewMdLzReceivePrepare({
+                    nonce,
+                    nanotons: lzReceivePrepareValue,
+                }),
+                oAppFixture: toFixture,
+                deployer: multiSigOwner1,
+                eventHandler,
+                profile: {
+                    profileGas: true,
+                    fileName: profileGasFile,
+                },
+            })
+            await assertInboundCount(toFixture.oApp, randomPacketInFlight.fromEid, ++toExpectedCounts.inbound)
+            if (totalPacketsDelivered !== undefined) totalPacketsDelivered++
+        }
+        if (fromPacketsInFlight && randomPacketIndex !== undefined) {
+            fromPacketsInFlight.splice(randomPacketIndex, 1)
+        }
+    } else {
+        await sendInternalMessageAndExpect({
+            value: toNano('1'),
+            sender: multiSigOwner1.getSender(),
+            contract: toFixture.channel,
+            opCode: opcode,
+            md: await allStorages.getNewMdLzReceivePrepare({
+                nonce: randomPacketInFlight.mdPacketSent.nonce,
+                nanotons: lzReceivePrepareValue,
+            }),
+            expectedTransactions: [
+                {
+                    from: multiSigOwner1.address,
+                    to: toFixture.channel.address,
+                    op: Number(opcode),
+                    exitCode: Number(ERRORS.Channel_ERROR_notExecutable),
+                    success: false,
+                },
+            ],
+        })
+        await assertInboundCount(toFixture.oApp, randomPacketInFlight.fromEid, toExpectedCounts.inbound)
+    }
+    return totalPacketsDelivered
+}
+
 // ==============================ULN INTEGRATION FUNCTIONS==============================
 
 export async function commitVerificationAndExpect(
@@ -4148,6 +4418,8 @@ export async function deployConfigAndRegisterUln(
         confirmationsNull: BigInt(0),
         confirmations: BigInt(1),
     })
+    
+    srcFixture.defaultUlnSendConfig = ulnSendConfig
 
     await sendMessageViaMultisigAndExpect({
         blockchain,
@@ -4198,6 +4470,8 @@ export async function deployConfigAndRegisterUln(
         optionalDVNThreshold: BigInt(optReceiveQuorum),
     })
 
+    srcFixture.defaultUlnReceiveConfig = ulnReceiveConfig
+    
     await sendMessageViaMultisigAndExpect({
         blockchain,
         multiSigContract: srcFixture.multisig,
@@ -4697,7 +4971,7 @@ export async function assertNewQuorum({ dvn, expectedQuorum }: AssertNewQuorumPa
 
 // ================================DVN ADMINS================================
 
-export async function assertNewAdmins({ dvn, newDict: expectedAdmins }: AssertNewDictParams): Promise<void> {
+export async function assertNewDvnAdmins({ dvn, newDict: expectedAdmins }: AssertNewDictParams): Promise<void> {
     // check that the admins are set correctly (checking the hash is enough)
     const dvnStorageCell = await dvn.getCurrentStorageCell()
     const dvnStorage = await TonObjectUnwrapper.getDvnToTS(dvn, dvnStorageCell)