@layerzerolabs/lz-v2-stellar-sdk 0.2.59 → 0.2.61

package/test/counter-uln.test.ts

@@ -1,4 +1,4 @@
-import { StrKey } from '@stellar/stellar-sdk';
+import { Address, nativeToScVal, StrKey, xdr } from '@stellar/stellar-sdk';
 import path from 'path';
 import { beforeAll, describe, expect, inject, it } from 'vitest';
 
@@ -6,6 +6,7 @@ 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 DvnClient } from '../src/generated/dvn';
 import { Client as ExecutorHelperClient } from '../src/generated/executor_helper';
 import { Client as Uln302Client } from '../src/generated/uln302';
 import {
@@ -42,11 +43,13 @@ let counterBAddress = '';
 let uln302ClientA: Uln302Client;
 let counterClientA: CounterClient;
 let executorHelperClientA: ExecutorHelperClient;
+let dvnClientA: DvnClient;
 
 // Chain B Clients
 let uln302ClientB: Uln302Client;
 let counterClientB: CounterClient;
 let executorHelperClientB: ExecutorHelperClient;
+let dvnClientB: DvnClient;
 
 describe('Counter Cross-Chain Testing (ULN302)', async () => {
     const repoRoot = await getFullyQualifiedRepoRootPath();
@@ -82,10 +85,12 @@ describe('Counter Cross-Chain Testing (ULN302)', async () => {
         // Create clients for Chain A protocol contracts
         uln302ClientA = createClient(Uln302Client, chainA.uln302);
         executorHelperClientA = createClient(ExecutorHelperClient, chainA.executorHelper);
+        dvnClientA = createClient(DvnClient, chainA.dvn);
 
         // Create clients for Chain B protocol contracts
         uln302ClientB = createClient(Uln302Client, chainB.uln302);
         executorHelperClientB = createClient(ExecutorHelperClient, chainB.executorHelper);
+        dvnClientB = createClient(DvnClient, chainB.dvn);
     });
 
     describe('Deploy Counters on Both Chains', () => {
@@ -260,15 +265,22 @@ describe('Counter Cross-Chain Testing (ULN302)', async () => {
         });
 
         it('DVN B Verifies Message on Chain B (from Chain A)', async () => {
-            // Chain B's DVN verifies the packet on Chain B's ULN302
-            const verifyTx = await uln302ClientB.verify({
-                dvn: chainB.dvn,
-                packet_header: packetHeader,
-                payload_hash: payloadHash,
-                confirmations: 1n,
+            // DVN calls execute_transaction to invoke uln302.verify externally
+            const verifyTx = await dvnClientB.execute_transaction({
+                calls: [
+                    {
+                        to: chainB.uln302,
+                        func: 'verify',
+                        args: [
+                            nativeToScVal(Address.fromString(chainB.dvn), { type: 'address' }),
+                            nativeToScVal(packetHeader, { type: 'bytes' }),
+                            nativeToScVal(payloadHash, { type: 'bytes' }),
+                            xdr.ScVal.scvU64(new xdr.Uint64(BigInt(1))),
+                        ],
+                    },
+                ],
             });
 
-            // Sign with DVN_SIGNER (shared between both chains)
             await signDvnAuthEntries(
                 chainB.dvn,
                 DVN_VID,
@@ -469,15 +481,22 @@ describe('Counter Cross-Chain Testing (ULN302)', async () => {
         });
 
         it('DVN A Verifies Return Message on Chain A (from Chain B)', async () => {
-            // Chain A's DVN verifies the packet on Chain A's ULN302
-            const verifyTx = await uln302ClientA.verify({
-                dvn: chainA.dvn,
-                packet_header: returnPacketHeader,
-                payload_hash: returnPayloadHash,
-                confirmations: 1n,
+            // DVN calls execute_transaction to invoke uln302.verify externally
+            const verifyTx = await dvnClientA.execute_transaction({
+                calls: [
+                    {
+                        to: chainA.uln302,
+                        func: 'verify',
+                        args: [
+                            nativeToScVal(Address.fromString(chainA.dvn), { type: 'address' }),
+                            nativeToScVal(returnPacketHeader, { type: 'bytes' }),
+                            nativeToScVal(returnPayloadHash, { type: 'bytes' }),
+                            xdr.ScVal.scvU64(new xdr.Uint64(BigInt(1))),
+                        ],
+                    },
+                ],
             });
 
-            // Sign with DVN_SIGNER (shared between both chains)
             await signDvnAuthEntries(
                 chainA.dvn,
                 DVN_VID,

package/test/upgrader.test.ts

@@ -111,6 +111,27 @@ describe('Upgrader Contract Testing', async () => {
             expect(newWasmHash).toBeDefined();
         });
 
+        it('Set Upgrader on DVN', async () => {
+            const setUpgraderTx = await dvnClient.set_upgrader({
+                upgrader: upgraderClient.options.contractId,
+            });
+
+            await signDvnAuthEntries(
+                testContractAddress,
+                DVN_VID,
+                DEFAULT_DEPLOYER,
+                [DVN_SIGNER],
+                setUpgraderTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            await setUpgraderTx.signAndSend();
+            console.log('✅ Upgrader set on DVN to:', upgraderClient.options.contractId);
+
+            const { result: upgrader } = await dvnClient.upgrader();
+            expect(upgrader).toBe(upgraderClient.options.contractId);
+        });
+
         it('Test Upgrader Contract Can Upgrade DVN with Multisig Auth', async () => {
             console.log('🔄 Testing upgrader contract call...');
             console.log('   Contract address:', testContractAddress);

package/test/utils.ts

@@ -167,7 +167,6 @@ import { Secp256k1KeyPair } from './secp256k1';
  * - expiration: u64 - Ledger timestamp for when auth expires
  * - signatures: Vec<BytesN<65>> - Secp256k1 signatures from multisig signers
  * - sender: Sender - Either None or Admin(public_key, ed25519_signature)
- * - preimage: Bytes - XDR-encoded HashIdPreimage::SorobanAuthorization (invocation is sliced from byte 48)
  */
 export async function signDvnAuthEntries<T>(
     dvnAddress: string,
@@ -234,11 +233,15 @@ export async function signDvnAuthEntries<T>(
             adminSignature.toString('hex').slice(0, 32) + '...',
         );
 
-        // 3. Compute the multisig hash from raw invocation XDR
-        // hash = keccak256(vid || expiration || invocation_xdr)
+        // 3. Extract calls from the auth entry and compute the multisig hash
+        // The expiration is the ledger timestamp when the auth expires
+        // We use validUntilLedgerSeq * 5 as a rough approximation (5 seconds per ledger)
         const expiration = BigInt(validUntilLedgerSeq) * 5n + BigInt(Math.floor(Date.now() / 1000));
-        const invocationXdr = Buffer.from(rootInvocation.toXDR());
-        const callHash = computeCallHash(vid, expiration, invocationXdr);
+        const rootCall = getRootCall(rootInvocation);
+        const isSelfCall = rootCall.to === dvnAddr.toString();
+        const calls = isSelfCall ? [rootCall] : collectCallsFromInvocation(rootInvocation);
+        const callsXdr = serializeCallsToXdr(calls);
+        const callHash = computeCallHash(vid, expiration, callsXdr);
         console.log('📝 Call hash for multisig:', Buffer.from(callHash).toString('hex'));
 
         // 4. Sign the call hash with multisig signers
@@ -261,19 +264,16 @@ export async function signDvnAuthEntries<T>(
         const sortedSignatures = signaturesWithAddresses.map((s) => s.sig);
 
         // 6. Build TransactionAuthData as ScVal
-        // struct TransactionAuthData { vid, expiration, signatures, sender, preimage }
-        const preimageXdr = Buffer.from(preimage.toXDR());
+        // struct TransactionAuthData { vid: u32, expiration: u64, signatures: Vec<BytesN<65>>, sender: Sender }
+        // enum Sender { None, Admin(BytesN<32>, BytesN<64>) }
         const transactionAuthDataScVal = xdr.ScVal.scvMap([
             new xdr.ScMapEntry({
                 key: xdr.ScVal.scvSymbol('expiration'),
                 val: xdr.ScVal.scvU64(new xdr.Uint64(expiration)),
             }),
-            new xdr.ScMapEntry({
-                key: xdr.ScVal.scvSymbol('preimage'),
-                val: xdr.ScVal.scvBytes(preimageXdr),
-            }),
             new xdr.ScMapEntry({
                 key: xdr.ScVal.scvSymbol('sender'),
+                // Sender::Admin(public_key, signature)
                 val: xdr.ScVal.scvVec([
                     xdr.ScVal.scvSymbol('Admin'),
                     xdr.ScVal.scvBytes(adminKeypair.rawPublicKey()),
@@ -325,11 +325,97 @@ export async function signDvnAuthEntries<T>(
     console.log('✅ Final simulation complete');
 }
 
+/**
+ * Represents a contract call for multisig authorization.
+ */
+interface Call {
+    to: string; // Contract address
+    func: string; // Function name
+    args: xdr.ScVal[]; // Function arguments
+}
+
+/**
+ * Extracts only the root call from an invocation (no recursion into sub-invocations).
+ */
+function getRootCall(invocation: xdr.SorobanAuthorizedInvocation): Call {
+    const fn = invocation.function();
+    if (
+        fn.switch() !== xdr.SorobanAuthorizedFunctionType.sorobanAuthorizedFunctionTypeContractFn()
+    ) {
+        throw new Error('Root invocation is not a contract function');
+    }
+    const contractFn = fn.contractFn();
+    return {
+        to: Address.fromScAddress(contractFn.contractAddress()).toString(),
+        func: contractFn.functionName().toString(),
+        args: contractFn.args(),
+    };
+}
+
+/**
+ * Collects all contract calls from an invocation tree.
+ */
+function collectCallsFromInvocation(invocation: xdr.SorobanAuthorizedInvocation): Call[] {
+    const calls: Call[] = [];
+    collectCallsRecursive(invocation, calls);
+    return calls;
+}
+
+function collectCallsRecursive(invocation: xdr.SorobanAuthorizedInvocation, calls: Call[]): void {
+    const fn = invocation.function();
+
+    if (
+        fn.switch() === xdr.SorobanAuthorizedFunctionType.sorobanAuthorizedFunctionTypeContractFn()
+    ) {
+        const contractFn = fn.contractFn();
+        const contractAddr = Address.fromScAddress(contractFn.contractAddress());
+
+        calls.push({
+            to: contractAddr.toString(),
+            func: contractFn.functionName().toString(),
+            args: contractFn.args(),
+        });
+    }
+
+    // Process sub-invocations
+    for (const sub of invocation.subInvocations()) {
+        collectCallsRecursive(sub, calls);
+    }
+}
+
+/**
+ * Serializes calls to XDR format matching Soroban's Vec<Call> serialization.
+ *
+ * Call struct: { args: Vec<Val>, func: Symbol, to: Address }
+ * Serialized as ScMap with keys in alphabetical order.
+ */
+function serializeCallsToXdr(calls: Call[]): Buffer {
+    const callScVals = calls.map((call) =>
+        xdr.ScVal.scvMap([
+            new xdr.ScMapEntry({
+                key: xdr.ScVal.scvSymbol('args'),
+                val: xdr.ScVal.scvVec(call.args),
+            }),
+            new xdr.ScMapEntry({
+                key: xdr.ScVal.scvSymbol('func'),
+                val: xdr.ScVal.scvSymbol(call.func),
+            }),
+            new xdr.ScMapEntry({
+                key: xdr.ScVal.scvSymbol('to'),
+                val: Address.fromString(call.to).toScVal(),
+            }),
+        ]),
+    );
+
+    const vecScVal = xdr.ScVal.scvVec(callScVals);
+    return Buffer.from(vecScVal.toXDR());
+}
+
 /**
  * Computes the call hash for multisig signing.
- * hash = keccak256(vid.to_be_bytes(4) || expiration.to_be_bytes(8) || invocation_xdr)
+ * hash = keccak256(vid.to_be_bytes(4) || expiration.to_be_bytes(8) || calls_xdr)
  */
-function computeCallHash(vid: number, expiration: bigint, invocationXdr: Buffer): Uint8Array {
+function computeCallHash(vid: number, expiration: bigint, callsXdr: Buffer): Uint8Array {
     // vid as 4-byte big-endian
     const vidBytes = Buffer.alloc(4);
     vidBytes.writeUInt32BE(vid, 0);
@@ -338,7 +424,8 @@ function computeCallHash(vid: number, expiration: bigint, invocationXdr: Buffer)
     const expirationBytes = Buffer.alloc(8);
     expirationBytes.writeBigUInt64BE(expiration, 0);
 
-    const data = Buffer.concat([vidBytes, expirationBytes, invocationXdr]);
+    // Concatenate and hash
+    const data = Buffer.concat([vidBytes, expirationBytes, callsXdr]);
     return keccak_256(data);
 }