@folks-finance/xchain-sdk 0.0.1

package/src/common/types/message.ts

@@ -0,0 +1,330 @@
+import type { GenericAddress } from "./address.js";
+import type { FolksChainId } from "./chain.js";
+import type { AccountId, LoanId, LoanName } from "./lending.js";
+import type { LoanTypeId } from "./module.js";
+import type { FolksTokenId, FolksSpokeTokenType } from "./token.js";
+import type { FINALITY } from "../constants/message.js";
+import type { Hex } from "viem";
+
+export enum AdapterType {
+  HUB = 1,
+  WORMHOLE_DATA = 2,
+  WORMHOLE_CCTP = 3,
+  CCIP_DATA = 4,
+  CCIP_TOKEN = 5,
+}
+
+export enum Action {
+  // SPOKE -> HUB
+  CreateAccount,
+  InviteAddress,
+  AcceptInviteAddress,
+  UnregisterAddress,
+  AddDelegate,
+  RemoveDelegate,
+  CreateLoan,
+  DeleteLoan,
+  CreateLoanAndDeposit,
+  Deposit,
+  DepositFToken,
+  Withdraw,
+  WithdrawFToken,
+  Borrow,
+  Repay,
+  RepayWithCollateral,
+  Liquidate,
+  SwitchBorrowType,
+  // HUB -> SPOKE
+  SendToken,
+}
+
+export type SendTokenAction = Extract<Action, Action.Deposit | Action.Repay>;
+export type ReceiveTokenAction = Extract<Action, Action.Withdraw | Action.Borrow>;
+export type HubAction = Extract<
+  Action,
+  Action.DepositFToken | Action.WithdrawFToken | Action.Liquidate | Action.SendToken
+>;
+export type DataAction = Extract<
+  Action,
+  | Action.CreateAccount
+  | Action.InviteAddress
+  | Action.AcceptInviteAddress
+  | Action.UnregisterAddress
+  | Action.AddDelegate
+  | Action.RemoveDelegate
+  | Action.CreateLoan
+  | Action.DeleteLoan
+  | Action.RepayWithCollateral
+  | Action.SwitchBorrowType
+>;
+
+export type Finality = (typeof FINALITY)[keyof typeof FINALITY];
+
+export type MessageAdapters = {
+  adapterId: AdapterType;
+  returnAdapterId: AdapterType;
+};
+
+export type SupportedMessageAdapters = {
+  adapterId: Array<AdapterType>;
+  returnAdapterId: Array<AdapterType>;
+};
+
+export type FeeParams = {
+  receiverValue: bigint;
+  gasLimit: bigint;
+  returnGasLimit: bigint;
+};
+
+export type MessageParams = FeeParams & MessageAdapters;
+
+export type OptionalFeeParams = Partial<FeeParams>;
+
+export type MessageToSend = {
+  params: MessageParams;
+  sender: GenericAddress;
+  destinationChainId: number;
+  handler: GenericAddress;
+  payload: Hex;
+  finalityLevel: Finality;
+  extraArgs: Hex;
+};
+
+// Data
+export type DefaultMessageData = "0x";
+
+// Data: account
+export type CreateAccountMessageData = {
+  refAccountId: AccountId;
+};
+
+export type InviteAddressMessageData = {
+  folksChainIdToInvite: FolksChainId;
+  addressToInvite: GenericAddress;
+  refAccountId: AccountId;
+};
+
+export type UnregisterAddressMessageData = {
+  folksChainIdToUnregister: FolksChainId;
+};
+
+// Data: loan
+export type CreateLoanMessageData = {
+  loanId: LoanId;
+  loanTypeId: LoanTypeId;
+  loanName: LoanName;
+};
+
+export type DeleteLoanMessageData = {
+  accountId: AccountId;
+  loanId: LoanId;
+};
+
+export type CreateLoanAndDepositMessageData = {
+  loanId: LoanId;
+  poolId: number;
+  amount: bigint;
+  loanTypeId: LoanTypeId;
+  loanName: LoanName;
+};
+
+export type DepositMessageData = {
+  loanId: LoanId;
+  poolId: number;
+  amount: bigint;
+};
+
+export type WithdrawMessageData = {
+  loanId: LoanId;
+  poolId: number;
+  receiverFolksChainId: FolksChainId;
+  amount: bigint;
+  isFAmount: boolean;
+};
+
+export type BorrowMessageData = {
+  loanId: LoanId;
+  poolId: number;
+  receiverFolksChainId: FolksChainId;
+  amount: bigint;
+  maxStableRate: bigint;
+};
+
+export type RepayMessageData = {
+  loanId: LoanId;
+  poolId: number;
+  amount: bigint;
+  maxOverRepayment: bigint;
+};
+
+export type RepayWithCollateralMessageData = {
+  loanId: LoanId;
+  poolId: number;
+  amount: bigint;
+};
+
+export type SwitchBorrowTypeMessageData = {
+  loanId: LoanId;
+  poolId: number;
+  maxStableRate: bigint;
+};
+
+export type LiquidateMessageData = {
+  violatorLoanId: LoanId;
+  liquidatorLoanId: LoanId;
+  colPoolId: number;
+  borPoolId: number;
+  repayingAmount: bigint;
+  minSeizedAmount: bigint;
+};
+
+export type SendTokenMessageData = {
+  folksTokenId: FolksTokenId;
+  amount: bigint;
+};
+
+// Extra args
+export type DefaultExtraArgs = "0x";
+
+// Extra args: loan
+export type DepositExtraArgs = {
+  token: FolksSpokeTokenType;
+  recipient: GenericAddress;
+  amount: bigint;
+};
+
+export type RepayExtraArgs = {
+  token: FolksSpokeTokenType;
+  recipient: GenericAddress;
+  amount: bigint;
+};
+
+export type SendTokenExtraArgs = {
+  token: FolksSpokeTokenType;
+  recipient: GenericAddress;
+  amount: bigint;
+};
+
+// Params
+export type DefaultMessageDataParams = {
+  action:
+    | Action.AcceptInviteAddress
+    | Action.AddDelegate
+    | Action.RemoveDelegate
+    | Action.DepositFToken
+    | Action.WithdrawFToken;
+  data: DefaultMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+// Params: account
+export type CreateAccountMessageDataParams = {
+  action: Action.CreateAccount;
+  data: CreateAccountMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type InviteAddressMessageDataParams = {
+  action: Action.InviteAddress;
+  data: InviteAddressMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type UnregisterAddressMessageDataParams = {
+  action: Action.UnregisterAddress;
+  data: UnregisterAddressMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+// Params: loan
+export type CreateLoanMessageDataParams = {
+  action: Action.CreateLoan;
+  data: CreateLoanMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type DeleteLoanMessageDataParams = {
+  action: Action.DeleteLoan;
+  data: DeleteLoanMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type CreateLoanAndDepositMessageDataParams = {
+  action: Action.CreateLoanAndDeposit;
+  data: CreateLoanAndDepositMessageData;
+  extraArgs: DepositExtraArgs;
+};
+
+export type DepositMessageDataParams = {
+  action: Action.Deposit;
+  data: DepositMessageData;
+  extraArgs: DepositExtraArgs;
+};
+
+export type WithdrawMessageDataParams = {
+  action: Action.Withdraw;
+  data: WithdrawMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type BorrowMessageDataParams = {
+  action: Action.Borrow;
+  data: BorrowMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type RepayMessageDataParams = {
+  action: Action.Repay;
+  data: RepayMessageData;
+  extraArgs: RepayExtraArgs;
+};
+
+export type RepayWithCollateralMessageDataParams = {
+  action: Action.RepayWithCollateral;
+  data: RepayWithCollateralMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type SwitchBorrowTypeMessageDataParams = {
+  action: Action.SwitchBorrowType;
+  data: SwitchBorrowTypeMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type LiquidateMessageDataParams = {
+  action: Action.Liquidate;
+  data: LiquidateMessageData;
+  extraArgs: DefaultExtraArgs;
+};
+
+export type SendTokenMessageDataParams = {
+  action: Action.SendToken;
+  data: SendTokenMessageData;
+  extraArgs: SendTokenExtraArgs;
+};
+
+export type MessageDataParams =
+  | DefaultMessageDataParams
+  | CreateAccountMessageDataParams
+  | InviteAddressMessageDataParams
+  | UnregisterAddressMessageDataParams
+  | CreateLoanMessageDataParams
+  | DeleteLoanMessageDataParams
+  | CreateLoanAndDepositMessageDataParams
+  | DepositMessageDataParams
+  | WithdrawMessageDataParams
+  | BorrowMessageDataParams
+  | RepayMessageDataParams
+  | RepayWithCollateralMessageDataParams
+  | SwitchBorrowTypeMessageDataParams
+  | LiquidateMessageDataParams
+  | SendTokenMessageDataParams;
+
+export type MessageBuilderParams = {
+  userAddress: GenericAddress;
+  accountId: AccountId;
+  adapters: MessageAdapters;
+  sender: GenericAddress;
+  destinationChainId: FolksChainId;
+  handler: GenericAddress;
+} & MessageDataParams;

package/src/common/types/module.ts

@@ -0,0 +1,42 @@
+import type {
+  PrepareCreateAccountCall as PrepareCreateAccountEVMCall,
+  PrepareInviteAddressCall as PrepareInviteAddressEVMCall,
+  PrepareAcceptInviteAddressCall as PrepareAcceptInviteAddressEVMCall,
+  PrepareUnregisterAddressCall as PrepareUnregisterAddressEVMCall,
+  PrepareCreateLoanCall as PrepareCreateLoanEVMCall,
+  PrepareDeleteLoanCall as PrepareDeleteLoanEVMCall,
+  PrepareCreateLoanAndDepositCall as PrepareCreateLoanAndDepositEVMCall,
+  PrepareDepositCall as PrepareDepositEVMCall,
+  PrepareWithdrawCall as PrepareWithdrawEVMCall,
+  PrepareCall as PrepareEVMCall,
+  PrepareBorrowCall as PrepareBorrowEVMCall,
+  PrepareRepayCall as PrepareRepayEVMCall,
+  PrepareRepayWithCollateralCall as PrepareRepayWithCollateralEVMCall,
+  PrepareSwitchBorrowTypeCall as PrepareSwitchBorrowTypeEVMCall,
+  PrepareLiquidateCall as PrepareLiquidateEVMCall,
+  PrepareRetryMessageCall as PrepareRetryMessageEVMCall,
+} from "../../chains/evm/common/types/module.js";
+
+export enum LoanTypeId {
+  DEPOSIT = 1, // no support for borrows
+  GENERAL = 2,
+}
+
+export type PrepareCall = PrepareEVMCall;
+
+export type PrepareCreateAccountCall = PrepareCreateAccountEVMCall;
+export type PrepareInviteAddressCall = PrepareInviteAddressEVMCall;
+export type PrepareAcceptInviteAddressCall = PrepareAcceptInviteAddressEVMCall;
+export type PrepareUnregisterAddressCall = PrepareUnregisterAddressEVMCall;
+
+export type PrepareCreateLoanCall = PrepareCreateLoanEVMCall;
+export type PrepareDeleteLoanCall = PrepareDeleteLoanEVMCall;
+export type PrepareCreateLoanAndDepositCall = PrepareCreateLoanAndDepositEVMCall;
+export type PrepareDepositCall = PrepareDepositEVMCall;
+export type PrepareWithdrawCall = PrepareWithdrawEVMCall;
+export type PrepareBorrowCall = PrepareBorrowEVMCall;
+export type PrepareRepayCall = PrepareRepayEVMCall;
+export type PrepareRepayWithCollateralCall = PrepareRepayWithCollateralEVMCall;
+export type PrepareSwitchBorrowTypeCall = PrepareSwitchBorrowTypeEVMCall;
+export type PrepareLiquidateCall = PrepareLiquidateEVMCall;
+export type PrepareRetryMessageCall = PrepareRetryMessageEVMCall;

package/src/common/types/token.ts

@@ -0,0 +1,50 @@
+import type { GenericAddress } from "./address.js";
+
+export enum FolksTokenId {
+  USDC = "USDC",
+  AVAX = "AVAX",
+  ETH_eth_sep = "ETH_eth_sep",
+  ETH_base_sep = "ETH_base_sep",
+  LINK_eth_sep = "LINK_eth_sep",
+}
+
+export enum TokenType {
+  NATIVE = "NATIVE",
+  ERC20 = "ERC20",
+  CIRCLE = "CIRCLE",
+}
+
+export type ITokenData = {
+  folksTokenId: FolksTokenId;
+};
+
+type Erc20SpokeTokenType = {
+  type: TokenType.ERC20;
+  address: GenericAddress;
+  decimals: number;
+};
+
+type Erc20HubTokenType = {
+  type: TokenType.ERC20;
+  decimals: number;
+};
+
+type CircleTokenType = {
+  type: TokenType.CIRCLE;
+  address: GenericAddress;
+  decimals: number;
+};
+
+type NativeTokenType = {
+  type: TokenType.NATIVE;
+  decimals: number;
+};
+
+export type FolksSpokeTokenType = Erc20SpokeTokenType | CircleTokenType | NativeTokenType;
+export type FolksHubTokenType = Erc20HubTokenType | CircleTokenType | NativeTokenType;
+
+export type SpokeTokenData = {
+  poolId: number;
+  spokeAddress: GenericAddress;
+  token: FolksSpokeTokenType;
+} & ITokenData;

package/src/common/utils/adapter.ts

@@ -0,0 +1,75 @@
+import { isHubChain } from "../../chains/evm/hub/utils/chain.js";
+import { exhaustiveCheck } from "../../utils/exhaustive-check.js";
+import { FolksCore } from "../../xchain/core/folks-core.js";
+import { DATA_ADAPTERS, HUB_ADAPTERS, TOKEN_ADAPTERS } from "../constants/adapter.js";
+import { MessageAdapterParamsType } from "../types/adapter.js";
+import { AdapterType } from "../types/message.js";
+
+import { isCircleToken } from "./token.js";
+
+import type { MessageAdapterParams, ReceiveTokenMessageAdapterParams } from "../types/adapter.js";
+import type { FolksChainId } from "../types/chain.js";
+
+export function doesAdapterSupportDataMessage(folksChainId: FolksChainId, adapterId: AdapterType): boolean {
+  const isHub = isHubChain(folksChainId, FolksCore.getSelectedNetwork());
+  return (
+    (isHub && adapterId === AdapterType.HUB) ||
+    (!isHub && (adapterId === AdapterType.WORMHOLE_DATA || adapterId === AdapterType.CCIP_DATA))
+  );
+}
+
+export function assertAdapterSupportsDataMessage(folksChainId: FolksChainId, adapterId: AdapterType): void {
+  if (!doesAdapterSupportDataMessage(folksChainId, adapterId))
+    throw Error(`Adapter ${adapterId} does not support data message for folksChainId: ${folksChainId}`);
+}
+
+export function doesAdapterSupportTokenMessage(folksChainId: FolksChainId, adapterId: AdapterType): boolean {
+  const isHub = isHubChain(folksChainId, FolksCore.getSelectedNetwork());
+  return (
+    (isHub && adapterId === AdapterType.HUB) ||
+    (!isHub && (adapterId === AdapterType.WORMHOLE_CCTP || adapterId === AdapterType.CCIP_TOKEN))
+  );
+}
+
+export function assertAdapterSupportsTokenMessage(folksChainId: FolksChainId, adapterId: AdapterType): void {
+  if (!doesAdapterSupportTokenMessage(folksChainId, adapterId))
+    throw Error(`Adapter ${adapterId} does not support token message for folksChainId: ${folksChainId}`);
+}
+
+function getAdapterIds(messageAdapterParams: MessageAdapterParams) {
+  const { sourceFolksChainId, network, messageAdapterParamType } = messageAdapterParams;
+  if (isHubChain(sourceFolksChainId, network)) return HUB_ADAPTERS;
+  if (messageAdapterParamType == MessageAdapterParamsType.SendToken && isCircleToken(messageAdapterParams.folksTokenId))
+    return TOKEN_ADAPTERS;
+  return DATA_ADAPTERS;
+}
+
+function getReturnAdapterIds({ folksTokenId, destFolksChainId, network }: ReceiveTokenMessageAdapterParams) {
+  if (isHubChain(destFolksChainId, network)) return HUB_ADAPTERS;
+  if (isCircleToken(folksTokenId)) return TOKEN_ADAPTERS;
+  return DATA_ADAPTERS;
+}
+
+export function getSupportedMessageAdapters(params: MessageAdapterParams) {
+  const { messageAdapterParamType } = params;
+
+  switch (messageAdapterParamType) {
+    case MessageAdapterParamsType.SendToken:
+      return {
+        adapterIds: getAdapterIds(params),
+        returnAdapterIds: [AdapterType.HUB],
+      };
+    case MessageAdapterParamsType.ReceiveToken:
+      return {
+        adapterIds: getAdapterIds(params),
+        returnAdapterIds: getReturnAdapterIds(params),
+      };
+    case MessageAdapterParamsType.Data:
+      return {
+        adapterIds: getAdapterIds(params),
+        returnAdapterIds: [AdapterType.HUB],
+      };
+    default:
+      return exhaustiveCheck(messageAdapterParamType);
+  }
+}

package/src/common/utils/address.ts

@@ -0,0 +1,49 @@
+import { getAddress, pad, sliceHex } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+
+import { exhaustiveCheck } from "../../utils/exhaustive-check.js";
+import { BYTES32_LENGTH, EVM_ADDRESS_BYTES_LENGTH } from "../constants/bytes.js";
+import { ChainType } from "../types/chain.js";
+
+import type { AddressType, EvmAddress, GenericAddress } from "../types/address.js";
+import type { AccountId } from "../types/lending.js";
+
+export function getRandomGenericAddress(): GenericAddress {
+  return pad(privateKeyToAccount(generatePrivateKey()).address, {
+    size: BYTES32_LENGTH,
+  }).toLowerCase() as GenericAddress;
+}
+
+export function isGenericAddress(address: GenericAddress): boolean {
+  return address.length === 64 + 2;
+}
+
+export function isAccountId(accountId: AccountId): boolean {
+  return accountId.length === 64 + 2;
+}
+
+export function convertToGenericAddress<T extends ChainType>(
+  address: AddressType<T>,
+  fromChainType: ChainType,
+): GenericAddress {
+  switch (fromChainType) {
+    case ChainType.EVM:
+      return pad(address as EvmAddress, {
+        size: BYTES32_LENGTH,
+      }).toLowerCase() as GenericAddress;
+    default:
+      return exhaustiveCheck(fromChainType);
+  }
+}
+
+export function convertFromGenericAddress<T extends ChainType>(
+  address: GenericAddress,
+  toChainType: ChainType,
+): AddressType<T> {
+  switch (toChainType) {
+    case ChainType.EVM:
+      return getAddress(sliceHex(address, BYTES32_LENGTH - EVM_ADDRESS_BYTES_LENGTH)) as EvmAddress;
+    default:
+      return exhaustiveCheck(toChainType);
+  }
+}

package/src/common/utils/bytes.ts

@@ -0,0 +1,46 @@
+import { bytesToHex, pad, toHex } from "viem";
+
+import { BYTES32_LENGTH } from "../constants/bytes.js";
+
+import type { AccountId, LoanId } from "../types/lending.js";
+import type { Hex } from "viem";
+
+export function getEmptyBytes(length: number): string {
+  return pad("0x", { size: length });
+}
+
+export function getAccountIdBytes(accountId: string): AccountId {
+  return pad(toHex(Buffer.from(accountId)), {
+    size: BYTES32_LENGTH,
+  }) as AccountId;
+}
+
+export function convertNumberToBytes(num: number | bigint, length: number): Hex {
+  // insert 0s at the beginning if data is smaller than length bytes
+  const buf = Buffer.alloc(length, 0);
+
+  // convert num to bytes
+  const hex = num.toString(16);
+  const isEven = hex.length % 2 === 0;
+  const bytes = Buffer.from(isEven ? hex : "0" + hex, "hex");
+
+  // write bytes to fixed length buf
+  bytes.copy(buf, buf.length - bytes.length);
+  return toHex(buf);
+}
+
+export function convertStringToBytes(str: string): Hex {
+  return toHex("0x" + Buffer.from(str).toString("hex"));
+}
+
+export function convertBooleanToByte(bool: boolean): Hex {
+  return bool ? "0x01" : "0x00";
+}
+
+export function getRandomBytes(length: number): Hex {
+  return bytesToHex(crypto.getRandomValues(new Uint8Array(length)));
+}
+
+export function generateLoanId(): LoanId {
+  return getRandomBytes(BYTES32_LENGTH) as LoanId;
+}

package/src/common/utils/chain.ts

@@ -0,0 +1,103 @@
+import { getEvmSignerAddress } from "../../chains/evm/common/utils/chain.js";
+import { getHubChainAdapterAddress, isHubChain } from "../../chains/evm/hub/utils/chain.js";
+import { exhaustiveCheck } from "../../utils/exhaustive-check.js";
+import { FOLKS_CHAIN, SPOKE_CHAIN } from "../constants/chain.js";
+import { ChainType } from "../types/chain.js";
+
+import { convertToGenericAddress } from "./address.js";
+
+import type { GenericAddress } from "../types/address.js";
+import type { FolksChain, FolksChainId, NetworkType, SpokeChain } from "../types/chain.js";
+import type { FolksChainSigner } from "../types/core.js";
+import type { AdapterType } from "../types/message.js";
+import type { FolksTokenId, SpokeTokenData } from "../types/token.js";
+
+export function getFolksChain(folksChainId: FolksChainId, network: NetworkType): FolksChain {
+  const folksChain = FOLKS_CHAIN[network][folksChainId];
+  if (!folksChain) throw new Error(`Folks Chain not found for folksChainId: ${folksChainId}`);
+
+  return folksChain;
+}
+
+export function getFolksChainsByNetwork(network: NetworkType): Array<FolksChain> {
+  return Object.values(FOLKS_CHAIN[network]);
+}
+
+export function getFolksChainIdsByNetwork(networkType: NetworkType): Array<FolksChainId> {
+  return getFolksChainsByNetwork(networkType).map((folksChain) => folksChain.folksChainId);
+}
+
+export function isSpokeChainSupported(folksChainId: FolksChainId, network: NetworkType): boolean {
+  return SPOKE_CHAIN[network][folksChainId] !== undefined;
+}
+
+export function assertSpokeChainSupported(folksChainId: FolksChainId, network: NetworkType) {
+  if (!isSpokeChainSupported(folksChainId, network))
+    throw new Error(`Spoke chain is not supported for folksChainId: ${folksChainId}`);
+}
+
+export function getSpokeChain(folksChainId: FolksChainId, network: NetworkType): SpokeChain {
+  const spokeChain = SPOKE_CHAIN[network][folksChainId];
+  if (!spokeChain) throw new Error(`Spoke chain not found for folksChainId: ${folksChainId}`);
+
+  return spokeChain;
+}
+
+export function doesSpokeSupportFolksToken(spokeChain: SpokeChain, folksTokenId: FolksTokenId): boolean {
+  return spokeChain.tokens[folksTokenId] !== undefined;
+}
+
+export function getSpokeTokenData(spokeChain: SpokeChain, folksTokenId: FolksTokenId): SpokeTokenData {
+  const tokenData = spokeChain.tokens[folksTokenId];
+  if (!tokenData) throw new Error(`Spoke Token not found for folksTokenId: ${folksTokenId}`);
+
+  return tokenData;
+}
+
+export function isFolksTokenSupported(
+  folksTokenId: FolksTokenId,
+  folksChainId: FolksChainId,
+  network: NetworkType,
+): boolean {
+  const spokeChain = getSpokeChain(folksChainId, network);
+  return doesSpokeSupportFolksToken(spokeChain, folksTokenId);
+}
+
+export function assertSpokeChainSupportFolksToken(
+  folksChainId: FolksChainId,
+  folksTokenId: FolksTokenId,
+  network: NetworkType,
+) {
+  if (!isFolksTokenSupported(folksTokenId, folksChainId, network))
+    throw new Error(`Folks Token ${folksTokenId} is not supported on Folks Chain ${folksChainId}`);
+}
+
+export function getSpokeChainAdapterAddress(
+  folksChainId: FolksChainId,
+  network: NetworkType,
+  adapterType: AdapterType,
+): GenericAddress {
+  const spokeChain = getSpokeChain(folksChainId, network);
+  const adapterAddress = spokeChain.adapters[adapterType];
+  if (adapterAddress) return adapterAddress;
+  throw new Error(`Adapter ${adapterType} not found for spoke chain ${folksChainId}`);
+}
+
+export function getAdapterAddress(folksChainId: FolksChainId, network: NetworkType, adapterType: AdapterType) {
+  if (isHubChain(folksChainId, network)) return getHubChainAdapterAddress(network, adapterType);
+  return getSpokeChainAdapterAddress(folksChainId, network, adapterType);
+}
+
+export function getSignerGenericAddress(folksChainSigner: FolksChainSigner): GenericAddress {
+  const chainType = folksChainSigner.chainType;
+  switch (chainType) {
+    case ChainType.EVM:
+      return convertToGenericAddress(getEvmSignerAddress(folksChainSigner.signer), chainType);
+    default:
+      return exhaustiveCheck(chainType);
+  }
+}
+
+export function assertHubChainSelected(folksChainId: FolksChainId, network: NetworkType) {
+  if (!isHubChain(folksChainId, network)) throw new Error(`Wrong chain selected: ${folksChainId}. Expected Hub chain`);
+}