@across-protocol/sdk 4.3.33 → 4.3.34-alpha.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.3.33",
+  "version": "4.3.34-alpha.1",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [

package/src/arch/svm/SpokeUtils.ts

@@ -17,6 +17,7 @@ import {
   Address,
   FetchAccountConfig,
   IAccountMeta,
+  IInstruction,
   KeyPairSigner,
   ReadonlyUint8Array,
   appendTransactionMessageInstruction,
@@ -32,9 +33,11 @@ import {
   signTransactionMessageWithSigners,
   some,
   type TransactionSigner,
+  type WritableAccount,
+  type ReadonlyAccount,
 } from "@solana/kit";
 import assert from "assert";
-import { arrayify, hexZeroPad, hexlify } from "ethers/lib/utils";
+import { arrayify } from "ethers/lib/utils";
 import { Logger } from "winston";
 import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "../../constants";
 import { DepositWithBlock, FillStatus, FillWithBlock, RelayData, RelayExecutionEventInfo } from "../../interfaces";
@@ -66,6 +69,11 @@ import {
   toAddress,
   unwrapEventData,
   getRootBundlePda,
+  getAcrossPlusMessageDecoder,
+  getAccountMeta,
+  toSvmRelayData,
+  getInstructionParamsPda,
+  type AcrossPlusMessage,
 } from "./";
 import { SvmCpiEventsClient } from "./eventsClient";
 import { SVM_BLOCK_NOT_AVAILABLE, SVM_SLOT_SKIPPED, isSolanaError } from "./provider";
@@ -601,6 +609,7 @@ export async function getFillRelayTx(
     getEventAuthority(program),
   ]);
 
+  const message = new Uint8Array(Buffer.from(relayData.message.slice(2), "hex"));
   const svmRelayData: SvmSpokeClient.FillRelayInput["relayData"] = {
     depositor: toAddress(depositor),
     recipient: toAddress(recipient),
@@ -613,9 +622,24 @@ export async function getFillRelayTx(
     depositId: new Uint8Array(intToU8Array32(relayData.depositId.toNumber())),
     fillDeadline: relayData.fillDeadline,
     exclusivityDeadline: relayData.exclusivityDeadline,
-    message: new Uint8Array(Buffer.from(relayData.message, "hex")),
+    message,
   };
 
+  // Add remaining accounts if the relayData has a non-empty message.
+  // @dev ! since in the context of creating a `fillRelayTx`, `relayData` must be defined.
+  const remainingAccounts: (WritableAccount | ReadonlyAccount)[] = [];
+  if (relayData.message !== "0x") {
+    const acrossPlusMessage = deserializeMessage(relayData.message);
+    // The first `remainingAccount` _must_ be the handler address.
+    // https://github.com/across-protocol/contracts/blob/3310f8dc716407a5f97ef5fd2eae63df83251f2f/programs/svm-spoke/src/utils/message_utils.rs#L36.
+    remainingAccounts.push(getAccountMeta(acrossPlusMessage.handler, true));
+    remainingAccounts.push(
+      ...acrossPlusMessage.accounts.map((account, idx) =>
+        getAccountMeta(account, idx < acrossPlusMessage.accounts.length - acrossPlusMessage.read_only_len)
+      )
+    );
+  }
+
   const fillInput: SvmSpokeClient.FillRelayInput = {
     signer: signer,
     state,
@@ -636,7 +660,105 @@ export async function getFillRelayTx(
   };
   // Pass createRecipientAtaIfNeeded =true to the createFillInstruction function to create the recipient token account
   // if it doesn't exist.
-  return createFillInstruction(signer, solanaClient, fillInput, mintInfo.data.decimals, true);
+  return createFillInstruction(
+    signer,
+    solanaClient,
+    fillInput,
+    svmRelayData,
+    mintInfo.data.decimals,
+    true,
+    remainingAccounts
+  );
+}
+
+/**
+ * Creates a fill instruction with an instruction params PDA as the relayData input.
+ * @param spokePoolAddr Address of the spoke pool we're trying to fill through
+ * @param solanaClient RPC client to interact with Solana chain
+ * @param relayData RelayData instance, supplemented with destinationChainId
+ * @param signer signer associated with the relayer creating a Fill. Can be VoidSigner for gas estimation
+ * @param repaymentChainId Chain id where relayer repayment is desired
+ * @param repaymentAddress Address to which repayment will go to on repaymentChainId
+ * @returns FillRelay transaction
+ */
+export async function getIPFillRelayTx(
+  spokePoolAddr: SvmAddress,
+  solanaClient: SVMProvider,
+  relayData: Omit<RelayData, "recipient" | "outputToken"> & {
+    destinationChainId: number;
+    recipient: SvmAddress;
+    outputToken: SvmAddress;
+  },
+  signer: TransactionSigner,
+  repaymentChainId: number,
+  repaymentAddress: SdkAddress
+) {
+  const program = toAddress(spokePoolAddr);
+  const _relayDataHash = getRelayDataHash(relayData, relayData.destinationChainId);
+  const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
+
+  const [state, delegate, instructionParams] = await Promise.all([
+    getStatePda(program),
+    getFillRelayDelegatePda(relayDataHash, BigInt(repaymentChainId), toAddress(repaymentAddress), program),
+    getInstructionParamsPda(program, signer.address),
+  ]);
+
+  const mint = toAddress(relayData.outputToken);
+  const mintInfo = await getMintInfo(solanaClient, mint);
+
+  const [recipientAta, relayerAta, fillStatus, eventAuthority] = await Promise.all([
+    getAssociatedTokenAddress(relayData.recipient, relayData.outputToken, mintInfo.programAddress),
+    getAssociatedTokenAddress(SvmAddress.from(signer.address), relayData.outputToken, mintInfo.programAddress),
+    getFillStatusPda(program, relayData, relayData.destinationChainId),
+    getEventAuthority(program),
+  ]);
+
+  // Add remaining accounts if the relayData has a non-empty message.
+  // @dev ! since in the context of creating a `fillRelayTx`, `relayData` must be defined.
+  const remainingAccounts: (WritableAccount | ReadonlyAccount)[] = [];
+  if (relayData.message !== "0x") {
+    const acrossPlusMessage = deserializeMessage(relayData.message);
+    // The first `remainingAccount` _must_ be the handler address.
+    // https://github.com/across-protocol/contracts/blob/3310f8dc716407a5f97ef5fd2eae63df83251f2f/programs/svm-spoke/src/utils/message_utils.rs#L36.
+    remainingAccounts.push(getAccountMeta(acrossPlusMessage.handler, true));
+    remainingAccounts.push(
+      ...acrossPlusMessage.accounts.map((account, idx) =>
+        getAccountMeta(account, idx < acrossPlusMessage.accounts.length - acrossPlusMessage.read_only_len)
+      )
+    );
+  }
+
+  const fillInput: SvmSpokeClient.FillRelayInput = {
+    signer: signer,
+    state,
+    delegate,
+    mint,
+    relayerTokenAccount: relayerAta,
+    recipientTokenAccount: recipientAta,
+    fillStatus,
+    tokenProgram: mintInfo.programAddress,
+    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    systemProgram: SYSTEM_PROGRAM_ADDRESS,
+    eventAuthority,
+    program,
+    instructionParams,
+    relayHash: relayDataHash,
+    relayData: null,
+    repaymentChainId: null,
+    repaymentAddress: null,
+  };
+
+  // Pass createRecipientAtaIfNeeded =true to the createFillInstruction function to create the recipient token account
+  // if it doesn't exist.
+  return createFillInstruction(
+    signer,
+    solanaClient,
+    fillInput,
+    { outputAmount: relayData.outputAmount.toBigInt(), recipient: toAddress(relayData.recipient) },
+    mintInfo.data.decimals,
+    true,
+    remainingAccounts
+  );
 }
 
 /**
@@ -652,8 +774,10 @@ export const createFillInstruction = async (
   signer: TransactionSigner,
   solanaClient: SVMProvider,
   fillInput: SvmSpokeClient.FillRelayInput,
+  relayData: Pick<SvmSpokeClient.RelayDataArgs, "outputAmount" | "recipient">,
   tokenDecimals: number,
-  createRecipientAtaIfNeeded: boolean = true
+  createRecipientAtaIfNeeded: boolean = true,
+  remainingAccounts: (WritableAccount | ReadonlyAccount)[] = []
 ) => {
   const mintInfo = await getMintInfo(solanaClient, fillInput.mint);
   const approveIx = getApproveCheckedInstruction(
@@ -662,7 +786,7 @@ export const createFillInstruction = async (
       mint: fillInput.mint,
       delegate: fillInput.delegate,
       owner: fillInput.signer,
-      amount: (fillInput.relayData as SvmSpokeClient.RelayDataArgs).outputAmount,
+      amount: relayData.outputAmount,
       decimals: tokenDecimals,
     },
     {
@@ -673,7 +797,7 @@ export const createFillInstruction = async (
   const getCreateAssociatedTokenIdempotentIx = () =>
     getCreateAssociatedTokenIdempotentInstruction({
       payer: signer,
-      owner: (fillInput.relayData as SvmSpokeClient.RelayDataArgs).recipient,
+      owner: relayData.recipient,
       mint: fillInput.mint,
       ata: fillInput.recipientTokenAccount,
       systemProgram: SYSTEM_PROGRAM_ADDRESS,
@@ -682,6 +806,9 @@ export const createFillInstruction = async (
 
   const createFillIx = SvmSpokeClient.getFillRelayInstruction(fillInput);
 
+  // Add remaining accounts.
+  createFillIx.accounts.push(...remainingAccounts);
+
   return pipe(
     await createDefaultTransaction(solanaClient, signer),
     (tx) =>
@@ -691,6 +818,14 @@ export const createFillInstruction = async (
   );
 };
 
+export function deserializeMessage(_message: string): AcrossPlusMessage {
+  const message = new Uint8Array(Buffer.from(_message.slice(2), "hex"));
+  // Add remaining accounts if the relayData has a non-empty message.
+  // @dev ! since in the context of creating a `fillRelayTx`, `relayData` must be defined.
+  const acrossPlusMessageDecoder = getAcrossPlusMessageDecoder();
+  return acrossPlusMessageDecoder.decode(message);
+}
+
 /**
  * Creates a deposit instruction.
  * @param signer - The signer of the transaction.
@@ -882,28 +1017,23 @@ export async function getAssociatedTokenAddress(
 }
 
 export function getRelayDataHash(relayData: RelayData, destinationChainId: number): string {
-  const addressEncoder = getAddressEncoder();
+  assert(relayData.message.startsWith("0x"), "Message must be a hex string");
   const uint64Encoder = getU64Encoder();
-  const uint32Encoder = getU32Encoder();
 
-  assert(relayData.message.startsWith("0x"), "Message must be a hex string");
-  const encodeAddress = (data: SdkAddress) => Uint8Array.from(addressEncoder.encode(toAddress(data)));
+  const svmRelayData = toSvmRelayData(relayData);
+  const relayDataEncoder = SvmSpokeClient.getRelayDataEncoder();
+  const encodedRelayData = relayDataEncoder.encode(svmRelayData);
+  const encodedMessage = Buffer.from(relayData.message.slice(2), "hex");
 
+  // Reformat the encoded relay data the same way it is done in the SvmSpoke:
+  // https://github.com/across-protocol/contracts/blob/3310f8dc716407a5f97ef5fd2eae63df83251f2f/programs/svm-spoke/src/utils/merkle_proof_utils.rs#L5
+  const messageOffset = encodedRelayData.length - 4 - encodedMessage.length;
   const contentToHash = Buffer.concat([
-    encodeAddress(relayData.depositor),
-    encodeAddress(relayData.recipient),
-    encodeAddress(relayData.exclusiveRelayer),
-    encodeAddress(relayData.inputToken),
-    encodeAddress(relayData.outputToken),
-    arrayify(hexZeroPad(hexlify(relayData.inputAmount), 32)),
-    Uint8Array.from(uint64Encoder.encode(BigInt(relayData.outputAmount.toString()))),
-    Uint8Array.from(uint64Encoder.encode(BigInt(relayData.originChainId.toString()))),
-    arrayify(hexZeroPad(hexlify(relayData.depositId), 32)),
-    Uint8Array.from(uint32Encoder.encode(relayData.fillDeadline)),
-    Uint8Array.from(uint32Encoder.encode(relayData.exclusivityDeadline)),
-    hashNonEmptyMessage(Buffer.from(arrayify(relayData.message))),
+    encodedRelayData.slice(0, messageOffset),
+    hashNonEmptyMessage(encodedMessage),
     Uint8Array.from(uint64Encoder.encode(BigInt(destinationChainId))),
   ]);
+
   return keccak256(contentToHash);
 }
 
@@ -991,6 +1121,47 @@ async function fetchBatchFillStatusFromPdaAccounts(
   return fillStatuses;
 }
 
+/**
+ * Returns a set of instructions to execute to fill a relay via instruction params.
+ * @param spokePool The program ID of the Solana spoke pool.
+ * @param relayData The relay data to write to the instruction params PDA.
+ * @param signer The transaction signer and authority of the instruction params PDA.
+ * @param maxWriteSize The maximum fragment size to write to instruction params.
+ */
+export async function getFillRelayViaInstructionParamsInstructions(
+  spokePool: Address<string>,
+  relayData: RelayData,
+  signer: TransactionSigner<string>,
+  maxWriteSize = 450
+): Promise<IInstruction[]> {
+  const instructionParams = await getInstructionParamsPda(spokePool, signer.address);
+
+  const relayDataEncoder = SvmSpokeClient.getRelayDataEncoder();
+  const svmRelayData = toSvmRelayData(relayData);
+  const encodedRelayData = relayDataEncoder.encode(svmRelayData);
+
+  const initInstructionParamsIx = SvmSpokeClient.getInitializeInstructionParamsInstruction({
+    signer,
+    instructionParams,
+    totalSize: encodedRelayData.length,
+  });
+  const instructions: IInstruction[] = [initInstructionParamsIx];
+
+  for (let i = 0; i <= encodedRelayData.length / maxWriteSize; ++i) {
+    const offset = i * maxWriteSize;
+    const offsetEnd = Math.min(offset + maxWriteSize, encodedRelayData.length);
+    const fragment = encodedRelayData.slice(offset, offsetEnd);
+    const writeInstructionParamsIx = SvmSpokeClient.getWriteInstructionParamsFragmentInstruction({
+      signer,
+      instructionParams,
+      offset,
+      fragment,
+    });
+    instructions.push(writeInstructionParamsIx);
+  }
+  return instructions;
+}
+
 /**
  * Returns the delegate PDA for deposit.
  */

package/src/arch/svm/encoders.ts

@@ -0,0 +1,86 @@
+import {
+  AccountRole,
+  addDecoderSizePrefix,
+  addEncoderSizePrefix,
+  getAddressDecoder,
+  getAddressEncoder,
+  getArrayEncoder,
+  getArrayDecoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU8Decoder,
+  getU8Encoder,
+  getU32Decoder,
+  getU32Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  type Address,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
+  type WritableAccount,
+  type ReadonlyAccount,
+} from "@solana/kit";
+
+export type AcrossPlusMessage = {
+  handler: Address;
+  read_only_len: number;
+  value_amount: bigint;
+  accounts: Array<Address>;
+  handler_message: ReadonlyUint8Array;
+};
+
+export type CompiledIx = {
+  program_id_index: number;
+  account_key_indexes: Array<number>;
+  data: ReadonlyUint8Array;
+};
+
+export function getAcrossPlusMessageEncoder(): Encoder<AcrossPlusMessage> {
+  return getStructEncoder([
+    ["handler", getAddressEncoder()],
+    ["read_only_len", getU8Encoder()],
+    ["value_amount", getU64Encoder()],
+    ["accounts", getArrayEncoder(getAddressEncoder())],
+    ["handler_message", addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())],
+  ]);
+}
+
+export function getAcrossPlusMessageDecoder(): Decoder<AcrossPlusMessage> {
+  return getStructDecoder([
+    ["handler", getAddressDecoder()],
+    ["read_only_len", getU8Decoder()],
+    ["value_amount", getU64Decoder()],
+    ["accounts", getArrayDecoder(getAddressDecoder())],
+    ["handler_message", addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())],
+  ]);
+}
+
+export function getHandlerMessageEncoder(): Encoder<Array<CompiledIx>> {
+  return getArrayEncoder(getCompiledIxEncoder());
+}
+
+export function getCompiledIxEncoder(): Encoder<CompiledIx> {
+  return getStructEncoder([
+    ["program_id_index", getU8Encoder()],
+    ["account_key_indexes", getArrayEncoder(getU8Encoder())],
+    ["data", addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())],
+  ]);
+}
+
+export function getCompiledIxDecoder(): Decoder<CompiledIx> {
+  return getStructDecoder([
+    ["program_id_index", getU8Decoder()],
+    ["account_key_indexes", getArrayDecoder(getU8Decoder())],
+    ["data", addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())],
+  ]);
+}
+
+export function getAccountMeta(value: Address, isWritable: boolean): WritableAccount | ReadonlyAccount {
+  return Object.freeze({
+    address: value,
+    role: isWritable ? AccountRole.WRITABLE : AccountRole.READONLY,
+  });
+}

package/src/arch/svm/index.ts

@@ -5,3 +5,4 @@ export * from "./utils";
 export * from "./constants";
 export * from "./BlockUtils";
 export * from "./provider";
+export * from "./encoders";

package/src/arch/svm/utils.ts

@@ -507,6 +507,29 @@ export const getEmergencyDeleteRootBundleRootBundleId = (body: Buffer): number =
   return result.rootBundleId.toNumber();
 };
 
+/**
+ * Converts a common `RelayData` type to an SvmSpokeClient.RelayData` type. This is useful for when we need
+ * to interface directly with the SvmSpoke.
+ * @param relayData The common RelayData TS type.
+ * @returns RelayData which conforms to the typing of the SvmSpoke.
+ */
+export function toSvmRelayData(relayData: RelayData): SvmSpokeClient.RelayData {
+  return {
+    originChainId: BigInt(relayData.originChainId),
+    depositor: address(relayData.depositor.toBase58()),
+    recipient: address(relayData.recipient.toBase58()),
+    depositId: ethers.utils.arrayify(ethers.utils.hexZeroPad(relayData.depositId.toHexString(), 32)),
+    inputToken: address(relayData.inputToken.toBase58()),
+    outputToken: address(relayData.outputToken.toBase58()),
+    inputAmount: ethers.utils.arrayify(ethers.utils.hexZeroPad(relayData.inputAmount.toHexString(), 32)),
+    outputAmount: relayData.outputAmount.toBigInt(),
+    message: Uint8Array.from(Buffer.from(relayData.message.slice(2), "hex")),
+    fillDeadline: relayData.fillDeadline,
+    exclusiveRelayer: address(relayData.exclusiveRelayer.toBase58()),
+    exclusivityDeadline: relayData.exclusivityDeadline,
+  };
+}
+
 /**
  * Convert a bigint (0 ≤ n < 2^256) to a 32-byte Uint8Array (big-endian).
  * @param n The bigint to convert.