llm check

Author: martin0995

llms.txt

@@ -22664,6 +22664,149 @@ With the full VAA, Guardian signatures, and the latest Guardian set, we can now
   }
     ```
 
+???- code "Complete Function"
+    ```typescript
+    vaa: string | Uint8Array<ArrayBufferLike>,
+  observations: { guardianAddr: string; signature: string }[],
+  currentGuardians: string[],
+  guardianSetIndex: number
+) {
+  console.log('Replacing Signatures...');
+
+  try {
+    if (!vaa) throw new Error('VAA is undefined or empty.');
+    if (currentGuardians.length === 0)
+      throw new Error('Guardian set is empty.');
+    if (observations.length === 0) throw new Error('No observations provided.');
+
+    const validSigs = observations.filter((sig) =>
+      currentGuardians.includes(sig.guardianAddr)
+    );
+
+    if (validSigs.length === 0)
+      throw new Error('No valid signatures found. Cannot proceed.');
+
+    const formattedSigs = validSigs
+      .map((sig) => {
+        try {
+          const sigBuffer = Buffer.from(sig.signature, 'base64');
+          // If it's 130 bytes, it's hex-encoded and needs conversion
+          const sigBuffer1 =
+            sigBuffer.length === 130
+              ? Buffer.from(sigBuffer.toString(), 'hex')
+              : sigBuffer;
+
+          const r = BigInt('0x' + sigBuffer1.subarray(0, 32).toString('hex'));
+          const s = BigInt('0x' + sigBuffer1.subarray(32, 64).toString('hex'));
+          const vRaw = sigBuffer1[64];
+          const v = vRaw < 27 ? vRaw : vRaw - 27;
+
+          return {
+            guardianIndex: currentGuardians.indexOf(sig.guardianAddr),
+            signature: new Signature(r, s, v),
+          };
+        } catch (error) {
+          console.error(
+            `Failed to process signature for guardian: ${sig.guardianAddr}`,
+            error
+          );
+          return null;
+        }
+      })
+      .filter(
+        (sig): sig is { guardianIndex: number; signature: Signature } =>
+          sig !== null
+      ); // Remove null values
+
+    let parsedVaa: VAA<'Uint8Array'>;
+    try {
+      parsedVaa = deserialize('Uint8Array', vaa);
+    } catch (error) {
+      throw new Error(`Error deserializing VAA: ${error}`);
+    }
+
+    const outdatedGuardianIndexes = parsedVaa.signatures
+      .filter(
+        (vaaSig) =>
+          !formattedSigs.some(
+            (sig) => sig.guardianIndex === vaaSig.guardianIndex
+          )
+      )
+      .map((sig) => sig.guardianIndex);
+
+    console.log('Outdated Guardian Indexes:', outdatedGuardianIndexes);
+
+    let updatedSignatures = parsedVaa.signatures.filter(
+      (sig) => !outdatedGuardianIndexes.includes(sig.guardianIndex)
+    );
+
+    const validReplacements = formattedSigs.filter(
+      (sig) =>
+        !updatedSignatures.some((s) => s.guardianIndex === sig.guardianIndex)
+    );
+
+    // Check if we have enough valid signatures to replace outdated ones**
+    if (outdatedGuardianIndexes.length > validReplacements.length) {
+      console.warn(
+        `Not enough valid replacement signatures! Need ${outdatedGuardianIndexes.length}, but only ${validReplacements.length} available.`
+      );
+      return;
+    }
+
+    updatedSignatures = [
+      ...updatedSignatures,
+      ...validReplacements.slice(0, outdatedGuardianIndexes.length),
+    ];
+
+    updatedSignatures.sort((a, b) => a.guardianIndex - b.guardianIndex);
+
+    const updatedVaa: VAA<'Uint8Array'> = {
+      ...parsedVaa,
+      guardianSet: guardianSetIndex,
+      signatures: updatedSignatures,
+    };
+
+    let patchedVaa: Uint8Array;
+    try {
+      patchedVaa = serialize(updatedVaa);
+    } catch (error) {
+      throw new Error(`Error serializing updated VAA: ${error}`);
+    }
+
+    try {
+      if (!(patchedVaa instanceof Uint8Array))
+        throw new Error('Patched VAA is not a Uint8Array!');
+
+      const vaaHex = `0x${Buffer.from(patchedVaa).toString('hex')}`;
+
+      console.log('Sending updated VAA to RPC...');
+
+      const result = await axios.post(RPC, {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'eth_call',
+        params: [
+          {
+            from: null,
+            to: ETH_CORE,
+            data: eth.abi.encodeFunctionCall(PARSE_AND_VERIFY_VM_ABI, [vaaHex]),
+          },
+          'latest',
+        ],
+      });
+
+      const verificationResult = result.data.result;
+      console.log('Updated VAA (hex):', vaaHex);
+      return verificationResult;
+    } catch (error) {
+      throw new Error(`Error sending updated VAA to RPC: ${error}`);
+    }
+  } catch (error) {
+    console.error('Unexpected error in replaceSignatures:', error);
+  }
+}
+    ```
+
 ## Create Script to Replace Outdated VAA Signatures
 
 Now that we have all the necessary helper functions, we will create a script to automate replacing outdated VAA signatures. This script will retrieve a transaction’s VAA sequentially, check its validity, fetch the latest Guardian set, and update its signatures. By the end, it will output a correctly signed VAA that can be proposed for Guardian approval.