@across-protocol/sdk 4.3.12 → 4.3.13

package/src/arch/svm/SpokeUtils.ts

@@ -1,7 +1,8 @@
-import { SvmSpokeClient } from "@across-protocol/contracts";
+import { MessageTransmitterClient, SvmSpokeClient, TokenMessengerMinterClient } from "@across-protocol/contracts";
 import { decodeFillStatusAccount, fetchState } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
-import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1/conversionUtils";
 import { hashNonEmptyMessage } from "@across-protocol/contracts/dist/src/svm/web3-v1";
+import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1/conversionUtils";
+import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
   TOKEN_PROGRAM_ADDRESS,
@@ -10,48 +11,60 @@ import {
   getCreateAssociatedTokenIdempotentInstruction,
 } from "@solana-program/token";
 import {
+  AccountRole,
   Address,
+  IAccountMeta,
+  KeyPairSigner,
+  ReadonlyUint8Array,
   appendTransactionMessageInstruction,
   fetchEncodedAccount,
   fetchEncodedAccounts,
   getAddressEncoder,
+  getBase64EncodedWireTransaction,
   getProgramDerivedAddress,
+  getSignatureFromTransaction,
   getU32Encoder,
   getU64Encoder,
   pipe,
-  ReadonlyUint8Array,
+  signTransactionMessageWithSigners,
   some,
   type TransactionSigner,
 } from "@solana/kit";
 import assert from "assert";
 import { arrayify, hexZeroPad, hexlify } from "ethers/lib/utils";
 import { Logger } from "winston";
-import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
+import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "../../constants";
 import { DepositWithBlock, FillStatus, FillWithBlock, RelayData, RelayExecutionEventInfo } from "../../interfaces";
 import {
   BigNumber,
   EvmAddress,
-  SvmAddress,
   Address as SdkAddress,
+  SvmAddress,
+  bs58,
+  chainIsProd,
   chainIsSvm,
   chunk,
   isUnsafeDepositId,
   keccak256,
+  mapAsync,
   toAddressType,
 } from "../../utils";
-import { SvmCpiEventsClient } from "./eventsClient";
 import {
   bigToU8a32,
   createDefaultTransaction,
+  getCCTPNoncePda,
   getEventAuthority,
   getFillStatusPda,
+  getSelfAuthority,
   getStatePda,
+  isDepositForBurnEvent,
+  simulateAndDecode,
   toAddress,
   unwrapEventData,
-} from "./utils";
-import { CHAIN_IDs } from "../../constants";
-import { isSolanaError, SVM_NO_BLOCK_AT_SLOT } from "./provider";
-import { SVMEventNames, SVMProvider } from "./types";
+} from "./";
+import { SvmCpiEventsClient } from "./eventsClient";
+import { SVM_NO_BLOCK_AT_SLOT, isSolanaError } from "./provider";
+import { AttestedCCTPMessage, SVMEventNames, SVMProvider } from "./types";
 
 /**
  * @note: Average Solana slot duration is about 400-500ms. We can be conservative
@@ -796,6 +809,19 @@ export const createCloseFillPdaInstruction = async (
   );
 };
 
+export const createReceiveMessageInstruction = async (
+  signer: TransactionSigner,
+  solanaClient: SVMProvider,
+  input: MessageTransmitterClient.ReceiveMessageInput,
+  remainingAccounts: IAccountMeta<string>[]
+) => {
+  const receiveMessageIx = await MessageTransmitterClient.getReceiveMessageInstruction(input);
+  (receiveMessageIx.accounts as IAccountMeta<string>[]).push(...remainingAccounts);
+  return pipe(await createDefaultTransaction(solanaClient, signer), (tx) =>
+    appendTransactionMessageInstruction(receiveMessageIx, tx)
+  );
+};
+
 export async function getAssociatedTokenAddress(
   owner: SvmAddress,
   mint: SvmAddress,
@@ -1048,3 +1074,239 @@ export async function getFillRelayDelegatePda(
 
   return pda;
 }
+
+/**
+ * Checks if a CCTP message has been processed.
+ * @param solanaClient The Solana client.
+ * @param signer The signer of the transaction.
+ * @param nonce The nonce to check.
+ * @param sourceDomain The source domain.
+ * @returns True if the message has been processed, false otherwise.
+ */
+export const hasCCTPV1MessageBeenProcessed = async (
+  solanaClient: SVMProvider,
+  signer: KeyPairSigner,
+  nonce: number,
+  sourceDomain: number
+): Promise<boolean> => {
+  const noncePda = await getCCTPNoncePda(solanaClient, signer, nonce, sourceDomain);
+  const isNonceUsedIx = await MessageTransmitterClient.getIsNonceUsedInstruction({
+    nonce: nonce,
+    usedNonces: noncePda,
+  });
+  const parserFunction = (buf: Buffer): boolean => {
+    if (buf.length != 1) {
+      throw new Error("Invalid buffer length for isNonceUsedIx");
+    }
+    return Boolean(buf[0]);
+  };
+  return await simulateAndDecode(solanaClient, isNonceUsedIx, signer, parserFunction);
+};
+
+/**
+ * Returns the account metas for a tokenless message.
+ * @returns The account metas for a tokenless message.
+ */
+export async function getAccountMetasForTokenlessMessage(): Promise<IAccountMeta<string>[]> {
+  const statePda = await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS);
+  return [
+    { address: statePda, role: AccountRole.READONLY },
+    { address: await getSelfAuthority(), role: AccountRole.READONLY },
+    { address: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+    { address: statePda, role: AccountRole.WRITABLE },
+    { address: await getEventAuthority(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS), role: AccountRole.READONLY },
+    { address: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+  ];
+}
+
+/**
+ * Returns the account metas for a deposit message.
+ * @param message The CCTP message.
+ * @param hubChainId The chain ID of the hub.
+ * @param tokenMessengerMinter The token messenger minter address.
+ * @returns The account metas for a deposit message.
+ */
+async function getAccountMetasForDepositMessage(
+  message: AttestedCCTPMessage,
+  hubChainId: number,
+  tokenMessengerMinter: Address
+): Promise<IAccountMeta<string>[]> {
+  const l1Usdc = EvmAddress.from(TOKEN_SYMBOLS_MAP.USDC.addresses[hubChainId]);
+  const l2Usdc = SvmAddress.from(
+    TOKEN_SYMBOLS_MAP.USDC.addresses[chainIsProd(hubChainId) ? CHAIN_IDs.SOLANA : CHAIN_IDs.SOLANA_DEVNET]
+  );
+
+  const [tokenMessengerPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["token_messenger"],
+  });
+
+  const [tokenMinterPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["token_minter"],
+  });
+
+  const [localTokenPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["local_token", bs58.decode(l2Usdc.toBase58())],
+  });
+
+  const [tokenMessengerEventAuthorityPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["__event_authority"],
+  });
+
+  const [custodyTokenAccountPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["custody", bs58.decode(l2Usdc.toBase58())],
+  });
+
+  const state = await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS);
+  const tokenProgram = TOKEN_PROGRAM_ADDRESS;
+  const vault = await getAssociatedTokenAddress(
+    SvmAddress.from(state),
+    SvmAddress.from(l2Usdc.toBase58()),
+    tokenProgram
+  );
+
+  // Define accounts dependent on deposit information.
+  const [tokenPairPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: [
+      new Uint8Array(Buffer.from("token_pair")),
+      new Uint8Array(Buffer.from(String(message.sourceDomain))),
+      new Uint8Array(Buffer.from(l1Usdc.toBytes32().slice(2), "hex")),
+    ],
+  });
+
+  const [remoteTokenMessengerPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["remote_token_messenger", String(message.sourceDomain)],
+  });
+
+  return [
+    { address: tokenMessengerPda, role: AccountRole.READONLY },
+    { address: remoteTokenMessengerPda, role: AccountRole.READONLY },
+    { address: tokenMinterPda, role: AccountRole.WRITABLE },
+    { address: localTokenPda, role: AccountRole.WRITABLE },
+    { address: tokenPairPda, role: AccountRole.READONLY },
+    { address: vault, role: AccountRole.WRITABLE },
+    { address: custodyTokenAccountPda, role: AccountRole.WRITABLE },
+    { address: TOKEN_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+    { address: tokenMessengerEventAuthorityPda, role: AccountRole.READONLY },
+    { address: tokenMessengerMinter, role: AccountRole.READONLY },
+  ];
+}
+
+/**
+ * Returns the CCTP v1 receive message transaction.
+ * @param solanaClient The Solana client.
+ * @param signer The signer of the transaction.
+ * @param message The CCTP message.
+ * @param hubChainId The chain ID of the hub.
+ * @returns The CCTP v1 receive message transaction.
+ */
+export async function getCCTPV1ReceiveMessageTx(
+  solanaClient: SVMProvider,
+  signer: KeyPairSigner,
+  message: AttestedCCTPMessage,
+  hubChainId: number
+) {
+  const [messageTransmitterPda] = await getProgramDerivedAddress({
+    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    seeds: ["message_transmitter"],
+  });
+
+  const [eventAuthorityPda] = await getProgramDerivedAddress({
+    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    seeds: ["__event_authority"],
+  });
+
+  const cctpMessageReceiver = isDepositForBurnEvent(message)
+    ? TokenMessengerMinterClient.TOKEN_MESSENGER_MINTER_PROGRAM_ADDRESS
+    : SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS;
+
+  const [authorityPda] = await getProgramDerivedAddress({
+    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    seeds: ["message_transmitter_authority", bs58.decode(cctpMessageReceiver)],
+  });
+
+  // Notice: message.nonce is only valid for v1 messages
+  const usedNonces = await getCCTPNoncePda(solanaClient, signer, message.nonce, message.sourceDomain);
+
+  // Notice: for Svm tokenless messages, we currently only support very specific finalizations: Hub -> Spoke relayRootBundle calls
+  const accountMetas: IAccountMeta<string>[] = isDepositForBurnEvent(message)
+    ? await getAccountMetasForDepositMessage(
+        message,
+        hubChainId,
+        TokenMessengerMinterClient.TOKEN_MESSENGER_MINTER_PROGRAM_ADDRESS
+      )
+    : await getAccountMetasForTokenlessMessage();
+
+  const messageBytes = message.messageBytes.startsWith("0x")
+    ? Buffer.from(message.messageBytes.slice(2), "hex")
+    : Buffer.from(message.messageBytes, "hex");
+
+  const input: MessageTransmitterClient.ReceiveMessageInput = {
+    program: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    payer: signer,
+    caller: signer,
+    authorityPda,
+    messageTransmitter: messageTransmitterPda,
+    eventAuthority: eventAuthorityPda,
+    usedNonces,
+    receiver: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS,
+    systemProgram: SYSTEM_PROGRAM_ADDRESS,
+    message: messageBytes,
+    attestation: Buffer.from(message.attestation.slice(2), "hex"),
+  };
+
+  return createReceiveMessageInstruction(signer, solanaClient, input, accountMetas);
+}
+
+/**
+ * Finalizes CCTP deposits and messages on Solana.
+ *
+ * @param solanaClient The Solana client.
+ * @param attestedMessages The CCTP messages to Solana.
+ * @param signer A base signer to be converted into a Solana signer.
+ * @param simulate Whether to simulate the transaction.
+ * @param hubChainId The chain ID of the hub.
+ * @returns A list of executed transaction signatures.
+ */
+
+export function finalizeCCTPV1Messages(
+  solanaClient: SVMProvider,
+  attestedMessages: AttestedCCTPMessage[],
+  signer: KeyPairSigner,
+  simulate = false,
+  hubChainId = 1
+): Promise<string[]> {
+  return mapAsync(attestedMessages, async (message) => {
+    const receiveMessageIx = await getCCTPV1ReceiveMessageTx(solanaClient, signer, message, hubChainId);
+
+    if (simulate) {
+      const result = await solanaClient
+        .simulateTransaction(
+          getBase64EncodedWireTransaction(await signTransactionMessageWithSigners(receiveMessageIx)),
+          {
+            encoding: "base64",
+          }
+        )
+        .send();
+      if (result.value.err) {
+        throw new Error(result.value.err.toString());
+      }
+      return "";
+    }
+
+    const signedTransaction = await signTransactionMessageWithSigners(receiveMessageIx);
+    const signature = getSignatureFromTransaction(signedTransaction);
+    const encodedTransaction = getBase64EncodedWireTransaction(signedTransaction);
+    await solanaClient
+      .sendTransaction(encodedTransaction, { preflightCommitment: "confirmed", encoding: "base64" })
+      .send();
+
+    return signature;
+  });
+}

package/src/arch/svm/types.ts

@@ -61,3 +61,11 @@ export type RpcClient = {
   rpc: SVMProvider;
   rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi>;
 };
+
+export type AttestedCCTPMessage = {
+  nonce: number;
+  sourceDomain: number;
+  messageBytes: string;
+  attestation: string;
+  type: "transfer" | "message";
+};

package/src/arch/svm/utils.ts

@@ -1,24 +1,29 @@
-import bs58 from "bs58";
-import { ethers } from "ethers";
+import { MessageTransmitterClient, SvmSpokeClient } from "@across-protocol/contracts";
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import {
   Address,
+  IInstruction,
+  KeyPairSigner,
   address,
+  appendTransactionMessageInstruction,
+  createTransactionMessage,
   getAddressEncoder,
+  getBase64EncodedWireTransaction,
   getProgramDerivedAddress,
-  getU64Encoder,
   getU32Encoder,
+  getU64Encoder,
   isAddress,
-  type TransactionSigner,
   pipe,
-  createTransactionMessage,
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
+  signTransactionMessageWithSigners,
+  type TransactionSigner,
 } from "@solana/kit";
-import { SvmSpokeClient } from "@across-protocol/contracts";
+import bs58 from "bs58";
+import { ethers } from "ethers";
 import { FillType, RelayData } from "../../interfaces";
-import { BigNumber, getRelayDataHash, isDefined, isUint8Array, Address as SdkAddress } from "../../utils";
-import { EventName, SVMEventNames, SVMProvider } from "./types";
+import { BigNumber, Address as SdkAddress, getRelayDataHash, isDefined, isUint8Array } from "../../utils";
+import { AttestedCCTPMessage, EventName, SVMEventNames, SVMProvider } from "./types";
 
 export { isSolanaError } from "@solana/kit";
 
@@ -334,6 +339,18 @@ export async function getEventAuthority(programId: Address): Promise<Address> {
   return eventAuthority;
 }
 
+/**
+ * Returns the PDA for the Self Authority.
+ * @returns The PDA for the Self Authority.
+ */
+export const getSelfAuthority = async () => {
+  const [selfAuthority] = await getProgramDerivedAddress({
+    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+    seeds: ["self_authority"],
+  });
+  return selfAuthority;
+};
+
 /**
  * Returns a random SVM address.
  */
@@ -358,8 +375,82 @@ export const createDefaultTransaction = async (rpcClient: SVMProvider, signer: T
   );
 };
 
+/**
+ * Simulates a transaction and decodes the result using a parser function.
+ * @param solanaClient - The Solana client.
+ * @param ix - The instruction to simulate.
+ * @param signer - The signer of the transaction.
+ * @param parser - The parser function to decode the result.
+ * @returns The decoded result.
+ */
+export const simulateAndDecode = async <P extends (buf: Buffer) => unknown>(
+  solanaClient: SVMProvider,
+  ix: IInstruction,
+  signer: KeyPairSigner,
+  parser: P
+): Promise<ReturnType<P>> => {
+  const simulationTx = appendTransactionMessageInstruction(ix, await createDefaultTransaction(solanaClient, signer));
+
+  const simulationResult = await solanaClient
+    .simulateTransaction(getBase64EncodedWireTransaction(await signTransactionMessageWithSigners(simulationTx)), {
+      encoding: "base64",
+    })
+    .send();
+
+  if (!simulationResult.value.returnData?.data[0]) {
+    throw new Error("No return data");
+  }
+
+  return parser(Buffer.from(simulationResult.value.returnData.data[0], "base64")) as ReturnType<P>;
+};
+
+/**
+ * Returns the PDA for the CCTP nonce.
+ * @param solanaClient The Solana client.
+ * @param signer The signer of the transaction.
+ * @param nonce The nonce to get the PDA for.
+ * @param sourceDomain The source domain.
+ * @returns The PDA for the CCTP nonce.
+ */
+export const getCCTPNoncePda = async (
+  solanaClient: SVMProvider,
+  signer: KeyPairSigner,
+  nonce: number,
+  sourceDomain: number
+) => {
+  const [messageTransmitterPda] = await getProgramDerivedAddress({
+    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    seeds: ["message_transmitter"],
+  });
+  const getNonceIx = await MessageTransmitterClient.getGetNoncePdaInstruction({
+    messageTransmitter: messageTransmitterPda,
+    nonce,
+    sourceDomain: sourceDomain,
+  });
+
+  const parserFunction = (buf: Buffer): Address => {
+    if (buf.length === 32) {
+      return address(bs58.encode(buf));
+    }
+    throw new Error("Invalid buffer");
+  };
+
+  return await simulateAndDecode(solanaClient, getNonceIx, signer, parserFunction);
+};
+
+/**
+ * Checks if a CCTP message is a deposit for burn event.
+ * @param event The CCTP message event.
+ * @returns True if the message is a deposit for burn event, false otherwise.
+ */
+export function isDepositForBurnEvent(event: AttestedCCTPMessage): boolean {
+  return event.type === "transfer";
+}
+
 /**
  * Convert a bigint (0 ≤ n < 2^256) to a 32-byte Uint8Array (big-endian).
+ * @param n The bigint to convert.
+ * @returns The 32-byte Uint8Array.
  */
 export function bigintToU8a32(n: bigint): Uint8Array {
   if (n < BigInt(0) || n > ethers.constants.MaxUint256.toBigInt()) {

package/src/clients/BundleDataClient/utils/PoolRebalanceUtils.ts

@@ -25,7 +25,8 @@ export async function getWidestPossibleExpectedBlockRange(
   endBlockBuffers: number[],
   clients: Clients,
   latestMainnetBlock: number,
-  enabledChains: number[]
+  enabledChains: number[],
+  optimistic: boolean = false
 ): Promise<number[][]> {
   // We impose a buffer on the head of the chain to increase the probability that the received blocks are final.
   // Reducing the latest block that we query also gives partially filled deposits slightly more buffer for relayers
@@ -85,7 +86,9 @@ export async function getWidestPossibleExpectedBlockRange(
     // Chain has advanced far enough including the buffer, return range from previous proposed end block + 1 to
     // latest block for chain minus buffer.
     return [
-      clients.hubPoolClient.getNextBundleStartBlockNumber(chainIds, latestMainnetBlock, chainId),
+      optimistic
+        ? clients.hubPoolClient.getOptimisticBundleStartBlockNumber(chainIds, latestMainnetBlock, chainId)
+        : clients.hubPoolClient.getNextBundleStartBlockNumber(chainIds, latestMainnetBlock, chainId),
       latestPossibleBundleEndBlockNumbers[index],
     ];
   });

package/src/clients/HubPoolClient.ts

@@ -789,6 +789,29 @@ export class HubPoolClient extends BaseAbstractClient {
     return endBlock > 0 ? endBlock + 1 : 0;
   }
 
+  // @dev Returns the start block of the next bundle assuming that if there is a currently outstanding root bundle proposal, it will pass liveness.
+  getOptimisticBundleStartBlockNumber(chainIdList: number[], latestMainnetBlock: number, chainId: number): number {
+    // If there is no pending root bundle, then return block ranges based on the latest fully executed root bundle.
+    if (!this.hasPendingProposal()) {
+      return this.getNextBundleStartBlockNumber(chainIdList, latestMainnetBlock, chainId);
+    }
+    // We cannot normally index `this.proposedRootBundles` since a bundle there may have been previously disputed, so only index `this.proposedRootBundles`
+    // if we have a pending proposal, since this must mean that the pending root bundle is the most recent proposed root bundle.
+    const latestProposedBundle = this.proposedRootBundles[this.proposedRootBundles.length - 1];
+
+    // If there is no previous root bundle, then return 0.
+    if (!isDefined(latestProposedBundle)) {
+      return 0;
+    }
+
+    // Otherwise, get the bundle end block for the optimistic bundle.
+    const optimisticEndBlock = this.getBundleEndBlockForChain(latestProposedBundle, chainId, chainIdList);
+
+    // As above, this assumes that chain ID's are only added to the chain ID list over time, and that chains are never
+    // deleted.
+    return optimisticEndBlock > 0 ? optimisticEndBlock + 1 : 0;
+  }
+
   getLatestExecutedRootBundleContainingL1Token(
     block: number,
     chain: number,