@across-protocol/sdk 4.2.9-alpha.0 → 4.2.9-alpha.2

package/src/relayFeeCalculator/chain-queries/svmQuery.ts

@@ -1,38 +1,34 @@
-import { pipe } from "@solana/functional";
+import { SvmSpokeClient } from "@across-protocol/contracts";
+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, fetchMint } from "@solana-program/token";
+import { getComputeUnitEstimateForTransactionMessageFactory } from "@solana/kit";
+import {
+  SVMProvider,
+  SolanaVoidSigner,
+  createFillInstruction,
+  getAssociatedTokenAddress,
+  getEventAuthority,
+  getFillRelayDelegatePda,
+  getFillStatusPda,
+  getStatePda,
+} from "../../arch/svm";
 import { Coingecko } from "../../coingecko";
-import { SymbolMappingType } from "./";
 import { CHAIN_IDs } from "../../constants";
+import { SvmGasPriceEstimate, getGasPriceEstimate } from "../../gasPriceOracle";
 import { Deposit } from "../../interfaces";
-import { getGasPriceEstimate, SvmGasPriceEstimate } from "../../gasPriceOracle";
 import {
-  BigNumberish,
-  TransactionCostEstimate,
   BigNumber,
+  BigNumberish,
   SvmAddress,
-  toBN,
-  isDefined,
+  TransactionCostEstimate,
+  getRelayDataHash,
   toAddressType,
+  toBN,
+  Address,
 } from "../../utils";
-import { getDefaultSimulatedRelayerAddress, Logger, QueryInterface } from "../relayFeeCalculator";
-import {
-  fillRelayInstruction,
-  createApproveInstruction,
-  createTokenAccountsInstruction,
-  SVMProvider,
-  SolanaVoidSigner,
-  getAssociatedTokenAddress,
-} from "../../arch/svm";
-import {
-  createTransactionMessage,
-  setTransactionMessageFeePayer,
-  setTransactionMessageLifetimeUsingBlockhash,
-  appendTransactionMessageInstructions,
-  getComputeUnitEstimateForTransactionMessageFactory,
-  fetchEncodedAccount,
-  IInstruction,
-} from "@solana/kit";
-import { TOKEN_PROGRAM_ADDRESS, getMintSize, getInitializeMintInstruction, fetchMint } from "@solana-program/token";
-import { getCreateAccountInstruction } from "@solana-program/system";
+import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
+import { SymbolMappingType } from "./";
 
 /**
  * A special QueryBase implementation for SVM used for querying gas costs, token prices, and decimals of various tokens
@@ -70,7 +66,7 @@ export class SvmQuery implements QueryInterface {
   /**
    * Retrieves the current gas costs of performing a fillRelay contract at the referenced SpokePool.
    * @param deposit V3 deposit instance.
-   * @param relayerAddress Relayer address to simulate with.
+   * @param _relayer Relayer address to simulate with.
    * @param options
    * @param options.gasPrice Optional gas price to use for the simulation.
    * @param options.gasUnits Optional gas units to use for the simulation.
@@ -79,7 +75,7 @@ export class SvmQuery implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId)),
+    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -88,7 +84,6 @@ export class SvmQuery implements QueryInterface {
     }> = {}
   ): Promise<TransactionCostEstimate> {
     const relayer = _relayer ? _relayer.forceSvmAddress() : this.simulatedRelayerAddress;
-
     const fillRelayTx = await this.getFillRelayTx(deposit, relayer);
 
     const [computeUnitsConsumed, _gasPriceEstimate] = await Promise.all([
@@ -122,11 +117,10 @@ export class SvmQuery implements QueryInterface {
    */
   async getNativeGasCost(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId))
+    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<BigNumber> {
     const fillRelayTx = await this.getFillRelayTx(deposit, _relayer);
-    const computeUnitsConsumed = toBN(await this.computeUnitEstimator(fillRelayTx));
-    return computeUnitsConsumed;
+    return toBN(await this.computeUnitEstimator(fillRelayTx));
   }
 
   /**
@@ -137,65 +131,67 @@ export class SvmQuery implements QueryInterface {
    */
   async getFillRelayTx(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId))
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
+    repaymentChainId = deposit.destinationChainId,
+    repaymentAddress = toAddressType(
+      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+      deposit.destinationChainId
+    )
   ) {
-    const relayer = isDefined(_relayer) ? _relayer : this.simulatedRelayerAddress;
-    // If the user did not have a token account created on destination, then we need to include this as a gas cost.
-    const mint = deposit.outputToken.forceSvmAddress();
-    const owner = deposit.recipient.forceSvmAddress();
-    const associatedToken = await getAssociatedTokenAddress(owner, mint);
-    const simulatedSigner = SolanaVoidSigner(relayer.toBase58());
-
-    // If the recipient has an associated token account on destination, then skip generating the instruction for creating a new token account.
-    let recipientCreateTokenAccountInstructions: IInstruction[] | undefined = undefined;
-    const [associatedTokenAccountExists, mintInfo] = await Promise.all([
-      (await fetchEncodedAccount(this.provider, associatedToken)).exists,
-      fetchMint(this.provider, mint.toV2Address()),
-    ]);
-    if (!associatedTokenAccountExists) {
-      const space = BigInt(getMintSize());
-      const rent = await this.provider.getMinimumBalanceForRentExemption(space).send();
-      const createAccountIx = getCreateAccountInstruction({
-        payer: simulatedSigner,
-        newAccount: SolanaVoidSigner(mint.toBase58()),
-        lamports: rent,
-        space,
-        programAddress: TOKEN_PROGRAM_ADDRESS,
-      });
-
-      const initializeMintIx = getInitializeMintInstruction({
-        mint: mint.toV2Address(),
-        decimals: mintInfo.data.decimals,
-        mintAuthority: owner.toV2Address(),
-      });
-      recipientCreateTokenAccountInstructions = [createAccountIx, initializeMintIx];
-    }
+    const toSvmAddress = (address: Address) => address.toV2Address();
+    const state = await getStatePda(this.spokePoolAddress.toV2Address());
+    const _relayDataHash = getRelayDataHash(deposit, deposit.destinationChainId);
+    const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
+    const delegate = await getFillRelayDelegatePda(
+      relayDataHash,
+      BigInt(repaymentChainId),
+      repaymentAddress.toV2Address(),
+      this.spokePoolAddress.toV2Address()
+    );
+    const mint = deposit.outputToken;
+    const mintInfo = await fetchMint(this.provider, mint.toV2Address());
+    const recipientAta = await getAssociatedTokenAddress(deposit.recipient, mint, mintInfo.programAddress);
+    const relayerAta = await getAssociatedTokenAddress(relayer, mint, mintInfo.programAddress);
+    const fillStatus = await getFillStatusPda(this.spokePoolAddress.toV2Address(), deposit, deposit.destinationChainId);
+    const eventAuthority = await getEventAuthority(this.spokePoolAddress.toV2Address());
 
-    const [createTokenAccountsIx, approveIx, fillIx] = await Promise.all([
-      createTokenAccountsInstruction(mint, simulatedSigner),
-      createApproveInstruction(
-        mint.forceSvmAddress(),
-        deposit.outputAmount,
-        this.simulatedRelayerAddress,
-        this.spokePoolAddress,
-        mintInfo.data.decimals
-      ),
-      fillRelayInstruction(this.spokePoolAddress, deposit, simulatedSigner, associatedToken),
-    ]);
+    const relayData: SvmSpokeClient.FillRelayInput["relayData"] = {
+      depositor: toSvmAddress(deposit.depositor),
+      recipient: toSvmAddress(deposit.recipient),
+      exclusiveRelayer: toSvmAddress(deposit.exclusiveRelayer),
+      inputToken: toSvmAddress(deposit.inputToken),
+      outputToken: mint.toV2Address(),
+      inputAmount: deposit.inputAmount.toBigInt(),
+      outputAmount: deposit.outputAmount.toBigInt(),
+      originChainId: deposit.originChainId,
+      depositId: new Uint8Array(intToU8Array32(deposit.depositId.toNumber())),
+      fillDeadline: deposit.fillDeadline,
+      exclusivityDeadline: deposit.exclusivityDeadline,
+      message: new Uint8Array(Buffer.from(deposit.message, "hex")),
+    };
 
-    // Get the most recent confirmed blockhash.
-    const recentBlockhash = await this.provider.getLatestBlockhash().send();
-    const fillRelayTx = pipe(
-      createTransactionMessage({ version: 0 }),
-      (tx) => setTransactionMessageFeePayer(relayer.forceSvmAddress().toV2Address(), tx),
-      (tx) => setTransactionMessageLifetimeUsingBlockhash(recentBlockhash.value, tx),
-      (tx) =>
-        isDefined(recipientCreateTokenAccountInstructions)
-          ? appendTransactionMessageInstructions(recipientCreateTokenAccountInstructions, tx)
-          : tx,
-      (tx) => appendTransactionMessageInstructions([createTokenAccountsIx, approveIx, fillIx], tx)
-    );
-    return fillRelayTx;
+    const simulatedSigner = SolanaVoidSigner(relayer.toBase58());
+    const fillInput: SvmSpokeClient.FillRelayInput = {
+      signer: simulatedSigner,
+      state,
+      delegate,
+      mint: mint.toV2Address(),
+      relayerTokenAccount: relayerAta,
+      recipientTokenAccount: recipientAta,
+      fillStatus,
+      tokenProgram: mintInfo.programAddress,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+      systemProgram: SYSTEM_PROGRAM_ADDRESS,
+      eventAuthority: eventAuthority,
+      program: this.spokePoolAddress.toV2Address(),
+      relayHash: relayDataHash,
+      relayData,
+      repaymentChainId: BigInt(repaymentChainId),
+      repaymentAddress: toSvmAddress(repaymentAddress),
+    };
+    // Pass createRecipientAtaIfNeeded =true to the createFillInstruction function to create the recipient token account
+    // if it doesn't exist.
+    return createFillInstruction(simulatedSigner, this.provider, fillInput, mintInfo.data.decimals, true);
   }
 
   /**

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -1,4 +1,5 @@
 import assert from "assert";
+import { Transport } from "viem";
 import {
   DEFAULT_SIMULATED_RELAYER_ADDRESS,
   DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM,
@@ -14,20 +15,19 @@ import {
   fixedPointAdjustment,
   getTokenInfo,
   isDefined,
+  isZeroAddress,
   max,
   min,
   nativeToToken,
   percent,
   toBN,
   toBNWei,
-  isZeroAddress,
   compareAddressesSimple,
   ConvertDecimals,
   chainIsSvm,
   toAddressType,
   Address,
 } from "../utils";
-import { Transport } from "viem";
 
 // This needs to be implemented for every chain and passed into RelayFeeCalculator
 export interface QueryInterface {
@@ -256,7 +256,10 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     outputAmount: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId)),
+    relayerAddress = toAddressType(
+      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+      deposit.destinationChainId
+    ),
     _tokenPrice?: number,
     tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
@@ -495,7 +498,10 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     outputAmount?: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId)),
+    relayerAddress = toAddressType(
+      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+      deposit.destinationChainId
+    ),
     _tokenPrice?: number,
     gasPrice?: BigNumberish,
     gasUnits?: BigNumberish,

package/src/utils/AddressUtils.ts

@@ -2,7 +2,7 @@ import { providers, utils } from "ethers";
 import assert from "assert";
 import bs58 from "bs58";
 import { Address as V2Address } from "@solana/kit";
-import { BigNumber, chainIsEvm } from "./";
+import { BigNumber, chainIsEvm, isDefined } from "./";
 
 /**
  * Checks if a contract is deployed at the given address
@@ -76,22 +76,39 @@ export function isValidEvmAddress(address: string): boolean {
  * Creates the proper address type given the input chain ID corresponding to the address's origin network.
  * @param address Stringified address type to convert. Can be either hex encoded or base58 encoded.
  * @param chainId Network ID corresponding to the input address, used to determine which address type to output.
+ * If no chain ID is specified, then fallback to inference via the structure of the address string.
  * @returns a child `Address` type most fitting for the chain ID.
  * @todo: Change this to `toAddress` once we remove the other `toAddress` function.
  */
-export function toAddressType(address: string): Address | EvmAddress | SvmAddress {
-  try {
-    if (utils.isHexString(address)) {
-      return EvmAddress.from(address);
+export function toAddressType(address: string, chainId?: number): Address | EvmAddress | SvmAddress {
+  const parseAddress = (address: string) => {
+    try {
+      if (utils.isHexString(address)) {
+        return EvmAddress.from(address);
+      }
+      return SvmAddress.from(address);
+    } catch (e) {
+      // If we hit this block, then the validation for one of the child address classes failed. We still may want to keep this address in our state, so
+      // return an unchecked address type.
+      assert(utils.isHexString(address));
+      assert(utils.hexDataLength(address) === 32);
+      return Address.__unsafeConstruct(utils.arrayify(address));
+    }
+  };
+  // If there is no network ID, then infer the address by the string format.
+  const addressType = parseAddress(address);
+  if (!isDefined(chainId)) {
+    return addressType;
+  }
+  // Wrap this in a try/catch in case we are trying to force an invalid EVM address to an EvmAddress type.
+  if (chainIsEvm(chainId)) {
+    try {
+      return addressType.forceEvmAddress();
+    } catch {
+      return addressType;
     }
-    return SvmAddress.from(address);
-  } catch (e) {
-    // If we hit this block, then the validation for one of the child address classes failed. We still may want to keep this address in our state, so
-    // return an unchecked address type.
-    assert(utils.isHexString(address));
-    assert(utils.hexDataLength(address) === 32);
-    return Address.__unsafeConstruct(utils.arrayify(address));
   }
+  return addressType.forceSvmAddress();
 }
 
 // The Address class can contain any address type. It is up to the subclasses to determine how to format the address's internal representation,
@@ -253,7 +270,7 @@ export class Address {
 // Subclass of address which strictly deals with 20-byte addresses. These addresses are guaranteed to be valid EVM addresses, so `toAddress` will always succeed.
 export class EvmAddress extends Address {
   // On construction, validate that the address can indeed be coerced into an EVM address. Throw immediately if it cannot.
-  private constructor(rawAddress: Uint8Array) {
+  constructor(rawAddress: Uint8Array) {
     super(rawAddress);
     const hexString = utils.hexlify(rawAddress);
     if (!this.isValidEvmAddress()) {
@@ -287,7 +304,7 @@ export class EvmAddress extends Address {
 // Subclass of address which strictly deals SVM addresses. These addresses are guaranteed to be valid SVM addresses, so `toBase58` will always produce a valid Solana address.
 export class SvmAddress extends Address {
   // On construction, validate that the address is a point on Curve25519. Throw immediately if it is not.
-  private constructor(rawAddress: Uint8Array) {
+  constructor(rawAddress: Uint8Array) {
     super(rawAddress);
   }
 

package/src/utils/TokenUtils.ts

@@ -14,7 +14,7 @@ type SignerOrProvider = providers.Provider | Signer;
 export async function fetchTokenInfo(address: string, signerOrProvider: SignerOrProvider): Promise<TokenInfo> {
   const token = new Contract(address, ERC20__factory.abi, signerOrProvider);
   const [symbol, decimals] = await Promise.all([token.symbol(), token.decimals()]);
-  return { address: toAddressType(address), symbol, decimals };
+  return { address: toAddressType(address).forceEvmAddress(), symbol, decimals };
 }
 
 export const getL2TokenAddresses = (
@@ -44,7 +44,7 @@ export function resolveSymbolOnChain(chainId: number, symbol: string): TokenInfo
   const { decimals, addresses } = token;
   const address = addresses[chainId];
 
-  return { symbol, decimals, address: toAddressType(address) };
+  return { symbol, decimals, address: toAddressType(address, chainId) };
 }
 
 /**
@@ -128,7 +128,7 @@ export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMappi
     tokenObject = tokenMapping[l1TokenSymbol as keyof typeof tokenMapping];
   }
   return {
-    address: toAddressType(l2TokenAddress),
+    address: toAddressType(l2TokenAddress, chainId),
     symbol: tokenObject.symbol,
     decimals: tokenObject.decimals,
   };