@across-protocol/sdk 4.3.32 → 4.3.34-alpha.0

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.

package/src/providers/quicknode.ts

@@ -0,0 +1,26 @@
+import { CHAIN_IDs, PUBLIC_NETWORKS } from "../constants";
+import { RPCTransport } from "./types";
+
+export function getURL(chainId: number, apiKey: string, transport: RPCTransport): string {
+  const envVar = "RPC_PROVIDER_KEY_QUICKNODE_PREFIX";
+  const prefix = process.env[`${envVar}_${chainId}`] ?? process.env[envVar];
+  if (!prefix) {
+    throw new Error(`No API key prefix supplied for QuickNode (${envVar})`);
+  }
+
+  /* Ethereum and Optimism are special snowflakes */
+  if (chainId === CHAIN_IDs.MAINNET) {
+    return `${transport}://${prefix}.quicknode.pro/${apiKey}`;
+  }
+
+  if (chainId === CHAIN_IDs.OPTIMISM) {
+    return `${transport}://${prefix}.optimism.quicknode.pro/${apiKey}`;
+  }
+
+  const chain = PUBLIC_NETWORKS[chainId]?.name.toLowerCase().replace(" ", "-");
+  if (!chain) {
+    throw new Error(`No known QuickNode provider for chainId ${chainId}`);
+  }
+
+  return `${transport}://${prefix}.${chain}.quicknode.pro/${apiKey}`;
+}

package/src/providers/utils.ts

@@ -7,6 +7,7 @@ import { RPCProvider, RPCTransport } from "./types";
 import * as alchemy from "./alchemy";
 import * as infura from "./infura";
 import * as drpc from "./drpc";
+import * as quicknode from "./quicknode";
 
 /**
  * Infura DIN is identified separately to allow it to be configured explicitly.
@@ -16,6 +17,7 @@ const PROVIDERS = {
   INFURA: infura.getURL,
   INFURA_DIN: infura.getURL,
   DRPC: drpc.getURL,
+  QUICKNODE: quicknode.getURL,
 };
 
 /**
@@ -24,7 +26,7 @@ const PROVIDERS = {
  * @returns True if the provider string is a supported provider.
  */
 export function isSupportedProvider(provider: string): provider is RPCProvider {
-  return ["ALCHEMY", "INFURA", "INFURA_DIN", "DRPC"].includes(provider);
+  return Object.keys(PROVIDERS).includes(provider);
 }
 
 /**