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

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

@@ -1,270 +0,0 @@
-import { BorshAccountsCoder } from "@coral-xyz/anchor";
-import { IdlCoder } from "@coral-xyz/anchor/dist/cjs/coder/borsh/idl";
-import { IdlTypeDef } from "@coral-xyz/anchor/dist/cjs/idl";
-import * as borsh from "@coral-xyz/borsh";
-import {
-  CompiledInstruction,
-  Message,
-  MessageAccountKeys,
-  MessageCompiledInstruction,
-  MessageHeader,
-  PublicKey,
-  TransactionInstruction,
-} from "@solana/web3.js";
-import bs58 from "bs58";
-import { Layout } from "buffer-layout";
-import { AcrossPlusMessage } from "../types.svm";
-
-/**
- * Extended Anchor accounts coder to handle large account data.
- */
-export class LargeAccountsCoder<A extends string = string> extends BorshAccountsCoder<A> {
-  // Getter to access the private accountLayouts property from base class.
-  private getAccountLayouts() {
-    // Base class has `Map<A, { discriminator: IdlDiscriminator; layout: Layout }`, but we only use layout here.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (this as any).accountLayouts as Map<A, { layout: Layout }>;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, require-await
-  public async encode<T = any>(accountName: A, account: T): Promise<Buffer> {
-    const buffer = Buffer.alloc(10240); // We don't currently need anything above instruction data account reallocation limit.
-    const layout = this.getAccountLayouts().get(accountName);
-    if (!layout) {
-      throw new Error(`Unknown account: ${accountName}`);
-    }
-    const len = layout.layout.encode(account, buffer);
-    const accountData = buffer.slice(0, len);
-    const discriminator = this.accountDiscriminator(accountName);
-    return Buffer.concat([discriminator, accountData]);
-  }
-}
-
-type KeyModeMap = Map<string, { isWritable: boolean }>;
-
-/**
- * Extended version of legacy CompiledKeys to handle compilation of unsigned transactions. Base implementation is here:
- * https://github.com/solana-labs/solana-web3.js/blob/v1.95.3/src/message/compiled-keys.ts
- */
-class UnsignedCompiledKeys {
-  keyModeMap: KeyModeMap;
-  payer?: PublicKey;
-
-  constructor(keyModeMap: KeyModeMap, payer?: PublicKey) {
-    this.keyModeMap = keyModeMap;
-    this.payer = payer;
-  }
-
-  static compileUnsigned(instructions: TransactionInstruction[], payer?: PublicKey): UnsignedCompiledKeys {
-    const keyModeMap: KeyModeMap = new Map();
-    const getOrInsertDefault = (pubkey: PublicKey): { isWritable: boolean } => {
-      const address = pubkey.toBase58();
-      let keyMode = keyModeMap.get(address);
-      if (keyMode === undefined) {
-        keyMode = {
-          isWritable: false,
-        };
-        keyModeMap.set(address, keyMode);
-      }
-      return keyMode;
-    };
-
-    if (payer !== undefined) {
-      const payerKeyMode = getOrInsertDefault(payer);
-      payerKeyMode.isWritable = true;
-    }
-
-    for (const ix of instructions) {
-      getOrInsertDefault(ix.programId);
-      for (const accountMeta of ix.keys) {
-        const keyMode = getOrInsertDefault(accountMeta.pubkey);
-        keyMode.isWritable ||= accountMeta.isWritable;
-      }
-    }
-
-    return new UnsignedCompiledKeys(keyModeMap, payer);
-  }
-
-  getMessageComponents(): [MessageHeader, PublicKey[]] {
-    const mapEntries = Array.from(this.keyModeMap.entries());
-    if (mapEntries.length > 256) throw new Error("Max static account keys length exceeded");
-
-    const writableNonSigners = mapEntries.filter(([, mode]) => mode.isWritable);
-    const readonlyNonSigners = mapEntries.filter(([, mode]) => !mode.isWritable);
-
-    const header: MessageHeader = {
-      numRequiredSignatures: 0,
-      numReadonlySignedAccounts: 0,
-      numReadonlyUnsignedAccounts: readonlyNonSigners.length,
-    };
-
-    const staticAccountKeys = [
-      ...writableNonSigners.map(([address]) => new PublicKey(address)),
-      ...readonlyNonSigners.map(([address]) => new PublicKey(address)),
-    ];
-
-    return [header, staticAccountKeys];
-  }
-}
-
-/**
- * Extended version of legacy Message to handle compilation of unsigned transactions. Base implementation is here:
- * https://github.com/solana-labs/solana-web3.js/blob/v1.95.3/src/message/legacy.ts
- */
-class UnsignedMessage extends Message {
-  static compileUnsigned(instructions: TransactionInstruction[], payer?: PublicKey): Message {
-    const compiledKeys = UnsignedCompiledKeys.compileUnsigned(instructions, payer);
-    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
-    const accountKeys = new MessageAccountKeys(staticAccountKeys);
-    const compiledInstructions = accountKeys.compileInstructions(instructions).map(
-      (ix: MessageCompiledInstruction): CompiledInstruction => ({
-        programIdIndex: ix.programIdIndex,
-        accounts: ix.accountKeyIndexes,
-        data: bs58.encode(ix.data),
-      })
-    );
-    return new Message({
-      header,
-      accountKeys: staticAccountKeys,
-      recentBlockhash: "", // Not used as we are not signing the transaction.
-      instructions: compiledInstructions,
-    });
-  }
-}
-
-/**
- * Helper to encode MulticallHandler transactions.
- */
-export class MulticallHandlerCoder {
-  readonly compiledMessage: Message;
-
-  private readonly layout: Layout;
-
-  constructor(instructions: TransactionInstruction[], payerKey?: PublicKey) {
-    // Compile transaction message and keys.
-    this.compiledMessage = UnsignedMessage.compileUnsigned(instructions, payerKey);
-
-    // Setup the layout for the encoder.
-    const fieldLayouts = [IdlCoder.fieldLayout(MulticallHandlerCoder.coderArg, MulticallHandlerCoder.coderTypes)];
-    this.layout = borsh.struct(fieldLayouts);
-  }
-
-  private static coderArg = {
-    name: "compiledIxs",
-    type: {
-      vec: {
-        defined: {
-          name: "compiledIx",
-        },
-      },
-    },
-  };
-
-  private static coderTypes: IdlTypeDef[] = [
-    {
-      name: "compiledIx",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "programIdIndex",
-            type: "u8",
-          },
-          {
-            name: "accountKeyIndexes",
-            type: {
-              vec: "u8",
-            },
-          },
-          {
-            name: "data",
-            type: "bytes",
-          },
-        ],
-      },
-    },
-  ];
-
-  get readOnlyLen() {
-    return (
-      this.compiledMessage.header.numReadonlySignedAccounts + this.compiledMessage.header.numReadonlyUnsignedAccounts
-    );
-  }
-
-  get compiledKeyMetas() {
-    return this.compiledMessage.accountKeys.map((key, index) => {
-      return {
-        pubkey: key,
-        isSigner: this.compiledMessage.isAccountSigner(index),
-        isWritable: this.compiledMessage.isAccountWritable(index),
-      };
-    });
-  }
-
-  encode() {
-    const buffer = Buffer.alloc(1280);
-    const len = this.layout.encode({ compiledIxs: this.compiledMessage.compiledInstructions }, buffer);
-    return buffer.slice(0, len);
-  }
-}
-
-/**
- * Helper to encode Across+ messages.
- */
-export class AcrossPlusMessageCoder {
-  private acrossPlusMessage: AcrossPlusMessage;
-
-  constructor(acrossPlusMessage: AcrossPlusMessage) {
-    this.acrossPlusMessage = acrossPlusMessage;
-  }
-
-  private static coderArg = {
-    name: "message",
-    type: {
-      defined: {
-        name: "acrossPlusMessage",
-      },
-    },
-  };
-
-  private static coderTypes: IdlTypeDef[] = [
-    {
-      name: "acrossPlusMessage",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "handler",
-            type: "pubkey",
-          },
-          {
-            name: "readOnlyLen",
-            type: "u8",
-          },
-          {
-            name: "valueAmount",
-            type: "u64",
-          },
-          {
-            name: "accounts",
-            type: {
-              vec: "pubkey",
-            },
-          },
-          {
-            name: "handlerMessage",
-            type: "bytes",
-          },
-        ],
-      },
-    },
-  ];
-
-  encode() {
-    const fieldLayouts = [IdlCoder.fieldLayout(AcrossPlusMessageCoder.coderArg, AcrossPlusMessageCoder.coderTypes)];
-    const layout = borsh.struct(fieldLayouts);
-    const buffer = Buffer.alloc(12800);
-    const len = layout.encode({ message: this.acrossPlusMessage }, buffer);
-    return buffer.slice(0, len);
-  }
-}

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

@@ -1,9 +0,0 @@
-import BN from "bn.js";
-
-export const CIRCLE_IRIS_API_URL_DEVNET = "https://iris-api-sandbox.circle.com";
-export const CIRCLE_IRIS_API_URL_MAINNET = "https://iris-api.circle.com";
-export const SOLANA_USDC_MAINNET = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
-export const SOLANA_USDC_DEVNET = "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU";
-export const SEPOLIA_CCTP_MESSAGE_TRANSMITTER_ADDRESS = "0x7865fAfC2db2093669d92c0F33AeEF291086BEFD";
-export const MAINNET_CCTP_MESSAGE_TRANSMITTER_ADDRESS = "0x0a992d191deec32afe36203ad87d7d289a738f81";
-export const SOLANA_SPOKE_STATE_SEED = new BN(0);

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

@@ -1,109 +0,0 @@
-import { utils as anchorUtils, BN } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { BigNumber, ethers } from "ethers";
-
-/**
- * Converts an integer to a 32-byte Uint8Array.
- */
-export function intToU8Array32(num: number | BN): number[] {
-  const bigIntValue = BigInt(num instanceof BN ? num.toString() : num);
-  if (bigIntValue < 0) throw new Error("Input must be a non-negative integer or BN");
-
-  const hexString = bigIntValue.toString(16).padStart(64, "0"); // 32 bytes = 64 hex chars
-  const u8Array = Array.from(Buffer.from(hexString, "hex"));
-
-  return u8Array;
-}
-
-/**
- * Converts a 32-byte Uint8Array to a bigint.
- */
-export function u8Array32ToInt(u8Array: Uint8Array | number[]): bigint {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const isValidArray = (arr: any): arr is number[] => Array.isArray(arr) && arr.every(Number.isInteger);
-
-  if ((u8Array instanceof Uint8Array || isValidArray(u8Array)) && u8Array.length === 32) {
-    return Array.from(u8Array).reduce<bigint>((num, byte) => (num << BigInt(8)) | BigInt(byte), BigInt(0));
-  }
-
-  throw new Error("Input must be a Uint8Array or an array of 32 numbers.");
-}
-
-/**
- * Converts a 32-byte Uint8Array to a BigNumber.
- */
-export function u8Array32ToBigNumber(u8Array: Uint8Array | number[]): BigNumber {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const isValidArray = (arr: any): arr is number[] => Array.isArray(arr) && arr.every(Number.isInteger);
-  if ((u8Array instanceof Uint8Array || isValidArray(u8Array)) && u8Array.length === 32) {
-    const hexString = "0x" + Buffer.from(u8Array).toString("hex");
-    return BigNumber.from(hexString);
-  }
-
-  throw new Error("Input must be a Uint8Array or an array of 32 numbers.");
-}
-
-/**
- * Converts a string to a PublicKey.
- */
-export function strPublicKey(publicKey: PublicKey): string {
-  return new PublicKey(publicKey).toString();
-}
-
-/**
- * Converts an EVM address to a Solana PublicKey.
- */
-export const evmAddressToPublicKey = (address: string): PublicKey => {
-  const bytes32Address = `0x000000000000000000000000${address.replace("0x", "")}`;
-  return new PublicKey(ethers.utils.arrayify(bytes32Address));
-};
-
-/**
- * Converts a Solana PublicKey to an EVM address.
- */
-export const publicKeyToEvmAddress = (publicKey: PublicKey | string): string => {
-  // Convert the input to a PublicKey if it's a string
-  const pubKeyBuffer = typeof publicKey === "string" ? new PublicKey(publicKey).toBuffer() : publicKey.toBuffer();
-
-  // Extract the last 20 bytes to get the Ethereum address
-  const addressBuffer = pubKeyBuffer.slice(-20);
-
-  // Convert the buffer to a hex string and prepend '0x'
-  return `0x${addressBuffer.toString("hex")}`;
-};
-
-/**
- * Converts a base58 string to a bytes32 string.
- */
-export const fromBase58ToBytes32 = (input: string): string => {
-  const decodedBytes = anchorUtils.bytes.bs58.decode(input);
-  return "0x" + Buffer.from(decodedBytes).toString("hex");
-};
-
-/**
- * Converts a bytes32 string to an EVM address.
- */
-export const fromBytes32ToAddress = (input: string): string => {
-  const hexString = input.startsWith("0x") ? input.slice(2) : input;
-
-  if (hexString.length !== 64) {
-    throw new Error("Invalid bytes32 string");
-  }
-
-  const address = hexString.slice(-40);
-
-  return "0x" + address;
-};
-
-/**
- * Converts EVM or SVM address to a bytes32 string.
- */
-export const addressOrBase58ToBytes32 = (input: string): string => {
-  if (ethers.utils.isAddress(input)) {
-    return ethers.utils.hexZeroPad(input, 32);
-  } else if (ethers.utils.isHexString(input, 32)) {
-    return input;
-  } else {
-    return fromBase58ToBytes32(input);
-  }
-};

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

@@ -1,303 +0,0 @@
-import { AnchorProvider, BN } from "@coral-xyz/anchor";
-import { BigNumber, ethers } from "ethers";
-import { PublicKey } from "@solana/web3.js";
-import { serialize } from "borsh";
-import { keccak256 } from "ethers/lib/utils";
-
-/**
- * Returns the chainId for a given solana cluster.
- */
-export const getSolanaChainId = (cluster: "devnet" | "mainnet"): BigNumber => {
-  return BigNumber.from(
-    BigInt(ethers.utils.keccak256(ethers.utils.toUtf8Bytes(`solana-${cluster}`))) & BigInt("0xFFFFFFFFFFFF")
-  );
-};
-
-/**
- * Returns true if the provider is on the devnet cluster.
- */
-export const isSolanaDevnet = (provider: AnchorProvider): boolean => {
-  const solanaRpcEndpoint = provider.connection.rpcEndpoint;
-  if (solanaRpcEndpoint.includes("devnet")) return true;
-  else if (solanaRpcEndpoint.includes("mainnet")) return false;
-  else throw new Error(`Unsupported solanaCluster endpoint: ${solanaRpcEndpoint}`);
-};
-
-/**
- * Generic helper: serialize + keccak256 → 32‑byte Uint8Array
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function deriveSeedHash<T>(schema: any, seedObj: T): Uint8Array {
-  const serialized = serialize(schema, seedObj);
-  const hashHex = keccak256(serialized);
-  return Buffer.from(hashHex.slice(2), "hex");
-}
-
-/**
- * “Absolute‐deadline” deposit data
- */
-export class DepositSeedData {
-  depositor!: Uint8Array;
-  recipient!: Uint8Array;
-  inputToken!: Uint8Array;
-  outputToken!: Uint8Array;
-  inputAmount!: BN;
-  outputAmount!: number[];
-  destinationChainId!: BN;
-  exclusiveRelayer!: Uint8Array;
-  quoteTimestamp!: BN;
-  fillDeadline!: BN;
-  exclusivityParameter!: BN;
-  message!: Uint8Array;
-
-  constructor(fields: {
-    depositor: Uint8Array;
-    recipient: Uint8Array;
-    inputToken: Uint8Array;
-    outputToken: Uint8Array;
-    inputAmount: BN;
-    outputAmount: number[];
-    destinationChainId: BN;
-    exclusiveRelayer: Uint8Array;
-    quoteTimestamp: BN;
-    fillDeadline: BN;
-    exclusivityParameter: BN;
-    message: Uint8Array;
-  }) {
-    Object.assign(this, fields);
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const depositSeedSchema: any = new Map([
-  [
-    DepositSeedData,
-    {
-      kind: "struct",
-      fields: [
-        ["depositor", [32]],
-        ["recipient", [32]],
-        ["inputToken", [32]],
-        ["outputToken", [32]],
-        ["inputAmount", "u64"],
-        ["outputAmount", [32]],
-        ["destinationChainId", "u64"],
-        ["exclusiveRelayer", [32]],
-        ["quoteTimestamp", "u32"],
-        ["fillDeadline", "u32"],
-        ["exclusivityParameter", "u32"],
-        ["message", ["u8"]],
-      ],
-    },
-  ],
-]);
-
-/**
- * Hash for the standard `deposit(...)` flow
- */
-export function getDepositSeedHash(depositData: {
-  depositor: PublicKey;
-  recipient: PublicKey;
-  inputToken: PublicKey;
-  outputToken: PublicKey;
-  inputAmount: BN;
-  outputAmount: number[];
-  destinationChainId: BN;
-  exclusiveRelayer: PublicKey;
-  quoteTimestamp: BN;
-  fillDeadline: BN;
-  exclusivityParameter: BN;
-  message: Uint8Array;
-}): Uint8Array {
-  const ds = new DepositSeedData({
-    depositor: depositData.depositor.toBuffer(),
-    recipient: depositData.recipient.toBuffer(),
-    inputToken: depositData.inputToken.toBuffer(),
-    outputToken: depositData.outputToken.toBuffer(),
-    inputAmount: depositData.inputAmount,
-    outputAmount: depositData.outputAmount,
-    destinationChainId: depositData.destinationChainId,
-    exclusiveRelayer: depositData.exclusiveRelayer.toBuffer(),
-    quoteTimestamp: depositData.quoteTimestamp,
-    fillDeadline: depositData.fillDeadline,
-    exclusivityParameter: depositData.exclusivityParameter,
-    message: depositData.message,
-  });
-
-  return deriveSeedHash(depositSeedSchema, ds);
-}
-
-/**
- * Returns the delegate PDA for `deposit(...)`
- */
-export function getDepositPda(depositData: Parameters<typeof getDepositSeedHash>[0], programId: PublicKey): PublicKey {
-  const seedHash = getDepositSeedHash(depositData);
-  const [pda] = PublicKey.findProgramAddressSync([Buffer.from("delegate"), seedHash], programId);
-  return pda;
-}
-
-/**
- * “Offset/now” deposit data
- */
-export class DepositNowSeedData {
-  depositor!: Uint8Array;
-  recipient!: Uint8Array;
-  inputToken!: Uint8Array;
-  outputToken!: Uint8Array;
-  inputAmount!: BN;
-  outputAmount!: number[];
-  destinationChainId!: BN;
-  exclusiveRelayer!: Uint8Array;
-  fillDeadlineOffset!: BN;
-  exclusivityPeriod!: BN;
-  message!: Uint8Array;
-
-  constructor(fields: {
-    depositor: Uint8Array;
-    recipient: Uint8Array;
-    inputToken: Uint8Array;
-    outputToken: Uint8Array;
-    inputAmount: BN;
-    outputAmount: number[];
-    destinationChainId: BN;
-    exclusiveRelayer: Uint8Array;
-    fillDeadlineOffset: BN;
-    exclusivityPeriod: BN;
-    message: Uint8Array;
-  }) {
-    Object.assign(this, fields);
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const depositNowSeedSchema: any = new Map([
-  [
-    DepositNowSeedData,
-    {
-      kind: "struct",
-      fields: [
-        ["depositor", [32]],
-        ["recipient", [32]],
-        ["inputToken", [32]],
-        ["outputToken", [32]],
-        ["inputAmount", "u64"],
-        ["outputAmount", [32]],
-        ["destinationChainId", "u64"],
-        ["exclusiveRelayer", [32]],
-        ["fillDeadlineOffset", "u32"],
-        ["exclusivityPeriod", "u32"],
-        ["message", ["u8"]],
-      ],
-    },
-  ],
-]);
-
-/**
- * Hash for the `deposit_now(...)` flow
- */
-export function getDepositNowSeedHash(depositData: {
-  depositor: PublicKey;
-  recipient: PublicKey;
-  inputToken: PublicKey;
-  outputToken: PublicKey;
-  inputAmount: BN;
-  outputAmount: number[];
-  destinationChainId: BN;
-  exclusiveRelayer: PublicKey;
-  fillDeadlineOffset: BN;
-  exclusivityPeriod: BN;
-  message: Uint8Array;
-}): Uint8Array {
-  const dns = new DepositNowSeedData({
-    depositor: depositData.depositor.toBuffer(),
-    recipient: depositData.recipient.toBuffer(),
-    inputToken: depositData.inputToken.toBuffer(),
-    outputToken: depositData.outputToken.toBuffer(),
-    inputAmount: depositData.inputAmount,
-    outputAmount: depositData.outputAmount,
-    destinationChainId: depositData.destinationChainId,
-    exclusiveRelayer: depositData.exclusiveRelayer.toBuffer(),
-    fillDeadlineOffset: depositData.fillDeadlineOffset,
-    exclusivityPeriod: depositData.exclusivityPeriod,
-    message: depositData.message,
-  });
-
-  return deriveSeedHash(depositNowSeedSchema, dns);
-}
-
-/**
- * Returns the delegate PDA for `deposit_now(...)`
- */
-export function getDepositNowPda(
-  depositData: Parameters<typeof getDepositNowSeedHash>[0],
-  programId: PublicKey
-): PublicKey {
-  const seedHash = getDepositNowSeedHash(depositData);
-  const [pda] = PublicKey.findProgramAddressSync([Buffer.from("delegate"), seedHash], programId);
-  return pda;
-}
-
-/**
- * Fill Delegate Seed Data
- */
-class FillDelegateSeedData {
-  relayHash: Uint8Array;
-  repaymentChainId: BN;
-  repaymentAddress: Uint8Array;
-  constructor(fields: { relayHash: Uint8Array; repaymentChainId: BN; repaymentAddress: Uint8Array }) {
-    this.relayHash = fields.relayHash;
-    this.repaymentChainId = fields.repaymentChainId;
-    this.repaymentAddress = fields.repaymentAddress;
-  }
-}
-
-/**
- * Borsh schema for FillDelegateSeedData
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const fillDelegateSeedSchema = new Map<any, any>([
-  [
-    FillDelegateSeedData,
-    {
-      kind: "struct",
-      fields: [
-        ["relayHash", [32]],
-        ["repaymentChainId", "u64"],
-        ["repaymentAddress", [32]],
-      ],
-    },
-  ],
-]);
-
-/**
- * Returns the fill delegate seed hash.
- */
-
-export function getFillRelayDelegateSeedHash(
-  relayHash: Uint8Array,
-  repaymentChainId: BN,
-  repaymentAddress: PublicKey
-): Uint8Array {
-  const ds = new FillDelegateSeedData({
-    relayHash,
-    repaymentChainId,
-    repaymentAddress: repaymentAddress.toBuffer(),
-  });
-
-  return deriveSeedHash(fillDelegateSeedSchema, ds);
-}
-
-/**
- * Returns the fill delegate PDA.
- */
-export function getFillRelayDelegatePda(
-  relayHash: Uint8Array,
-  repaymentChainId: BN,
-  repaymentAddress: PublicKey,
-  programId: PublicKey
-): { seedHash: Uint8Array; pda: PublicKey } {
-  const seedHash = getFillRelayDelegateSeedHash(relayHash, repaymentChainId, repaymentAddress);
-  const [pda] = PublicKey.findProgramAddressSync([Buffer.from("delegate"), seedHash], programId);
-
-  return { seedHash, pda };
-}

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

@@ -1,11 +0,0 @@
-export * from "./relayHashUtils";
-export * from "./instructionParamsUtils";
-export * from "./conversionUtils";
-export * from "./transactionUtils";
-export * from "./solanaProgramUtils";
-export * from "./coders";
-export * from "./programConnectors";
-export * from "./constants";
-export * from "./helpers";
-export * from "./cctpHelpers";
-export * from "./cctpV2Helpers";