@folks-finance/xchain-sdk 0.0.1

package/src/chains/evm/common/constants/tokens.ts

@@ -0,0 +1,39 @@
+import { FolksTokenId } from "../../../../common/types/token.js";
+
+import { EVM_FOLKS_CHAIN_ID } from "./chain.js";
+
+import type { EvmFolksChainId } from "../types/chain.js";
+import type { Erc20ContractSlot } from "../types/tokens.js";
+
+export const CONTRACT_SLOT: Partial<
+  Record<EvmFolksChainId, { erc20: Partial<Record<FolksTokenId, Erc20ContractSlot>> }>
+> = {
+  [EVM_FOLKS_CHAIN_ID.AVALANCHE_FUJI]: {
+    erc20: {
+      [FolksTokenId.USDC]: {
+        balanceOf: 9n,
+        allowance: 10n,
+      },
+    },
+  },
+  [EVM_FOLKS_CHAIN_ID.BASE_SEPOLIA]: {
+    erc20: {
+      [FolksTokenId.USDC]: {
+        balanceOf: 9n,
+        allowance: 10n,
+      },
+    },
+  },
+  [EVM_FOLKS_CHAIN_ID.ETHEREUM_SEPOLIA]: {
+    erc20: {
+      [FolksTokenId.USDC]: {
+        balanceOf: 9n,
+        allowance: 10n,
+      },
+      [FolksTokenId.LINK_eth_sep]: {
+        balanceOf: 0n,
+        allowance: 1n,
+      },
+    },
+  },
+} as const;

package/src/chains/evm/common/types/chain.ts

@@ -0,0 +1,23 @@
+import type {
+  EVM_CHAIN_ID,
+  MAINNET_EVM_CHAIN_ID,
+  TESTNET_EVM_CHAIN_ID,
+  EVM_CHAIN_NAMES,
+  MAINNET_EVM_CHAIN_NAMES,
+  TESTNET_EVM_CHAIN_NAMES,
+  EVM_FOLKS_CHAIN_ID,
+  MAINNET_EVM_FOLKS_CHAIN_ID,
+  TESTNET_EVM_FOLKS_CHAIN_ID,
+} from "../constants/chain.js";
+
+export type MainnetEvmChainName = (typeof MAINNET_EVM_CHAIN_NAMES)[number];
+export type TestnetEvmChainName = (typeof TESTNET_EVM_CHAIN_NAMES)[number];
+export type EvmChainName = (typeof EVM_CHAIN_NAMES)[number];
+
+export type MainnetEvmChainId = (typeof MAINNET_EVM_CHAIN_ID)[keyof typeof MAINNET_EVM_CHAIN_ID];
+export type TestnetEvmChainId = (typeof TESTNET_EVM_CHAIN_ID)[keyof typeof TESTNET_EVM_CHAIN_ID];
+export type EvmChainId = (typeof EVM_CHAIN_ID)[keyof typeof EVM_CHAIN_ID];
+
+export type MainnetEvmFolksChainId = (typeof MAINNET_EVM_FOLKS_CHAIN_ID)[keyof typeof MAINNET_EVM_FOLKS_CHAIN_ID];
+export type TestnetEvmFolksChainId = (typeof TESTNET_EVM_FOLKS_CHAIN_ID)[keyof typeof TESTNET_EVM_FOLKS_CHAIN_ID];
+export type EvmFolksChainId = (typeof EVM_FOLKS_CHAIN_ID)[keyof typeof EVM_FOLKS_CHAIN_ID];

package/src/chains/evm/common/types/contract.ts

@@ -0,0 +1,7 @@
+import type { Abi, GetContractReturnType, Client, GetContractEventsParameters } from "viem";
+
+type OmitWrite<T> = Omit<T, "write">;
+export type GetReadContractReturnType<TAbi extends Abi> = OmitWrite<GetContractReturnType<TAbi, Client>>;
+
+export type EventParams = Pick<GetContractEventsParameters, "strict" | "fromBlock" | "toBlock">;
+export type GetEventParams = { eventParams: EventParams };

package/src/chains/evm/common/types/gmp.ts

@@ -0,0 +1,15 @@
+import type { EvmAddress, GenericAddress } from "../../../../common/types/address.js";
+import type { Hex } from "viem";
+
+type CCIPTokenAmount = {
+  token: EvmAddress;
+  amount: bigint;
+};
+
+export type CCIPAny2EvmMessage = {
+  messageId: Hex;
+  sourceChainSelector: bigint;
+  sender: GenericAddress;
+  data: Hex;
+  destTokenAmounts: Array<CCIPTokenAmount>;
+};

package/src/chains/evm/common/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./chain.js";
+export * from "./contract.js";
+export * from "./module.js";

package/src/chains/evm/common/types/module.ts

@@ -0,0 +1,85 @@
+import type { GenericAddress } from "../../../../common/types/address.js";
+import type { MessageParams } from "../../../../common/types/message.js";
+import type { SpokeTokenData } from "../../../../common/types/token.js";
+import type { Hex } from "viem";
+
+export type PrepareCall = {
+  msgValue: bigint;
+  gasLimit: bigint;
+  messageParams: MessageParams;
+};
+
+export type PrepareCreateAccountCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareInviteAddressCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareAcceptInviteAddressCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareUnregisterAddressCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareAddDelegateCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareRemoveDelegateCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareCreateLoanCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareDeleteLoanCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareCreateLoanAndDepositCall = {
+  spokeTokenData: SpokeTokenData;
+} & PrepareCall;
+
+export type PrepareDepositCall = {
+  spokeTokenData: SpokeTokenData;
+} & PrepareCall;
+
+export type PrepareWithdrawCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareBorrowCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareRepayCall = {
+  spokeTokenData: SpokeTokenData;
+} & PrepareCall;
+
+export type PrepareRepayWithCollateralCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareSwitchBorrowTypeCall = {
+  spokeCommonAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareLiquidateCall = {
+  messageData: Hex;
+  hubAddress: GenericAddress;
+} & Omit<PrepareCall, "messageParams" | "msgValue">;
+
+export type PrepareRetryMessageCall = {
+  isHub: boolean;
+  bridgeRouterAddress: GenericAddress;
+} & Omit<PrepareCall, "messageParams">;
+
+export type PrepareReverseMessageCall = {
+  isHub: boolean;
+  bridgeRouterAddress: GenericAddress;
+} & Omit<PrepareCall, "messageParams">;

package/src/chains/evm/common/types/tokens.ts

@@ -0,0 +1,31 @@
+import type { EvmFolksChainId } from "./chain.js";
+import type { EvmAddress } from "../../../../common/types/address.js";
+import type { FolksTokenId, TokenType } from "../../../../common/types/token.js";
+
+export type Erc20ContractSlot = {
+  balanceOf: bigint;
+  allowance: bigint;
+};
+
+export type AllowanceStateOverride = {
+  erc20Address: EvmAddress;
+  stateDiff: Array<{
+    owner: EvmAddress;
+    spender: EvmAddress;
+    folksChainId: EvmFolksChainId;
+    folksTokenId: FolksTokenId;
+    tokenType: TokenType;
+    amount: bigint;
+  }>;
+};
+
+export type BalanceOfStateOverride = {
+  erc20Address: EvmAddress;
+  stateDiff: Array<{
+    owner: EvmAddress;
+    folksChainId: EvmFolksChainId;
+    folksTokenId: FolksTokenId;
+    tokenType: TokenType;
+    amount: bigint;
+  }>;
+};

package/src/chains/evm/common/utils/chain.ts

@@ -0,0 +1,20 @@
+import { EVM_FOLKS_CHAIN_ID } from "../constants/chain.js";
+
+import type { EvmAddress } from "../../../../common/types/address.js";
+import type { EvmChainId } from "../types/chain.js";
+import type { Account, WalletClient } from "viem";
+
+export function getEvmSignerAddress(signer: WalletClient): EvmAddress {
+  if (signer.account?.address) return signer.account.address as EvmAddress;
+  throw new Error("EVM Signer address is not set");
+}
+
+export function getEvmSignerAccount(signer: WalletClient): Account {
+  if (signer.account) return signer.account;
+  throw new Error("EVM Signer account is not set");
+}
+
+export const isEvmChainId = (chainId: number): chainId is EvmChainId => {
+  // @ts-expect-error -- this is made on purpose to have the type predicate
+  return Object.values(EVM_FOLKS_CHAIN_ID).includes(chainId);
+};

package/src/chains/evm/common/utils/contract.ts

@@ -0,0 +1,84 @@
+import { BaseError, ContractFunctionRevertedError, encodeAbiParameters, getContract, keccak256 } from "viem";
+
+import { ChainType } from "../../../../common/types/chain.js";
+import { convertFromGenericAddress } from "../../../../common/utils/address.js";
+import { CCIPDataAdapterAbi } from "../constants/abi/ccip-data-adapter-abi.js";
+import { ERC20Abi } from "../constants/abi/erc-20-abi.js";
+import { WormholeDataAdapterAbi } from "../constants/abi/wormhole-data-adapter-abi.js";
+
+import { getEvmSignerAccount, getEvmSignerAddress } from "./chain.js";
+
+import type { EvmAddress, GenericAddress } from "../../../../common/types/address.js";
+import type { GetReadContractReturnType } from "../types/contract.js";
+import type { Client, Hex, WalletClient } from "viem";
+
+export function getERC20Contract(provider: Client, address: GenericAddress, signer: WalletClient) {
+  return getContract({
+    abi: ERC20Abi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export async function sendERC20Approve(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient,
+  spender: EvmAddress,
+  amount: bigint,
+): Promise<Hex | null> {
+  const erc20 = getERC20Contract(provider, address, signer);
+  const allowance = await erc20.read.allowance([getEvmSignerAddress(signer), spender]);
+
+  // approve if not enough
+  if (allowance < amount)
+    return await erc20.write.approve([spender, BigInt(amount)], {
+      account: getEvmSignerAccount(signer),
+      chain: signer.chain,
+    });
+  return null;
+}
+
+export function getWormholeDataAdapterContract(
+  provider: Client,
+  address: GenericAddress,
+): GetReadContractReturnType<typeof WormholeDataAdapterAbi> {
+  return getContract({
+    abi: WormholeDataAdapterAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { public: provider },
+  });
+}
+
+export function getCCIPDataAdapterContract(
+  provider: Client,
+  address: GenericAddress,
+): GetReadContractReturnType<typeof CCIPDataAdapterAbi> {
+  return getContract({
+    abi: CCIPDataAdapterAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { public: provider },
+  });
+}
+
+export function extractRevertErrorName(err: unknown): string | undefined {
+  if (err instanceof BaseError) {
+    const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+    if (revertError instanceof ContractFunctionRevertedError && revertError.data?.errorName) {
+      return revertError.data.errorName;
+    }
+  }
+}
+
+export function getBalanceOfSlotHash(address: EvmAddress, slot: bigint) {
+  return keccak256(encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [address, slot]));
+}
+
+export function getAllowanceSlotHash(owner: EvmAddress, spender: EvmAddress, slot: bigint) {
+  return keccak256(
+    encodeAbiParameters(
+      [{ type: "address" }, { type: "bytes32" }],
+      [spender, keccak256(encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [owner, slot]))],
+    ),
+  );
+}

package/src/chains/evm/common/utils/gmp.ts

@@ -0,0 +1,24 @@
+import { concat } from "viem";
+
+import { UINT16_LENGTH, UINT256_LENGTH } from "../../../../common/constants/bytes.js";
+import { convertNumberToBytes } from "../../../../common/utils/bytes.js";
+
+import type { GenericAddress } from "../../../../common/types/address.js";
+import type { AdapterType } from "../../../../common/types/message.js";
+import type { Hex } from "viem";
+
+export function encodeEvmPayloadWithMetadata(
+  returnAdapterId: AdapterType,
+  returnGasLimit: bigint,
+  sender: GenericAddress,
+  handler: GenericAddress,
+  payload: Hex,
+): Hex {
+  return concat([
+    convertNumberToBytes(returnAdapterId, UINT16_LENGTH),
+    convertNumberToBytes(returnGasLimit, UINT256_LENGTH),
+    sender,
+    handler,
+    payload,
+  ]);
+}