@across-protocol/sdk 4.4.0-alpha.9 → 4.4.0

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

@@ -1,200 +0,0 @@
-import { Keypair, TransactionInstruction, Transaction, sendAndConfirmTransaction, PublicKey } from "@solana/web3.js";
-import { Program, BN } from "@coral-xyz/anchor";
-import { RelayData, SlowFillLeaf, RelayerRefundLeafSolana } from "../types.svm";
-import { SvmSpokeAnchor as SvmSpoke } from "../assets";
-import { LargeAccountsCoder } from "./coders";
-
-/**
- * Loads execute relayer refund leaf parameters.
- */
-export async function loadExecuteRelayerRefundLeafParams(
-  program: Program<SvmSpoke>,
-  caller: PublicKey,
-  rootBundleId: number,
-  relayerRefundLeaf: RelayerRefundLeafSolana,
-  proof: number[][]
-) {
-  const maxInstructionParamsFragment = 900; // Should not exceed message size limit when writing to the data account.
-
-  // Close the instruction params account if the caller has used it before.
-  const [instructionParams] = PublicKey.findProgramAddressSync(
-    [Buffer.from("instruction_params"), caller.toBuffer()],
-    program.programId
-  );
-  const accountInfo = await program.provider.connection.getAccountInfo(instructionParams);
-  if (accountInfo !== null) await program.methods.closeInstructionParams().rpc();
-
-  const accountCoder = new LargeAccountsCoder(program.idl);
-  const instructionParamsBytes = await accountCoder.encode("executeRelayerRefundLeafParams", {
-    rootBundleId,
-    relayerRefundLeaf,
-    proof,
-  });
-
-  await program.methods.initializeInstructionParams(instructionParamsBytes.length).rpc();
-
-  for (let i = 0; i < instructionParamsBytes.length; i += maxInstructionParamsFragment) {
-    const fragment = instructionParamsBytes.slice(i, i + maxInstructionParamsFragment);
-    await program.methods.writeInstructionParamsFragment(i, fragment).rpc();
-  }
-  return instructionParams;
-}
-
-/**
- * Closes the instruction parameters account.
- */
-export async function closeInstructionParams(program: Program<SvmSpoke>, signer: Keypair) {
-  const [instructionParams] = PublicKey.findProgramAddressSync(
-    [Buffer.from("instruction_params"), signer.publicKey.toBuffer()],
-    program.programId
-  );
-  const accountInfo = await program.provider.connection.getAccountInfo(instructionParams);
-  if (accountInfo !== null) {
-    const closeIx = await program.methods.closeInstructionParams().accounts({ signer: signer.publicKey }).instruction();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await sendAndConfirmTransaction(program.provider.connection as any, new Transaction().add(closeIx), [signer]);
-  }
-}
-
-/**
- * Creates instructions to load fill relay parameters.
- */
-export async function createFillRelayParamsInstructions(
-  program: Program<SvmSpoke>,
-  signer: PublicKey,
-  relayData: RelayData,
-  repaymentChainId: BN,
-  repaymentAddress: PublicKey
-): Promise<{ loadInstructions: TransactionInstruction[]; closeInstruction: TransactionInstruction }> {
-  const maxInstructionParamsFragment = 900; // Should not exceed message size limit when writing to the data account.
-
-  const accountCoder = new LargeAccountsCoder(program.idl);
-  const instructionParamsBytes = await accountCoder.encode("fillRelayParams", {
-    relayData,
-    repaymentChainId,
-    repaymentAddress,
-  });
-
-  const loadInstructions: TransactionInstruction[] = [];
-  loadInstructions.push(
-    await program.methods.initializeInstructionParams(instructionParamsBytes.length).accounts({ signer }).instruction()
-  );
-
-  for (let i = 0; i < instructionParamsBytes.length; i += maxInstructionParamsFragment) {
-    const fragment = instructionParamsBytes.slice(i, i + maxInstructionParamsFragment);
-    loadInstructions.push(
-      await program.methods.writeInstructionParamsFragment(i, fragment).accounts({ signer }).instruction()
-    );
-  }
-
-  const closeInstruction = await program.methods.closeInstructionParams().accounts({ signer }).instruction();
-
-  return { loadInstructions, closeInstruction };
-}
-
-/**
- * Loads fill relay parameters.
- */
-export async function loadFillRelayParams(
-  program: Program<SvmSpoke>,
-  signer: Keypair,
-  relayData: RelayData,
-  repaymentChainId: BN,
-  repaymentAddress: PublicKey
-) {
-  // Close the instruction params account if the caller has used it before.
-  await closeInstructionParams(program, signer);
-
-  // Execute load instructions sequentially.
-  const { loadInstructions } = await createFillRelayParamsInstructions(
-    program,
-    signer.publicKey,
-    relayData,
-    repaymentChainId,
-    repaymentAddress
-  );
-  for (let i = 0; i < loadInstructions.length; i += 1) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await sendAndConfirmTransaction(program.provider.connection as any, new Transaction().add(loadInstructions[i]), [
-      signer,
-    ]);
-  }
-}
-
-/**
- * Loads request slow fill parameters.
- */
-export async function loadRequestSlowFillParams(program: Program<SvmSpoke>, signer: Keypair, relayData: RelayData) {
-  // Close the instruction params account if the caller has used it before.
-  await closeInstructionParams(program, signer);
-
-  // Execute load instructions sequentially.
-  const maxInstructionParamsFragment = 900; // Should not exceed message size limit when writing to the data account.
-
-  const accountCoder = new LargeAccountsCoder(program.idl);
-  const instructionParamsBytes = await accountCoder.encode("requestSlowFillParams", { relayData });
-
-  const loadInstructions: TransactionInstruction[] = [];
-  loadInstructions.push(
-    await program.methods
-      .initializeInstructionParams(instructionParamsBytes.length)
-      .accounts({ signer: signer.publicKey })
-      .instruction()
-  );
-
-  for (let i = 0; i < instructionParamsBytes.length; i += maxInstructionParamsFragment) {
-    const fragment = instructionParamsBytes.slice(i, i + maxInstructionParamsFragment);
-    loadInstructions.push(
-      await program.methods
-        .writeInstructionParamsFragment(i, fragment)
-        .accounts({ signer: signer.publicKey })
-        .instruction()
-    );
-  }
-
-  return loadInstructions;
-}
-
-/**
- * Loads execute slow relay leaf parameters.
- */
-export async function loadExecuteSlowRelayLeafParams(
-  program: Program<SvmSpoke>,
-  signer: Keypair,
-  slowFillLeaf: SlowFillLeaf,
-  rootBundleId: number,
-  proof: number[][]
-) {
-  // Close the instruction params account if the caller has used it before.
-  await closeInstructionParams(program, signer);
-
-  // Execute load instructions sequentially.
-  const maxInstructionParamsFragment = 900; // Should not exceed message size limit when writing to the data account.
-
-  const accountCoder = new LargeAccountsCoder(program.idl);
-  const instructionParamsBytes = await accountCoder.encode("executeSlowRelayLeafParams", {
-    slowFillLeaf,
-    rootBundleId,
-    proof,
-  });
-
-  const loadInstructions: TransactionInstruction[] = [];
-  loadInstructions.push(
-    await program.methods
-      .initializeInstructionParams(instructionParamsBytes.length)
-      .accounts({ signer: signer.publicKey })
-      .instruction()
-  );
-
-  for (let i = 0; i < instructionParamsBytes.length; i += maxInstructionParamsFragment) {
-    const fragment = instructionParamsBytes.slice(i, i + maxInstructionParamsFragment);
-    loadInstructions.push(
-      await program.methods
-        .writeInstructionParamsFragment(i, fragment)
-        .accounts({ signer: signer.publicKey })
-        .instruction()
-    );
-  }
-
-  return loadInstructions;
-}

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

@@ -1,82 +0,0 @@
-import { AnchorProvider, Idl, Program } from "@coral-xyz/anchor";
-import { getDeployedAddress } from "@across-protocol/contracts";
-import { SupportedNetworks } from "../types.svm";
-import {
-  MessageTransmitterAnchor,
-  MessageTransmitterIdl,
-  MulticallHandlerAnchor,
-  MulticallHandlerIdl,
-  SvmSpokeAnchor,
-  SvmSpokeIdl,
-  TokenMessengerMinterAnchor,
-  TokenMessengerMinterIdl,
-  MessageTransmitterV2Anchor,
-  MessageTransmitterV2Idl,
-  TokenMessengerMinterV2Anchor,
-  TokenMessengerMinterV2Idl,
-  SponsoredCctpSrcPeripheryAnchor,
-  SponsoredCctpSrcPeripheryIdl,
-} from "../assets";
-import { getSolanaChainId, isSolanaDevnet } from "./helpers";
-
-type ProgramOptions = { network?: SupportedNetworks; programId?: string };
-
-export function getConnectedProgram<P extends Idl>(idl: P, provider: AnchorProvider, programId: string) {
-  idl.address = programId;
-  return new Program<P>(idl, provider);
-}
-
-// Resolves the program ID from options or defaults to the deployed address. Prioritizes programId, falls back to
-// network, and if network is not defined, determines the network from the provider's RPC URL. Throws an error if
-// the program ID cannot be resolved.
-function resolveProgramId(programName: string, provider: AnchorProvider, options?: ProgramOptions): string {
-  const { network, programId } = options ?? {};
-
-  if (programId) {
-    return programId; // Prioritize explicitly provided programId
-  }
-
-  const resolvedNetwork = network ?? (isSolanaDevnet(provider) ? "devnet" : "mainnet");
-  const deployedAddress = getDeployedAddress(programName, getSolanaChainId(resolvedNetwork).toString());
-
-  if (!deployedAddress) {
-    throw new Error(`${programName} Program ID not found for ${resolvedNetwork}`);
-  }
-
-  return deployedAddress;
-}
-
-export function getSpokePoolProgram(provider: AnchorProvider, options?: ProgramOptions) {
-  const id = resolveProgramId("SvmSpoke", provider, options);
-  return getConnectedProgram<SvmSpokeAnchor>(SvmSpokeIdl, provider, id);
-}
-
-export function getMessageTransmitterProgram(provider: AnchorProvider, options?: ProgramOptions) {
-  const id = resolveProgramId("MessageTransmitter", provider, options);
-  return getConnectedProgram<MessageTransmitterAnchor>(MessageTransmitterIdl, provider, id);
-}
-
-export function getTokenMessengerMinterProgram(provider: AnchorProvider, options?: ProgramOptions) {
-  const id = resolveProgramId("TokenMessengerMinter", provider, options);
-  return getConnectedProgram<TokenMessengerMinterAnchor>(TokenMessengerMinterIdl, provider, id);
-}
-
-export function getMulticallHandlerProgram(provider: AnchorProvider, options?: ProgramOptions) {
-  const id = resolveProgramId("MulticallHandler", provider, options);
-  return getConnectedProgram<MulticallHandlerAnchor>(MulticallHandlerIdl, provider, id);
-}
-
-export function getMessageTransmitterV2Program(provider: AnchorProvider, options?: ProgramOptions) {
-  const id = resolveProgramId("MessageTransmitterV2", provider, options);
-  return getConnectedProgram<MessageTransmitterV2Anchor>(MessageTransmitterV2Idl, provider, id);
-}
-
-export function getTokenMessengerMinterV2Program(provider: AnchorProvider, options?: ProgramOptions) {
-  const id = resolveProgramId("TokenMessengerMinterV2", provider, options);
-  return getConnectedProgram<TokenMessengerMinterV2Anchor>(TokenMessengerMinterV2Idl, provider, id);
-}
-
-export function getSponsoredCctpSrcPeripheryProgram(provider: AnchorProvider, options?: ProgramOptions) {
-  const id = resolveProgramId("SponsoredCctpSrcPeriphery", provider, options);
-  return getConnectedProgram<SponsoredCctpSrcPeripheryAnchor>(SponsoredCctpSrcPeripheryIdl, provider, id);
-}

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

@@ -1,228 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { ethers } from "ethers";
-import { RelayerRefundLeaf, RelayerRefundLeafSolana, SlowFillLeaf } from "../types.svm";
-import { serialize } from "borsh";
-
-/**
- * Calculates the relay hash from relay data and chain ID.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function calculateRelayHashUint8Array(relayData: any, chainId: BN): Uint8Array {
-  const contentToHash = Buffer.concat([
-    relayData.depositor.toBuffer(),
-    relayData.recipient.toBuffer(),
-    relayData.exclusiveRelayer.toBuffer(),
-    relayData.inputToken.toBuffer(),
-    relayData.outputToken.toBuffer(),
-    Buffer.from(relayData.inputAmount),
-    relayData.outputAmount.toArrayLike(Buffer, "le", 8),
-    relayData.originChainId.toArrayLike(Buffer, "le", 8),
-    Buffer.from(relayData.depositId),
-    new BN(relayData.fillDeadline).toArrayLike(Buffer, "le", 4),
-    new BN(relayData.exclusivityDeadline).toArrayLike(Buffer, "le", 4),
-    hashNonEmptyMessage(relayData.message), // Replace with hash of message, so that relay hash can be recovered from event.
-    chainId.toArrayLike(Buffer, "le", 8),
-  ]);
-
-  const relayHash = ethers.utils.keccak256(contentToHash);
-  const relayHashBuffer = Buffer.from(relayHash.slice(2), "hex");
-  return new Uint8Array(relayHashBuffer);
-}
-
-/**
- * Calculates the relay event hash from relay event data and chain ID.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function calculateRelayEventHashUint8Array(relayEventData: any, chainId: BN): Uint8Array {
-  const contentToHash = Buffer.concat([
-    relayEventData.depositor.toBuffer(),
-    relayEventData.recipient.toBuffer(),
-    relayEventData.exclusiveRelayer.toBuffer(),
-    relayEventData.inputToken.toBuffer(),
-    relayEventData.outputToken.toBuffer(),
-    Buffer.from(relayEventData.inputAmount),
-    relayEventData.outputAmount.toArrayLike(Buffer, "le", 8),
-    relayEventData.originChainId.toArrayLike(Buffer, "le", 8),
-    Buffer.from(relayEventData.depositId),
-    new BN(relayEventData.fillDeadline).toArrayLike(Buffer, "le", 4),
-    new BN(relayEventData.exclusivityDeadline).toArrayLike(Buffer, "le", 4),
-    Buffer.from(relayEventData.messageHash), // Renamed to messageHash in the event data.
-    chainId.toArrayLike(Buffer, "le", 8),
-  ]);
-
-  const relayHash = ethers.utils.keccak256(contentToHash);
-  const relayHashBuffer = Buffer.from(relayHash.slice(2), "hex");
-  return new Uint8Array(relayHashBuffer);
-}
-
-/**
- * Reads a 256-bit unsigned integer from a buffer.
- */
-export const readUInt256BE = (buffer: Buffer): bigint => {
-  let result = BigInt(0);
-  for (let i = 0; i < buffer.length; i++) {
-    result = (result << BigInt(8)) + BigInt(buffer[i]);
-  }
-  return result;
-};
-
-/**
- * Hashes a non-empty message using Keccak256.
- */
-export function hashNonEmptyMessage(message: Buffer) {
-  if (message.length > 0) {
-    const hash = ethers.utils.keccak256(message);
-    return Uint8Array.from(Buffer.from(hash.slice(2), "hex"));
-  }
-  // else return zeroed bytes32
-  return new Uint8Array(32);
-}
-
-/**
- * Class for relay data.
- */
-class RelayData {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(properties: any) {
-    Object.assign(this, properties);
-  }
-}
-
-/**
- * Schema for relay data.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const relayDataSchema: any = new Map([
-  [
-    RelayData,
-    {
-      kind: "struct",
-      fields: [
-        ["amountToReturn", "u64"],
-        ["chainId", "u64"],
-        ["refundAmounts", ["u64"]],
-        ["leafId", "u32"],
-        ["mintPublicKey", [32]],
-        ["refundAddresses", [[32]]],
-      ],
-    },
-  ],
-]);
-
-/**
- * Calculates the relayer refund leaf hash for Solana.
- */
-export function calculateRelayerRefundLeafHashUint8Array(relayData: RelayerRefundLeafSolana): string {
-  const refundAddresses = relayData.refundAddresses.map((address) => address.toBuffer());
-
-  const data = new RelayData({
-    amountToReturn: relayData.amountToReturn,
-    chainId: relayData.chainId,
-    refundAmounts: relayData.refundAmounts,
-    leafId: relayData.leafId,
-    mintPublicKey: relayData.mintPublicKey.toBuffer(),
-    refundAddresses: refundAddresses,
-  });
-
-  const serializedData = serialize(relayDataSchema, data);
-
-  // SVM leaves require the first 64 bytes to be 0 to ensure EVM leaves can never be played on SVM and vice versa.
-  const contentToHash = Buffer.concat([Buffer.alloc(64, 0), serializedData]);
-
-  return ethers.utils.keccak256(contentToHash);
-}
-
-/**
- * Hash function for relayer refund leaves.
- */
-export const relayerRefundHashFn = (input: RelayerRefundLeaf | RelayerRefundLeafSolana) => {
-  if (!input.isSolana) {
-    const abiCoder = new ethers.utils.AbiCoder();
-    const encodedData = abiCoder.encode(
-      [
-        "tuple( uint256 amountToReturn, uint256 chainId, uint256[] refundAmounts, uint256 leafId, address l2TokenAddress, address[] refundAddresses)",
-      ],
-      [
-        {
-          leafId: input.leafId,
-          chainId: input.chainId,
-          amountToReturn: input.amountToReturn,
-          l2TokenAddress: (input as RelayerRefundLeaf).l2TokenAddress, // Type assertion
-          refundAddresses: (input as RelayerRefundLeaf).refundAddresses, // Type assertion
-          refundAmounts: (input as RelayerRefundLeaf).refundAmounts, // Type assertion
-        },
-      ]
-    );
-    return ethers.utils.keccak256(encodedData);
-  } else {
-    return calculateRelayerRefundLeafHashUint8Array(input as RelayerRefundLeafSolana);
-  }
-};
-
-/**
- * Class for slow fill data.
- */
-class SlowFillData {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(properties: any) {
-    Object.assign(this, properties);
-  }
-}
-
-/**
- * Schema for slow fill data.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const slowFillDataSchema: any = new Map([
-  [
-    SlowFillData,
-    {
-      kind: "struct",
-      fields: [
-        ["depositor", [32]],
-        ["recipient", [32]],
-        ["exclusiveRelayer", [32]],
-        ["inputToken", [32]],
-        ["outputToken", [32]],
-        ["inputAmount", [32]],
-        ["outputAmount", "u64"],
-        ["originChainId", "u64"],
-        ["depositId", [32]],
-        ["fillDeadline", "u32"],
-        ["exclusivityDeadline", "u32"],
-        ["message", ["u8"]],
-        ["chainId", "u64"],
-        ["updatedOutputAmount", "u64"],
-      ],
-    },
-  ],
-]);
-
-/**
- * Hash function for slow fill leaves.
- */
-export function slowFillHashFn(slowFillLeaf: SlowFillLeaf): string {
-  const data = new SlowFillData({
-    depositor: Uint8Array.from(slowFillLeaf.relayData.depositor.toBuffer()),
-    recipient: Uint8Array.from(slowFillLeaf.relayData.recipient.toBuffer()),
-    exclusiveRelayer: Uint8Array.from(slowFillLeaf.relayData.exclusiveRelayer.toBuffer()),
-    inputToken: Uint8Array.from(slowFillLeaf.relayData.inputToken.toBuffer()),
-    outputToken: Uint8Array.from(slowFillLeaf.relayData.outputToken.toBuffer()),
-    inputAmount: slowFillLeaf.relayData.inputAmount,
-    outputAmount: slowFillLeaf.relayData.outputAmount,
-    originChainId: slowFillLeaf.relayData.originChainId,
-    depositId: Uint8Array.from(Buffer.from(slowFillLeaf.relayData.depositId)),
-    fillDeadline: slowFillLeaf.relayData.fillDeadline,
-    exclusivityDeadline: slowFillLeaf.relayData.exclusivityDeadline,
-    message: Uint8Array.from(slowFillLeaf.relayData.message),
-    chainId: slowFillLeaf.chainId,
-    updatedOutputAmount: slowFillLeaf.updatedOutputAmount,
-  });
-
-  const serializedData = serialize(slowFillDataSchema, data);
-
-  // SVM leaves require the first 64 bytes to be 0 to ensure EVM leaves cannot be played on SVM and vice versa
-  const contentToHash = Buffer.concat([Buffer.alloc(64, 0), serializedData]);
-
-  return ethers.utils.keccak256(contentToHash);
-}