@townsq/mm-sdk 1.0.1

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

@@ -0,0 +1,43 @@
+import type { EvmAddress, GenericAddress } from "../../../../common/types/address.js";
+import type { TSChainId } from "../../../../common/types/chain.js";
+import type { AccountId } from "../../../../common/types/lending.js";
+import type { AdapterType } from "../../../../common/types/message.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>;
+};
+
+export type RetryMessageExtraArgs = {
+  returnAdapterId: AdapterType;
+  returnGasLimit: bigint;
+};
+
+export type RetryMessageExtraArgsParams = Partial<Omit<RetryMessageExtraArgs, "returnGasLimit">> | undefined;
+
+export type ReverseMessageExtraArgs = {
+  accountId: AccountId;
+  returnAdapterId: AdapterType;
+  returnGasLimit: bigint;
+};
+
+export type ReverseMessageExtraArgsParams = Partial<Omit<ReverseMessageExtraArgs, "returnGasLimit">> | undefined;
+
+export type MessageReceived = {
+  messageId: Hex;
+  sourceChainId: TSChainId;
+  sourceAddress: GenericAddress;
+  handler: GenericAddress;
+  payload: Hex;
+  returnAdapterId: AdapterType;
+  returnGasLimit: bigint;
+};

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

@@ -0,0 +1,115 @@
+import type { MessageReceived } from './gmp.js';
+import type {
+  EvmAddress,
+  GenericAddress,
+} from '../../../../common/types/address.js';
+import type { AccountId } from '../../../../common/types/lending.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;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
+  messageParams: MessageParams;
+};
+
+export type PrepareCreateAccountCall = {
+  accountId: AccountId;
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareInviteAddressCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareAcceptInviteAddressCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareUnregisterAddressCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareAddDelegateCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareRemoveDelegateCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareCreateLoanCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareDeleteLoanCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareCreateLoanAndDepositCall = {
+  spokeTokenData: SpokeTokenData;
+} & PrepareCall;
+
+export type PrepareDepositCall = {
+  spokeTokenData: SpokeTokenData;
+} & PrepareCall;
+
+export type PrepareWithdrawCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareBorrowCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareRepayCall = {
+  spokeTokenData: SpokeTokenData;
+} & PrepareCall;
+
+export type PrepareRepayWithCollateralCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareSwitchBorrowTypeCall = {
+  spokeOperationAddress: GenericAddress;
+} & PrepareCall;
+
+export type PrepareLiquidateCall = {
+  messageData: Hex;
+  hubAddress: GenericAddress;
+} & Omit<PrepareCall, 'messageParams' | 'msgValue'>;
+
+export type PrepareUpdateUserPointsInLoansCall = {
+  loanControllerAddress: GenericAddress;
+} & Omit<PrepareCall, 'messageParams' | 'msgValue'>;
+
+export type PrepareRetryMessageCall = {
+  isHub: boolean;
+  message: MessageReceived;
+  extraArgs: Hex;
+  bridgeRouterAddress: GenericAddress;
+} & Omit<PrepareCall, 'messageParams'>;
+
+export type PrepareReverseMessageCall = {
+  isHub: boolean;
+  message: MessageReceived;
+  extraArgs: Hex;
+  bridgeRouterAddress: GenericAddress;
+} & Omit<PrepareCall, 'messageParams'>;
+
+export type PrepareResendWormholeMessageCall = {
+  vaaKey: {
+    chainId: number;
+    emitterAddress: GenericAddress;
+    sequence: bigint;
+  };
+  targetWormholeChainId: number;
+  receiverValue: bigint;
+  receiverGasLimit: bigint;
+  deliveryProviderAddress: GenericAddress;
+  wormholeRelayerAddress: GenericAddress;
+} & Omit<PrepareCall, 'messageParams'>;

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

@@ -0,0 +1,35 @@
+import type { EvmTsChainId } from './chain.js';
+import type { EvmAddress } from '../../../../common/types/address.js';
+
+import type {
+  TSTokenId as LendingTokenId,
+  TokenType,
+} from '../../../../common/types/token.js';
+
+export type Erc20ContractSlot = {
+  balanceOf: bigint;
+  allowance: bigint;
+};
+
+export type AllowanceStateOverride = {
+  erc20Address: EvmAddress;
+  stateDiff: Array<{
+    owner: EvmAddress;
+    spender: EvmAddress;
+    tsChainId: EvmTsChainId;
+    tsTokenId: LendingTokenId;
+    tokenType: TokenType;
+    amount: bigint;
+  }>;
+};
+
+export type BalanceOfStateOverride = {
+  erc20Address: EvmAddress;
+  stateDiff: Array<{
+    owner: EvmAddress;
+    tsChainId: EvmTsChainId;
+    tsTokenId: LendingTokenId;
+    tokenType: TokenType;
+    amount: bigint;
+  }>;
+};

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

@@ -0,0 +1,33 @@
+import { getBlock } from 'viem/actions';
+
+import { EVM_TS_CHAIN_ID } from '../constant/chain.js';
+
+import type { EvmAddress } from '../../../../common/types/address.js';
+import type { EvmChainId } from '../types/chain.js';
+import type { Account, Client, 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_TS_CHAIN_ID).includes(chainId);
+};
+
+export async function getBlockTimestamp(
+  provider: Client,
+  blockNumber?: bigint
+): Promise<bigint> {
+  const block = await getBlock(provider, {
+    blockNumber,
+    includeTransactions: false,
+  });
+  return block.timestamp;
+}

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

@@ -0,0 +1,120 @@
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  encodeAbiParameters,
+  getContract,
+  keccak256,
+  padHex,
+  toHex,
+} from "viem";
+
+import { ChainType } from "../../../../common/types/chain.js";
+import { convertFromGenericAddress } from "../../../../common/utils/address.js";
+import { CCIPDataAdapterAbi } from "../constant/abi/ccip-data-adapter-abi.js";
+import { ERC20Abi } from "../constant/abi/erc-20-abi.js";
+import { WormholeDataAdapterAbi } from "../constant/abi/wormhole-data-adapter-abi.js";
+import { IWormholeRelayerAbi } from "../constant/abi/wormhole-relayer-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, GetContractReturnType, 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 getWormholeRelayerContract(
+  provider: Client,
+  address: GenericAddress,
+): GetReadContractReturnType<typeof IWormholeRelayerAbi>;
+export function getWormholeRelayerContract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient,
+): GetContractReturnType<typeof IWormholeRelayerAbi, Client>;
+export function getWormholeRelayerContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient,
+): GetReadContractReturnType<typeof IWormholeRelayerAbi> | GetContractReturnType<typeof IWormholeRelayerAbi, Client> {
+  return getContract({
+    abi: IWormholeRelayerAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+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 encodeErc20AccountData(data: { isFrozen: boolean; amount: bigint }) {
+  const bitFlag = data.isFrozen ? 1n : 0n;
+  const packed = (data.amount << 8n) | bitFlag;
+  return padHex(toHex(packed), { size: 32 });
+}
+
+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,54 @@
+import { concat } from 'viem';
+
+import {
+  UINT16_LENGTH,
+  UINT256_LENGTH,
+} from '../../../../common/constants/byte.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 {
+  RetryMessageExtraArgs,
+  ReverseMessageExtraArgs,
+} from '../types/gmp.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,
+  ]);
+}
+
+export function encodeRetryMessageExtraArgs(
+  extraArgs?: RetryMessageExtraArgs
+): Hex {
+  if (extraArgs === undefined) return '0x';
+  const { returnAdapterId, returnGasLimit } = extraArgs;
+  return concat([
+    convertNumberToBytes(returnAdapterId, UINT16_LENGTH),
+    convertNumberToBytes(returnGasLimit, UINT256_LENGTH),
+  ]);
+}
+
+export function encodeReverseMessageExtraArgs(
+  extraArgs?: ReverseMessageExtraArgs
+): Hex {
+  if (extraArgs === undefined) return '0x';
+  const { accountId, returnAdapterId, returnGasLimit } = extraArgs;
+  return concat([
+    accountId,
+    convertNumberToBytes(returnAdapterId, UINT16_LENGTH),
+    convertNumberToBytes(returnGasLimit, UINT256_LENGTH),
+  ]);
+}