@layerzerolabs/protocol-stellar-v2 0.2.60 → 0.2.61

package/sdk/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);
 }