epic: Solana v1

.storybook/preview.tsx

@@ -2,16 +2,13 @@ import { Preview } from "@storybook/react";
 import { MemoryRouter } from "react-router-dom";
 
 import { default as GlobalStyles } from "../src/components/GlobalStyles/GlobalStyles";
-import { OnboardContext, useOnboardManager } from "../src/hooks/useOnboard";
 
 const preview: Preview = {
   decorators: [
     (Story) => (
       <MemoryRouter initialEntries={["/"]}>
         <GlobalStyles />
-        <OnboardContext.Provider value={useOnboardManager()}>
-          <Story />
-        </OnboardContext.Provider>
+        <Story />
       </MemoryRouter>
     ),
   ],

api/_address.ts

@@ -1,5 +1,45 @@
-import { isAddress as isEvmAddress } from "viem";
-import { isAddress as isSvmAddress } from "@solana/kit";
+import { Address, Hex, padHex, toBytes, toHex, trim } from "viem";
+import {
+  getAddressDecoder,
+  getAddressEncoder,
+  isAddress as isSvmAddress,
+} from "@solana/kit";
+import { isAddress } from "ethers/lib/utils";
 
 // exports
-export { isSvmAddress, isEvmAddress };
+export { isSvmAddress };
+
+// utils
+export function isEvmAddress(value: string): value is Address {
+  return isAddress(value);
+}
+
+export function svmToHex(pubkey: string): Hex {
+  if (!isSvmAddress(pubkey)) {
+    throw new Error("Invalid SVM Address");
+  }
+  const bytes = getAddressEncoder().encode(pubkey);
+  return toHex(new Uint8Array(bytes));
+}
+
+export function hexToBase58(address: Address) {
+  if (!isEvmAddress(address)) {
+    throw new Error("Invalid EVM Address");
+  }
+  const bytes = trim(toBytes(address));
+  return getAddressDecoder().decode(bytes);
+}
+
+export function toBytes32(value: string) {
+  if (isSvmAddress(value)) {
+    // byte length already checked at this stage
+    return svmToHex(value);
+  }
+  if (isEvmAddress(value)) {
+    return padHex(value, {
+      size: 32,
+      dir: "left",
+    });
+  }
+  throw new Error("Invalid Address type. Must be valid EVM or SVM address");
+}

api/_balance.ts

@@ -0,0 +1,196 @@
+import { BigNumber, providers } from "ethers";
+import * as sdk from "@across-protocol/sdk";
+import { ERC20__factory } from "@across-protocol/contracts/dist/typechain";
+
+import { getSvmProvider, getProvider } from "./_providers";
+import { BLOCK_TAG_LAG } from "./_constants";
+import { getMulticall3, callViaMulticall3 } from "./_multicall";
+
+/**
+ * Resolves the balance of a given token at a provided address.
+ * @param chainId The chain Id to query against
+ * @param account A valid Web3 wallet address
+ * @param token The valid token address on the given `chainId`.
+ * @returns A promise that resolves to the BigNumber of the balance
+ */
+export async function getBalance(
+  chainId: string | number,
+  account: string,
+  token: string,
+  blockTag?: string | number
+): Promise<BigNumber> {
+  if (sdk.utils.chainIsSvm(Number(chainId))) {
+    return getSvmBalance(chainId, account, token);
+  }
+  return sdk.utils.getTokenBalance(
+    account,
+    token,
+    getProvider(Number(chainId)),
+    blockTag ?? BLOCK_TAG_LAG
+  );
+}
+
+async function getSvmBalance(
+  chainId: string | number,
+  account: string,
+  token: string
+) {
+  const tokenMint = sdk.utils.toAddressType(token);
+  const owner = sdk.utils.toAddressType(account);
+  const svmProvider = getSvmProvider(Number(chainId)).createRpcClient();
+
+  if (tokenMint.isZeroAddress()) {
+    const address = owner.forceSvmAddress().toV2Address();
+    const balance = await svmProvider.getBalance(address).send();
+    return BigNumber.from(balance.value);
+  }
+
+  // Get the associated token account address
+  const tokenAccount = await sdk.arch.svm.getAssociatedTokenAddress(
+    owner.forceSvmAddress(),
+    tokenMint.forceSvmAddress()
+  );
+
+  let balance: BigNumber;
+  try {
+    // Get token account info
+    const tokenAccountInfo = await svmProvider
+      .getTokenAccountBalance(tokenAccount)
+      .send();
+    balance = BigNumber.from(tokenAccountInfo.value.amount);
+  } catch (error) {
+    // If token account doesn't exist or other error, return 0 balance
+    balance = BigNumber.from(0);
+  }
+  return balance;
+}
+
+export async function getBatchBalance(
+  chainId: string | number,
+  addresses: string[],
+  tokenAddresses: string[],
+  blockTag: providers.BlockTag = "latest"
+) {
+  if (sdk.utils.chainIsSvm(Number(chainId))) {
+    return getBatchSvmBalance(chainId, addresses, tokenAddresses);
+  }
+  return getBatchBalanceViaMulticall3(
+    chainId,
+    addresses,
+    tokenAddresses,
+    blockTag
+  );
+}
+
+/**
+ * Fetches the balances for an array of addresses on a particular chain, for a particular erc20 token
+ * @param chainId The blockchain Id to query against
+ * @param addresses An array of valid Web3 wallet addresses
+ * @param tokenAddress The valid ERC20 token address on the given `chainId` or ZERO_ADDRESS for native balances
+ * @param blockTag Block to query from, defaults to latest block
+ * @returns a Promise that resolves to an array of BigNumbers
+ */
+export async function getBatchBalanceViaMulticall3(
+  chainId: string | number,
+  addresses: string[],
+  tokenAddresses: string[],
+  blockTag: providers.BlockTag = "latest"
+): Promise<{
+  blockNumber: providers.BlockTag;
+  balances: Record<string, Record<string, string>>;
+}> {
+  const chainIdAsInt = Number(chainId);
+  const provider = getProvider(chainIdAsInt);
+
+  const multicall3 = getMulticall3(chainIdAsInt, provider);
+
+  if (!multicall3) {
+    throw new Error("No Multicall3 deployed on this chain");
+  }
+
+  let calls: Parameters<typeof callViaMulticall3>[1] = [];
+
+  for (const tokenAddress of tokenAddresses) {
+    if (tokenAddress === sdk.constants.ZERO_ADDRESS) {
+      // For native currency
+      calls.push(
+        ...addresses.map((address) => ({
+          contract: multicall3,
+          functionName: "getEthBalance",
+          args: [address],
+        }))
+      );
+    } else {
+      // For ERC20 tokens
+      const erc20Contract = ERC20__factory.connect(tokenAddress, provider);
+      calls.push(
+        ...addresses.map((address) => ({
+          contract: erc20Contract,
+          functionName: "balanceOf",
+          args: [address],
+        }))
+      );
+    }
+  }
+
+  const inputs = calls.map(({ contract, functionName, args }) => ({
+    target: contract.address,
+    callData: contract.interface.encodeFunctionData(functionName, args),
+  }));
+
+  const [blockNumber, results] = await multicall3.callStatic.aggregate(inputs, {
+    blockTag,
+  });
+
+  const decodedResults = results.map((result, i) =>
+    calls[i].contract.interface.decodeFunctionResult(
+      calls[i].functionName,
+      result
+    )
+  );
+
+  let balances: Record<string, Record<string, string>> = {};
+
+  let resultIndex = 0;
+  for (const tokenAddress of tokenAddresses) {
+    addresses.forEach((address) => {
+      if (!balances[address]) {
+        balances[address] = {};
+      }
+      balances[address][tokenAddress] = decodedResults[resultIndex].toString();
+      resultIndex++;
+    });
+  }
+
+  return {
+    blockNumber: blockNumber.toNumber(),
+    balances,
+  };
+}
+
+export async function getBatchSvmBalance(
+  chainId: string | number,
+  addresses: string[],
+  tokenAddresses: string[],
+  blockTag: providers.BlockTag = "latest"
+) {
+  const balances: Record<string, Record<string, string>> = {};
+
+  for (const tokenAddress of tokenAddresses) {
+    const callsPerAddress = addresses.map((address) =>
+      getSvmBalance(chainId, address, tokenAddress)
+    );
+    const results = await Promise.all(callsPerAddress);
+    for (const [index, result] of Object.entries(results)) {
+      const address = addresses[Number(index)];
+      if (!balances[address]) {
+        balances[address] = {};
+      }
+      balances[address][tokenAddress] = result.toString();
+    }
+  }
+  return {
+    blockNumber: blockTag,
+    balances,
+  };
+}

api/_constants.ts

@@ -293,6 +293,8 @@ export const CG_CONTRACTS_DEFERRED_TO_ID = new Set([
   TOKEN_SYMBOLS_MAP.GHO.addresses[CHAIN_IDs.MAINNET],
   ...Object.values(TOKEN_SYMBOLS_MAP["TATARA-USDC"].addresses),
   TOKEN_SYMBOLS_MAP.BNB.addresses[CHAIN_IDs.MAINNET],
+  TOKEN_SYMBOLS_MAP.SOL.addresses[CHAIN_IDs.SOLANA],
+  TOKEN_SYMBOLS_MAP.SOL.addresses[CHAIN_IDs.SOLANA_DEVNET],
   TOKEN_SYMBOLS_MAP.VLR.addresses[CHAIN_IDs.MAINNET],
   TOKEN_SYMBOLS_MAP.SOL.addresses[CHAIN_IDs.SOLANA],
   TOKEN_SYMBOLS_MAP.SOL.addresses[CHAIN_IDs.SOLANA_DEVNET],
@@ -332,9 +334,6 @@ export const DEFI_LLAMA_POOL_LOOKUP: Record<string, string> = {
     "8f7b5b8c-09db-45e3-8938-f30115d34672",
 };
 
-export const DEFAULT_SIMULATED_RECIPIENT_ADDRESS =
-  "0xBb23Cd0210F878Ea4CcA50e9dC307fb0Ed65Cf6B";
-
 export const DOMAIN_CALLDATA_DELIMITER = "0x1dc0de";
 
 export const DEFAULT_LITE_CHAIN_USD_MAX_BALANCE = "250000";

api/_fill-deadline.ts

@@ -1,5 +1,8 @@
+import * as sdk from "@across-protocol/sdk";
+
 import { DEFAULT_FILL_DEADLINE_BUFFER_SECONDS } from "./_constants";
-import { getSpokePool } from "./_utils";
+import { getSpokePool } from "./_spoke-pool";
+import { getSVMRpc } from "./_providers";
 
 function getFillDeadlineBuffer(chainId: number) {
   const bufferFromEnv = (
@@ -11,9 +14,26 @@ function getFillDeadlineBuffer(chainId: number) {
   return Number(bufferFromEnv ?? DEFAULT_FILL_DEADLINE_BUFFER_SECONDS);
 }
 
+async function getCurrentTimeSvm(chainId: number): Promise<number> {
+  const rpc = getSVMRpc(chainId);
+  const timestamp = await rpc
+    .getSlot({
+      commitment: "confirmed",
+    })
+    .send()
+    .then((slot) => rpc.getBlockTime(slot).send());
+  return Number(timestamp);
+}
+
 export async function getFillDeadline(chainId: number): Promise<number> {
   const fillDeadlineBuffer = getFillDeadlineBuffer(chainId);
-  const spokePool = getSpokePool(chainId);
-  const currentTime = await spokePool.callStatic.getCurrentTime();
-  return Number(currentTime) + fillDeadlineBuffer;
+  let currentTime: number;
+
+  if (sdk.utils.chainIsSvm(chainId)) {
+    currentTime = await getCurrentTimeSvm(chainId);
+  } else {
+    const spokePool = getSpokePool(chainId);
+    currentTime = (await spokePool.callStatic.getCurrentTime()).toNumber();
+  }
+  return currentTime + fillDeadlineBuffer;
 }

api/_gas.ts

@@ -0,0 +1,70 @@
+import * as sdk from "@across-protocol/sdk";
+import { BigNumber, BigNumberish } from "ethers";
+import { getDefaultRecipientAddress } from "./_recipient-address";
+
+export function calcGasFeeDetails(params: {
+  gasPriceEstimate: sdk.gasPriceOracle.GasPriceEstimate;
+  nativeGasCost: BigNumberish;
+  opStackL1GasCost?: BigNumberish;
+}) {
+  const { gasPriceEstimate, nativeGasCost, opStackL1GasCost } = params;
+
+  const gasPriceEstimateEvm =
+    gasPriceEstimate as sdk.gasPriceOracle.EvmGasPriceEstimate;
+  const gasPriceEstimateSvm =
+    gasPriceEstimate as sdk.gasPriceOracle.SvmGasPriceEstimate;
+
+  // EVM-based chains
+  if (
+    gasPriceEstimateEvm.maxFeePerGas &&
+    gasPriceEstimateEvm.maxPriorityFeePerGas
+  ) {
+    const tokenGasCost = BigNumber.from(nativeGasCost)
+      .mul(gasPriceEstimateEvm.maxFeePerGas)
+      .add(opStackL1GasCost ?? 0);
+    return {
+      tokenGasCost,
+      opStackL1GasCost,
+      gasPrice: gasPriceEstimateEvm.maxFeePerGas,
+      nativeGasCost: BigNumber.from(nativeGasCost),
+    };
+  }
+
+  // SVM-based chains
+  if (
+    gasPriceEstimateSvm.baseFee &&
+    gasPriceEstimateSvm.microLamportsPerComputeUnit
+  ) {
+    const tokenGasCost = gasPriceEstimateSvm.baseFee.add(
+      gasPriceEstimateSvm.microLamportsPerComputeUnit
+        .mul(nativeGasCost)
+        .div(1_000_000) // 1_000_000 microLamports/lamport.
+    );
+    return {
+      tokenGasCost,
+      opStackL1GasCost,
+      gasPrice: tokenGasCost,
+      nativeGasCost: BigNumber.from(nativeGasCost),
+    };
+  }
+
+  throw new Error(
+    "Can't compute gas fee details. Missing or incorrect gas price estimate."
+  );
+}
+
+export function getDepositArgsForCachedGasDetails(
+  chainId: number,
+  tokenAddress: string
+) {
+  return {
+    amount: BigNumber.from(100),
+    inputToken: sdk.utils.toAddressType(sdk.constants.ZERO_ADDRESS).toBytes32(),
+    outputToken: sdk.utils.toAddressType(tokenAddress).toBytes32(),
+    recipientAddress: sdk.utils
+      .toAddressType(getDefaultRecipientAddress(chainId))
+      .toBytes32(),
+    originChainId: 0, // Shouldn't matter for simulation
+    destinationChainId: Number(chainId),
+  };
+}