@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

package/sdk/test/counter-uln.test.ts

@@ -0,0 +1,493 @@
+import { StrKey } from '@stellar/stellar-sdk';
+import path from 'path';
+import { beforeAll, describe, expect, inject, it } from 'vitest';
+
+import { getFullyQualifiedRepoRootPath } from '@layerzerolabs/common-node-utils';
+import { Options, PacketSerializer, PacketV1Codec } from '@layerzerolabs/lz-v2-utilities';
+
+import { Client as CounterClient } from '../src/generated/counter';
+import { Client as ExecutorHelperClient } from '../src/generated/executor_helper';
+import { Client as Uln302Client } from '../src/generated/uln302';
+import {
+    DEFAULT_DEPLOYER,
+    DVN_SIGNER,
+    DVN_VID,
+    EID,
+    EXECUTOR_ADMIN,
+    MSG_TYPE_COMPOSED_ABA,
+    MSG_TYPE_VANILLA,
+    NETWORK_PASSPHRASE,
+} from './suites/constants';
+import { deployContract } from './suites/deploy';
+import { PacketSentEvent, scanPacketSentEvents } from './suites/scan';
+import {
+    assertTransactionSucceeded,
+    createClient,
+    getNativeBalance,
+    signAndSendWithExecutorAuth,
+    signDvnAuthEntries,
+} from './utils';
+
+// Protocol addresses (will be injected from globalSetup in beforeAll)
+let protocolAddresses: ReturnType<typeof inject<'protocolAddresses'>>;
+
+// Counter-specific address
+let counterAddress = '';
+
+// Clients
+let uln302Client: Uln302Client;
+let counterClient: CounterClient;
+let executorHelperClient: ExecutorHelperClient;
+
+// NOTE: run `stellar contract build --features sandbox` before running the test
+
+describe('Counter with ULN302 testing', async () => {
+    const repoRoot = await getFullyQualifiedRepoRootPath();
+    const wasmDir = path.join(
+        repoRoot,
+        'contracts',
+        'protocol',
+        'stellar',
+        'target',
+        'wasm32v1-none',
+        'release',
+    );
+
+    const COUNTER_WASM_PATH = path.join(wasmDir, 'counter.wasm');
+
+    beforeAll(async () => {
+        // Inject protocol addresses from globalSetup
+        protocolAddresses = inject('protocolAddresses');
+
+        console.log('\n📋 Protocol addresses injected from globalSetup');
+        console.log('  Endpoint:', protocolAddresses.endpointV2);
+        console.log('  ULN302:', protocolAddresses.uln302);
+        console.log('  DVN:', protocolAddresses.dvn);
+        console.log('  Executor:', protocolAddresses.executor);
+        console.log('  Executor Helper:', protocolAddresses.executorHelper);
+
+        // Create clients for protocol contracts
+        uln302Client = createClient(Uln302Client, protocolAddresses.uln302);
+        executorHelperClient = createClient(ExecutorHelperClient, protocolAddresses.executorHelper);
+    });
+
+    describe('Deploy Counter', () => {
+        it('Deploy Counter', async () => {
+            counterClient = await deployContract<CounterClient>(
+                CounterClient,
+                COUNTER_WASM_PATH,
+                {
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    endpoint: protocolAddresses.endpointV2,
+                    delegate: DEFAULT_DEPLOYER.publicKey(),
+                },
+                DEFAULT_DEPLOYER,
+            );
+
+            counterAddress = counterClient.options.contractId;
+            console.log('✅ Counter deployed:', counterAddress);
+        });
+
+        it('Set Counter Peer', async () => {
+            const peerBytes = StrKey.decodeContract(counterAddress);
+
+            const assembledTx = await counterClient.set_peer({
+                eid: EID,
+                peer: Buffer.from(peerBytes),
+            });
+            await assembledTx.signAndSend();
+
+            const { result: peer } = await counterClient.peer({
+                eid: EID,
+            });
+            expect(peer?.toString()).toBe(Buffer.from(peerBytes).toString());
+            console.log('✅ Counter peer set for EID', EID);
+        });
+    });
+
+    describe('Counter Increment with Composed ABA and Native Drop', async () => {
+        let incrementLedger = 0;
+        let packetSentEvent: PacketSentEvent;
+        let guid: Buffer;
+        let message: Buffer;
+        let packetHeader: Buffer;
+        let payloadHash: Buffer;
+        let composeValue: bigint;
+
+        // Native drop receiver - use DEFAULT_DEPLOYER as the receiver
+        const NATIVE_DROP_AMOUNT = 1000000n; // 0.1 XLM (in stroops)
+        let nativeDropReceiver: Buffer;
+
+        it('Counter Increment (Composed ABA with Native Drop)', async () => {
+            // Get the native drop receiver address (32 bytes)
+            nativeDropReceiver = Buffer.from(
+                StrKey.decodeEd25519PublicKey(DEFAULT_DEPLOYER.publicKey()),
+            );
+            const nativeDropReceiverHex = '0x' + nativeDropReceiver.toString('hex');
+
+            // First quote the return fee (for the lz_compose to send back a message)
+            // Return message uses vanilla type with lzReceive option
+            const returnOptions = Options.newOptions().addExecutorLzReceiveOption(200000n, 0n);
+
+            const { result: returnFee } = await counterClient.quote({
+                dst_eid: EID,
+                msg_type: MSG_TYPE_VANILLA,
+                options: Buffer.from(returnOptions.toBytes()),
+                pay_in_zro: false,
+            });
+            console.log('✅ Return fee for ComposedABA:', returnFee);
+
+            // Add 1% buffer to the return fee
+            const returnFeeWithBuffer = (returnFee.native_fee * 101n) / 100n;
+            composeValue = returnFeeWithBuffer;
+
+            // Build type 3 options with:
+            // 1. lz_receive option (gas only, no value)
+            // 2. native_drop option (amount + receiver)
+            // 3. lz_compose option (index + gas + value for return message)
+            const composedAbaOptions = Options.newOptions()
+                .addExecutorLzReceiveOption(200000n, 0n)
+                .addExecutorNativeDropOption(NATIVE_DROP_AMOUNT, nativeDropReceiverHex)
+                .addExecutorComposeOption(0, 200000n, returnFeeWithBuffer);
+
+            const optionsBuffer = Buffer.from(composedAbaOptions.toBytes());
+
+            const { result: fee } = await counterClient.quote({
+                dst_eid: EID,
+                msg_type: MSG_TYPE_COMPOSED_ABA,
+                options: optionsBuffer,
+                pay_in_zro: false,
+            });
+            console.log('✅ ComposedABA Fee:', fee);
+
+            const assembledTx = await counterClient.increment({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                dst_eid: EID,
+                msg_type: MSG_TYPE_COMPOSED_ABA,
+                options: optionsBuffer,
+                fee: fee,
+            });
+            const sentTx = await assembledTx.signAndSend();
+
+            // Extract ledger number from transaction response
+            const txResponse = sentTx.getTransactionResponse;
+            if (txResponse && 'ledger' in txResponse) {
+                incrementLedger = txResponse.ledger;
+            }
+
+            const { result: outboundCount } = await counterClient.outbound_count({
+                eid: EID,
+            });
+            expect(outboundCount).toBe(1n);
+            console.log('✅ Counter incremented (Composed ABA), outbound count:', outboundCount);
+        });
+
+        it('Scan PacketSent Events (Composed ABA)', async () => {
+            const packetSentEvents = await scanPacketSentEvents(
+                protocolAddresses.endpointV2,
+                incrementLedger,
+            );
+            expect(packetSentEvents.length).toBeGreaterThan(0);
+            packetSentEvent = packetSentEvents[0];
+            console.log(
+                `✅ PacketSent events scanned successfully. Found ${packetSentEvents.length} events`,
+            );
+        });
+
+        it('Extract Packet Header and Payload Hash (Composed ABA)', async () => {
+            const packet = PacketSerializer.deserialize(packetSentEvent.encoded_packet);
+            guid = Buffer.from(packet.guid.replace('0x', ''), 'hex');
+            message = Buffer.from(packet.message.replace('0x', ''), 'hex');
+
+            const codec = PacketV1Codec.from(packet);
+            packetHeader = Buffer.from(codec.header().replace('0x', ''), 'hex');
+            payloadHash = Buffer.from(codec.payloadHash().replace('0x', ''), 'hex');
+
+            console.log('✅ Packet header extracted, length:', packetHeader.length);
+            console.log(
+                '✅ Payload hash extracted:',
+                payloadHash.toString('hex').slice(0, 16) + '...',
+            );
+        });
+
+        it('DVN Verifies Message (Composed ABA)', async () => {
+            const verifyTx = await uln302Client.verify({
+                dvn: protocolAddresses.dvn,
+                packet_header: packetHeader,
+                payload_hash: payloadHash,
+                confirmations: 1n,
+            });
+
+            await signDvnAuthEntries(
+                protocolAddresses.dvn,
+                DVN_VID,
+                DEFAULT_DEPLOYER,
+                [DVN_SIGNER],
+                verifyTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            await verifyTx.signAndSend();
+            console.log('✅ DVN verified message (Composed ABA)');
+
+            const { result: isVerifiable } = await uln302Client.verifiable({
+                packet_header: packetHeader,
+                payload_hash: payloadHash,
+            });
+            expect(isVerifiable).toBe(true);
+        });
+
+        it('Commit Verification (Composed ABA)', async () => {
+            const commitTx = await uln302Client.commit_verification({
+                packet_header: packetHeader,
+                payload_hash: payloadHash,
+            });
+            await commitTx.signAndSend();
+            console.log('✅ Verification committed to endpoint (Composed ABA)');
+        });
+
+        it('Execute native_drop_and_execute (Composed ABA)', async () => {
+            // Execute native_drop + lz_receive together
+            // For ComposedABA, lz_receive will queue a compose message via send_compose
+            const origin = {
+                nonce: 1n, // First message
+                sender: Buffer.from(StrKey.decodeContract(counterAddress)),
+                src_eid: EID,
+            };
+
+            // Get the balance before native drop
+            const balanceBefore = await getNativeBalance(DEFAULT_DEPLOYER.publicKey());
+            console.log('💰 Balance before native drop:', balanceBefore);
+
+            const assembledTx = await executorHelperClient.native_drop_and_execute(
+                {
+                    executor: protocolAddresses.executor,
+                    admin: EXECUTOR_ADMIN.publicKey(),
+                    origin,
+                    dst_eid: EID,
+                    oapp: counterAddress,
+                    native_drop_params: [
+                        {
+                            receiver: DEFAULT_DEPLOYER.publicKey(),
+                            amount: NATIVE_DROP_AMOUNT,
+                        },
+                    ],
+                    execute_params: {
+                        extra_data: Buffer.from([]),
+                        gas_limit: 0n,
+                        guid,
+                        message,
+                        origin,
+                        receiver: counterAddress,
+                        value: 0n, // No value for lz_receive, value is for lz_compose
+                    },
+                },
+                {
+                    simulate: false,
+                },
+            );
+
+            const txResult = await signAndSendWithExecutorAuth(
+                protocolAddresses.executor,
+                EXECUTOR_ADMIN,
+                assembledTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            assertTransactionSucceeded(txResult, 'native_drop_and_execute (Composed ABA)');
+
+            // Verify native drop was received
+            const balanceAfter = await getNativeBalance(DEFAULT_DEPLOYER.publicKey());
+            console.log('💰 Balance after native drop:', balanceAfter);
+            const balanceIncrease = balanceAfter - balanceBefore;
+            expect(balanceIncrease).toBe(NATIVE_DROP_AMOUNT);
+            console.log('✅ Native drop received:', NATIVE_DROP_AMOUNT, 'stroops');
+
+            // Verify the counter state
+            const { result: inboundCount } = await counterClient.inbound_count({
+                eid: EID,
+            });
+            expect(inboundCount).toBe(1n);
+            console.log('✅ Inbound count from EID', EID, ':', inboundCount);
+        });
+
+        // Variables for tracking the return message
+        let composeLedger = 0;
+        let returnPacketSentEvent: PacketSentEvent;
+        let returnGuid: Buffer;
+        let returnMessage: Buffer;
+        let returnPacketHeader: Buffer;
+        let returnPayloadHash: Buffer;
+
+        it('Execute lz_compose (Composed ABA)', async () => {
+            // Now execute the compose message that was queued by lz_receive
+            // For ComposedABA, this will send a return message back to source
+            const assembledTx = await executorHelperClient.compose(
+                {
+                    executor: protocolAddresses.executor,
+                    params: {
+                        from: counterAddress, // Compose message is from the counter
+                        to: counterAddress, // And to the counter (self-compose)
+                        guid,
+                        index: 0,
+                        message,
+                        extra_data: Buffer.from([]),
+                        value: composeValue,
+                        gas_limit: 0n,
+                    },
+                    value_payer: EXECUTOR_ADMIN.publicKey(),
+                },
+                {
+                    simulate: false,
+                },
+            );
+
+            const txResult = await signAndSendWithExecutorAuth(
+                protocolAddresses.executor,
+                EXECUTOR_ADMIN,
+                assembledTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            assertTransactionSucceeded(txResult, 'lz_compose (Composed ABA)');
+
+            // Extract ledger number for scanning return packet
+            if ('ledger' in txResult) {
+                composeLedger = txResult.ledger;
+            }
+
+            // Verify composed count increased
+            const { result: composedCount } = await counterClient.composed_count();
+            expect(composedCount).toBe(1n);
+            console.log('✅ Composed count:', composedCount);
+
+            // Verify outbound count increased (return message was sent)
+            const { result: outboundCount } = await counterClient.outbound_count({
+                eid: EID,
+            });
+            expect(outboundCount).toBe(2n); // 1 original + 1 return message
+            console.log('✅ Outbound count (including return message):', outboundCount);
+        });
+
+        it('Scan Return PacketSent Events', async () => {
+            // Scan for the return packet sent by lz_compose
+            const packetSentEvents = await scanPacketSentEvents(
+                protocolAddresses.endpointV2,
+                composeLedger,
+            );
+            expect(packetSentEvents.length).toBeGreaterThan(0);
+            returnPacketSentEvent = packetSentEvents[0];
+            console.log(
+                `✅ Return PacketSent events scanned. Found ${packetSentEvents.length} events`,
+            );
+        });
+
+        it('Extract Return Packet Header and Payload Hash', async () => {
+            const packet = PacketSerializer.deserialize(returnPacketSentEvent.encoded_packet);
+            returnGuid = Buffer.from(packet.guid.replace('0x', ''), 'hex');
+            returnMessage = Buffer.from(packet.message.replace('0x', ''), 'hex');
+
+            const codec = PacketV1Codec.from(packet);
+            returnPacketHeader = Buffer.from(codec.header().replace('0x', ''), 'hex');
+            returnPayloadHash = Buffer.from(codec.payloadHash().replace('0x', ''), 'hex');
+
+            console.log('✅ Return packet header extracted, length:', returnPacketHeader.length);
+            console.log(
+                '✅ Return payload hash extracted:',
+                returnPayloadHash.toString('hex').slice(0, 16) + '...',
+            );
+        });
+
+        it('DVN Verifies Return Message', async () => {
+            const verifyTx = await uln302Client.verify({
+                dvn: protocolAddresses.dvn,
+                packet_header: returnPacketHeader,
+                payload_hash: returnPayloadHash,
+                confirmations: 1n,
+            });
+
+            await signDvnAuthEntries(
+                protocolAddresses.dvn,
+                DVN_VID,
+                DEFAULT_DEPLOYER,
+                [DVN_SIGNER],
+                verifyTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            await verifyTx.signAndSend();
+            console.log('✅ DVN verified return message');
+
+            const { result: isVerifiable } = await uln302Client.verifiable({
+                packet_header: returnPacketHeader,
+                payload_hash: returnPayloadHash,
+            });
+            expect(isVerifiable).toBe(true);
+        });
+
+        it('Commit Verification (Return Message)', async () => {
+            const commitTx = await uln302Client.commit_verification({
+                packet_header: returnPacketHeader,
+                payload_hash: returnPayloadHash,
+            });
+            await commitTx.signAndSend();
+            console.log('✅ Verification committed for return message');
+        });
+
+        it('Receive Return Message (lz_receive)', async () => {
+            // Execute lz_receive for the return message (Vanilla type)
+            const origin = {
+                nonce: 2n, // Second message (return from ComposedABA)
+                sender: Buffer.from(StrKey.decodeContract(counterAddress)),
+                src_eid: EID,
+            };
+
+            const assembledTx = await executorHelperClient.execute(
+                {
+                    executor: protocolAddresses.executor,
+                    params: {
+                        extra_data: Buffer.from([]),
+                        gas_limit: 0n,
+                        guid: returnGuid,
+                        message: returnMessage,
+                        origin,
+                        receiver: counterAddress,
+                        value: 0n,
+                    },
+                    value_payer: EXECUTOR_ADMIN.publicKey(),
+                },
+                {
+                    simulate: false,
+                },
+            );
+
+            const txResult = await signAndSendWithExecutorAuth(
+                protocolAddresses.executor,
+                EXECUTOR_ADMIN,
+                assembledTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            assertTransactionSucceeded(txResult, 'lz_receive (Return Message)');
+
+            // Verify final counter state
+            const { result: count } = await counterClient.count();
+            expect(count).toBe(2n);
+            console.log('✅ Final counter count:', count);
+
+            const { result: inboundCount } = await counterClient.inbound_count({
+                eid: EID,
+            });
+            expect(inboundCount).toBe(2n); // 1 composed ABA + 1 return
+            console.log('✅ Final inbound count from EID', EID, ':', inboundCount);
+
+            console.log('\n🎉 Counter Composed ABA with Native Drop - Full Round Trip completed!');
+            console.log(
+                '   Workflow: Send ComposedABA → DVN Verify → Commit → native_drop_and_execute',
+            );
+            console.log(
+                '             → lz_compose (sends return) → DVN Verify → Commit → lz_receive',
+            );
+        });
+    });
+});