@across-protocol/sdk 4.3.137-alpha.3 → 4.4.0-alpha.2

package/src/svm/web3-v1/solanaProgramUtils.ts

@@ -0,0 +1,285 @@
+import { BN, Idl, Program, utils, web3 } from "@coral-xyz/anchor";
+import {
+  ConfirmedSignatureInfo,
+  Connection,
+  Finality,
+  Logs,
+  PublicKey,
+  SignaturesForAddressOptions,
+} from "@solana/web3.js";
+import { deserialize } from "borsh";
+import { EventType } from "../types.svm";
+import { publicKeyToEvmAddress, u8Array32ToInt } from "./conversionUtils";
+
+/**
+ * Finds a program address with a given label and optional extra seeds.
+ */
+export function findProgramAddress(label: string, program: PublicKey, extraSeeds?: string[]) {
+  const seeds: Buffer[] = [Buffer.from(utils.bytes.utf8.encode(label))];
+  if (extraSeeds) {
+    for (const extraSeed of extraSeeds) {
+      if (typeof extraSeed === "string") {
+        seeds.push(Buffer.from(utils.bytes.utf8.encode(extraSeed)));
+      } else if (Array.isArray(extraSeed)) {
+        seeds.push(Buffer.from(extraSeed));
+      } else if (Buffer.isBuffer(extraSeed)) {
+        seeds.push(extraSeed);
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        seeds.push((extraSeed as any).toBuffer());
+      }
+    }
+  }
+  const res = PublicKey.findProgramAddressSync(seeds, program);
+  return { publicKey: res[0], bump: res[1] };
+}
+
+/**
+ * Reads events from a transaction.
+ */
+export async function readEvents<IDL extends Idl = Idl>(
+  connection: Connection,
+  txSignature: string,
+  programs: Program<IDL>[],
+  commitment: Finality = "confirmed"
+) {
+  const txResult = await connection.getTransaction(txSignature, { commitment, maxSupportedTransactionVersion: 0 });
+
+  if (txResult === null) return [];
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return processEventFromTx(txResult as any, programs);
+}
+
+/**
+ * Processes events from a transaction.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function processEventFromTx(txResult: web3.VersionedTransactionResponse, programs: Program<any>[]) {
+  const eventAuthorities: Map<string, PublicKey> = new Map();
+  for (const program of programs) {
+    eventAuthorities.set(
+      program.programId.toString(),
+      findProgramAddress("__event_authority", program.programId).publicKey
+    );
+  }
+
+  const events = [];
+
+  // Resolve any potential addresses that were passed from address lookup tables.
+  const messageAccountKeys = txResult.transaction.message.getAccountKeys({
+    accountKeysFromLookups: txResult.meta?.loadedAddresses,
+  });
+
+  for (const ixBlock of txResult.meta?.innerInstructions ?? []) {
+    for (const ix of ixBlock.instructions) {
+      for (const program of programs) {
+        const ixProgramId = messageAccountKeys.get(ix.programIdIndex);
+        const singleIxAccount = ix.accounts.length === 1 ? messageAccountKeys.get(ix.accounts[0]) : undefined;
+        if (
+          ixProgramId !== undefined &&
+          singleIxAccount !== undefined &&
+          program.programId.equals(ixProgramId) &&
+          eventAuthorities.get(ixProgramId.toString())?.equals(singleIxAccount)
+        ) {
+          const ixData = utils.bytes.bs58.decode(ix.data);
+          const eventData = utils.bytes.base64.encode(Buffer.from(new Uint8Array(ixData).slice(8)));
+          const event = program.coder.events.decode(eventData);
+          events.push({
+            program: program.programId,
+            data: event?.data,
+            name: event?.name,
+          });
+        }
+      }
+    }
+  }
+  return events;
+}
+
+/**
+ * Helper function to wait for an event to be emitted. Should only be used in tests where txSignature is known to emit.
+ */
+export async function readEventsUntilFound<IDL extends Idl = Idl>(
+  connection: Connection,
+  txSignature: string,
+  programs: Program<IDL>[]
+) {
+  const startTime = Date.now();
+  let txResult = null;
+
+  while (Date.now() - startTime < 5000) {
+    // 5 seconds timeout to wait to find the event.
+    txResult = await connection.getTransaction(txSignature, {
+      commitment: "confirmed",
+      maxSupportedTransactionVersion: 0,
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (txResult !== null) return processEventFromTx(txResult as any, programs);
+
+    await new Promise((resolve) => setTimeout(resolve, 50)); // 50 ms delay between retries.
+  }
+
+  throw new Error("No event found within 5 seconds");
+}
+
+/**
+ * Retrieves a specific event by name from a list of events.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getEvent(events: any[], program: PublicKey, eventName: string) {
+  for (const event of events) {
+    if (event.name === eventName && program.toString() === event.program.toString()) {
+      return event.data;
+    }
+  }
+  throw new Error("Event " + eventName + " not found");
+}
+
+/**
+ * Reads all events for a specific program.
+ */
+export async function readProgramEvents(
+  connection: Connection,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  program: Program<any>,
+  finality: Finality = "confirmed",
+  options: SignaturesForAddressOptions = { limit: 1000 }
+): Promise<EventType[]> {
+  const allSignatures: ConfirmedSignatureInfo[] = [];
+
+  // Fetch all signatures in sequential batches
+  for (;;) {
+    const signatures = await connection.getSignaturesForAddress(program.programId, options, finality);
+    allSignatures.push(...signatures);
+
+    // Update options for the next batch. Set before to the last fetched signature.
+    if (signatures.length > 0) {
+      options = { ...options, before: signatures[signatures.length - 1].signature };
+    }
+
+    if (options.limit && signatures.length < options.limit) break; // Exit early if the number of signatures < limit
+  }
+
+  // Fetch events for all signatures in parallel
+  const eventsWithSlots = await Promise.all(
+    allSignatures.map(async (signature) => {
+      const events = await readEvents(connection, signature.signature, [program], finality);
+      return events.map((event) => ({
+        ...event,
+        confirmationStatus: signature.confirmationStatus || "Unknown",
+        blockTime: signature.blockTime || 0,
+        signature: signature.signature,
+        slot: signature.slot,
+        name: event.name || "Unknown",
+      }));
+    })
+  );
+
+  return eventsWithSlots.flat(); // Flatten the array of events & return.
+}
+
+/**
+ * Subscribes to CPI events for a program.
+ */
+export function subscribeToCpiEventsForProgram(
+  connection: Connection,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  program: Program<any>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  callback: (events: any[]) => void
+) {
+  const subscriptionId = connection.onLogs(
+    new PublicKey(findProgramAddress("__event_authority", program.programId).publicKey.toString()),
+    async (logs: Logs) => {
+      callback(await readEvents(connection, logs.signature, [program], "confirmed"));
+    },
+    "confirmed"
+  );
+
+  return subscriptionId;
+}
+
+/**
+ * Class for DepositId.
+ */
+class DepositId {
+  value: Uint8Array; // Fixed-length array as Uint8Array
+
+  constructor(properties: { value: Uint8Array }) {
+    this.value = properties.value;
+  }
+}
+
+/**
+ * Borsh schema for deserializing DepositId.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const depositIdSchema: any = new Map(
+  [[DepositId, { kind: "struct", fields: [["value", [32]]] }]] // Fixed array [u8; 32]
+);
+
+/**
+ * Parses depositId: checks if only the first 4 bytes are non-zero and returns a u32 or deserializes the full array.
+ */
+function parseDepositId(value: Uint8Array): string {
+  const restAreZero = value.slice(4).every((byte) => byte === 0);
+
+  if (restAreZero) {
+    // Parse the first 4 bytes as a little-endian u32
+    const u32Value = new DataView(value.buffer).getUint32(0, true); // true for little-endian
+    return u32Value.toString();
+  }
+
+  // Deserialize the full depositId using the Borsh schema
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const depositId = (deserialize as any)(depositIdSchema, DepositId, Buffer.from(value)) as DepositId;
+  return new BN(depositId.value).toString();
+}
+
+/**
+ * Stringifies a CPI event.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function stringifyCpiEvent(obj: any, eventName: string): any {
+  if (obj?.constructor?.toString()?.includes("PublicKey")) {
+    if (obj.toString().startsWith("111111111111")) {
+      // First 12 bytes are 0 for EVM addresses.
+      return publicKeyToEvmAddress(obj);
+    }
+    return obj.toString();
+  } else if (BN.isBN(obj)) {
+    return obj.toString();
+  } else if (typeof obj === "bigint") {
+    return obj.toString();
+  } else if (Array.isArray(obj) && obj.length == 32) {
+    return Buffer.from(obj).toString("hex"); // Hex representation for fixed-length arrays
+  } else if (Array.isArray(obj)) {
+    return obj.map((obj) => stringifyCpiEvent(obj, eventName));
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => {
+        if (Array.isArray(value) && value.length === 32) {
+          if (key === "depositId" || key === "deposit_id") {
+            // Parse depositId using the helper function
+            const parsedValue = parseDepositId(new Uint8Array(value));
+            return [key, parsedValue];
+          } else if (
+            eventName.toLowerCase() === "fundsdeposited" &&
+            (key === "outputAmount" || key === "output_amount")
+          ) {
+            return [key, u8Array32ToInt(new Uint8Array(value)).toString()];
+          } else if (
+            (eventName.toLowerCase() === "filledrelay" || eventName.toLowerCase() === "requestedslowfill") &&
+            (key === "inputAmount" || key === "input_amount")
+          ) {
+            return [key, u8Array32ToInt(new Uint8Array(value)).toString()];
+          }
+        }
+        return [key, stringifyCpiEvent(value, eventName)];
+      })
+    );
+  }
+  return obj;
+}

package/src/svm/web3-v1/transactionUtils.ts

@@ -0,0 +1,134 @@
+import { web3 } from "@coral-xyz/anchor";
+import {
+  AddressLookupTableAccount,
+  AddressLookupTableProgram,
+  Connection,
+  Keypair,
+  PublicKey,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js";
+
+/**
+ * Sends a transaction using an Address Lookup Table for large numbers of accounts.
+ */
+export async function sendTransactionWithLookupTable(
+  connection: Connection,
+  instructions: TransactionInstruction[],
+  sender: Keypair,
+  additionalSigners: Keypair[] = []
+): Promise<{ txSignature: string; lookupTableAddress: PublicKey }> {
+  // Maximum number of accounts that can be added to Address Lookup Table (ALT) in a single transaction.
+  const maxExtendedAccounts = 30;
+
+  // Consolidate addresses from all instructions into a single array for the ALT.
+  const lookupAddresses = Array.from(
+    new Set(
+      instructions.flatMap((instruction) => [
+        instruction.programId,
+        ...instruction.keys.map((accountMeta) => accountMeta.pubkey),
+      ])
+    )
+  );
+
+  // Create instructions for creating and extending the ALT.
+  const [lookupTableInstruction, lookupTableAddress] = await AddressLookupTableProgram.createLookupTable({
+    authority: sender.publicKey,
+    payer: sender.publicKey,
+    recentSlot: await connection.getSlot(),
+  });
+
+  // Submit the ALT creation transaction
+  await web3.sendAndConfirmTransaction(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    connection as any,
+    new web3.Transaction().add(lookupTableInstruction),
+    [sender],
+    {
+      commitment: "confirmed",
+      skipPreflight: true,
+    }
+  );
+
+  // Extend the ALT with all accounts making sure not to exceed the maximum number of accounts per transaction.
+  for (let i = 0; i < lookupAddresses.length; i += maxExtendedAccounts) {
+    const extendInstruction = AddressLookupTableProgram.extendLookupTable({
+      lookupTable: lookupTableAddress,
+      authority: sender.publicKey,
+      payer: sender.publicKey,
+      addresses: lookupAddresses.slice(i, i + maxExtendedAccounts),
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await web3.sendAndConfirmTransaction(connection as any, new web3.Transaction().add(extendInstruction), [sender], {
+      commitment: "confirmed",
+      skipPreflight: true,
+    });
+  }
+
+  // Wait for slot to advance. LUTs only active after slot advance.
+  const initialSlot = await connection.getSlot();
+  while ((await connection.getSlot()) === initialSlot) {
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+
+  // Fetch the AddressLookupTableAccount
+  const lookupTableAccount = (await connection.getAddressLookupTable(lookupTableAddress)).value;
+  if (lookupTableAccount === null) throw new Error("AddressLookupTableAccount not fetched");
+
+  // Create the versioned transaction
+  const versionedTx = new VersionedTransaction(
+    new TransactionMessage({
+      payerKey: sender.publicKey,
+      recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
+      instructions,
+    }).compileToV0Message([lookupTableAccount])
+  );
+
+  // Sign and submit the versioned transaction.
+  versionedTx.sign([sender, ...additionalSigners]);
+  const txSignature = await connection.sendTransaction(versionedTx);
+
+  // Confirm the versioned transaction
+  const block = await connection.getLatestBlockhash();
+  await connection.confirmTransaction(
+    { signature: txSignature, blockhash: block.blockhash, lastValidBlockHeight: block.lastValidBlockHeight },
+    "confirmed"
+  );
+
+  return { txSignature, lookupTableAddress };
+}
+
+/**
+ * Sends a transaction using existing Address Lookup Table.
+ */
+export async function sendTransactionWithExistingLookupTable(
+  connection: Connection,
+  instructions: TransactionInstruction[],
+  lookupTableAccount: AddressLookupTableAccount,
+  sender: Keypair,
+  additionalSigners: Keypair[] = []
+): Promise<string> {
+  // Create the versioned transaction
+  const versionedTx = new VersionedTransaction(
+    new TransactionMessage({
+      payerKey: sender.publicKey,
+      recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
+      instructions,
+    }).compileToV0Message([lookupTableAccount])
+  );
+
+  // Sign and submit the versioned transaction.
+  versionedTx.sign([sender, ...additionalSigners]);
+  const txSignature = await connection.sendTransaction(versionedTx);
+
+  // Confirm the versioned transaction
+  const block = await connection.getLatestBlockhash();
+  await connection.confirmTransaction(
+    { signature: txSignature, blockhash: block.blockhash, lastValidBlockHeight: block.lastValidBlockHeight },
+    "confirmed"
+  );
+
+  return txSignature;
+}

package/src/svm/web3-v2/index.ts

@@ -0,0 +1,3 @@
+export * from "./solanaProgramUtils";
+export * from "./transactionUtils";
+export * from "./types";

package/src/svm/web3-v2/solanaProgramUtils.ts

@@ -0,0 +1,148 @@
+import { BorshEventCoder, Idl, utils } from "@coral-xyz/anchor";
+import web3, { Address, Commitment, GetSignaturesForAddressApi, GetTransactionApi, Signature } from "@solana/kit";
+import { RpcClient } from "./types";
+
+type GetTransactionReturnType = ReturnType<GetTransactionApi["getTransaction"]>;
+
+type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getSignaturesForAddress"]>[1];
+
+type GetSignaturesForAddressTransaction = ReturnType<GetSignaturesForAddressApi["getSignaturesForAddress"]>[number];
+
+/**
+ * Reads all events for a specific program.
+ */
+export async function readProgramEvents(
+  rpc: RpcClient,
+  program: Address,
+  anchorIdl: Idl,
+  finality: Commitment = "confirmed",
+  options: GetSignaturesForAddressConfig = { limit: 1000 }
+) {
+  const allSignatures: GetSignaturesForAddressTransaction[] = await searchSignaturesUntilLimit(rpc, program, options);
+
+  // Fetch events for all signatures in parallel
+  const eventsWithSlots = await Promise.all(
+    allSignatures.map(async (signatureTransaction) => {
+      const events = await readEvents(rpc, signatureTransaction.signature, program, anchorIdl, finality);
+
+      return events.map((event) => ({
+        ...event,
+        confirmationStatus: signatureTransaction.confirmationStatus || "Unknown",
+        blockTime: signatureTransaction.blockTime || 0,
+        signature: signatureTransaction.signature,
+        slot: signatureTransaction.slot,
+        name: event.name || "Unknown",
+      }));
+    })
+  );
+  return eventsWithSlots.flat();
+}
+
+async function searchSignaturesUntilLimit(
+  client: RpcClient,
+  program: Address,
+  options: GetSignaturesForAddressConfig = { limit: 1000 }
+): Promise<GetSignaturesForAddressTransaction[]> {
+  const allSignatures: GetSignaturesForAddressTransaction[] = [];
+  // Fetch all signatures in sequential batches
+  for (;;) {
+    const signatures = await client.rpc.getSignaturesForAddress(program, options).send();
+    allSignatures.push(...signatures);
+
+    // Update options for the next batch. Set before to the last fetched signature.
+    if (signatures.length > 0) {
+      options = { ...options, before: signatures[signatures.length - 1].signature };
+    }
+
+    if (options.limit && signatures.length < options.limit) break; // Exit early if the number of signatures < limit
+  }
+  return allSignatures;
+}
+
+/**
+ * Reads events from a transaction.
+ */
+export async function readEvents(
+  client: RpcClient,
+  txSignature: Signature,
+  programId: Address,
+  programIdl: Idl,
+  commitment: Commitment = "confirmed"
+) {
+  const txResult = await client.rpc
+    .getTransaction(txSignature, { encoding: "json", commitment, maxSupportedTransactionVersion: 0 })
+    .send();
+
+  if (txResult === null) return [];
+
+  // Ensure `version` field is always present in the response. @todo Drop this with next Anchor upgrade.
+  const txWithVersion = { ...txResult, version: txResult.version ?? 0 };
+  return processEventFromTx(txWithVersion, programId, programIdl);
+}
+
+/**
+ * Processes events from a transaction.
+ */
+async function processEventFromTx(
+  txResult: GetTransactionReturnType,
+  programId: Address,
+  programIdl: Idl
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<{ program: Address; data: any; name: string | undefined }[]> {
+  if (!txResult) return [];
+  const eventAuthorities: Map<string, Address> = new Map();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const events: { program: Address; data: any; name: string | undefined }[] = [];
+  const [pda] = await web3.getProgramDerivedAddress({ programAddress: programId, seeds: ["__event_authority"] });
+  eventAuthorities.set(programId, pda);
+
+  const accountKeys = txResult.transaction.message.accountKeys;
+  const messageAccountKeys = [...accountKeys];
+  // Order matters here. writable accounts must be processed before readonly accounts.
+  // See https://docs.anza.xyz/proposals/versioned-transactions#new-transaction-format
+  messageAccountKeys.push(...(txResult?.meta?.loadedAddresses?.writable ?? []));
+  messageAccountKeys.push(...(txResult?.meta?.loadedAddresses?.readonly ?? []));
+
+  for (const ixBlock of txResult.meta?.innerInstructions ?? []) {
+    for (const ix of ixBlock.instructions) {
+      const ixProgramId = messageAccountKeys[ix.programIdIndex];
+      const singleIxAccount = ix.accounts.length === 1 ? messageAccountKeys[ix.accounts[0]] : undefined;
+      if (
+        ixProgramId !== undefined &&
+        singleIxAccount !== undefined &&
+        programId == ixProgramId &&
+        eventAuthorities.get(ixProgramId.toString()) == singleIxAccount
+      ) {
+        const ixData = utils.bytes.bs58.decode(ix.data);
+        const eventData = utils.bytes.base64.encode(Buffer.from(new Uint8Array(ixData).slice(8)));
+        const event = new BorshEventCoder(programIdl).decode(eventData);
+        events.push({
+          program: programId,
+          data: event?.data,
+          name: event?.name,
+        });
+      }
+    }
+  }
+
+  return events;
+}
+
+/**
+ * For a given fillStatusPDa & associated spokePool ProgramID, return the fill event.
+ */
+export async function readFillEventFromFillStatusPda(
+  client: RpcClient,
+  fillStatusPda: Address,
+  programId: Address,
+  programIdl: Idl
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<{ event: any; slot: number }> {
+  const signatures = await searchSignaturesUntilLimit(client, fillStatusPda);
+  if (signatures.length === 0) return { event: null, slot: 0 };
+
+  // The first signature will always be PDA creation, and therefore CPI event carrying signature. Any older signatures
+  // will therefore be either spam or PDA closure signatures and can be ignored when looking for the fill event.
+  const events = await readEvents(client, signatures[signatures.length - 1].signature, programId, programIdl);
+  return { event: events[0], slot: Number(signatures[signatures.length - 1].slot) };
+}