@folks-finance/xchain-sdk 0.0.1

package/src/xchain/modules/folks-account.ts

@@ -0,0 +1,385 @@
+import { FolksHubAccount } from "../../chains/evm/hub/modules/index.js";
+import { getHubChain } from "../../chains/evm/hub/utils/chain.js";
+import { FolksEvmAccount } from "../../chains/evm/spoke/modules/index.js";
+import { NULL_ACCOUNT_ID } from "../../common/constants/lending.js";
+import { ChainType } from "../../common/types/chain.js";
+import { MessageDirection } from "../../common/types/gmp.js";
+import { Action } from "../../common/types/message.js";
+import { assertAdapterSupportsDataMessage } from "../../common/utils/adapter.js";
+import { convertFromGenericAddress } from "../../common/utils/address.js";
+import { assertSpokeChainSupported, getSignerGenericAddress, getSpokeChain } from "../../common/utils/chain.js";
+import { buildMessageToSend, estimateAdapterReceiveGasLimit } from "../../common/utils/messages.js";
+import { exhaustiveCheck } from "../../utils/exhaustive-check.js";
+import { FolksCore } from "../core/folks-core.js";
+
+import type { AccountIdByAddress, AccountInfo } from "../../chains/evm/hub/types/account.js";
+import type { GenericAddress } from "../../common/types/address.js";
+import type { FolksChainId } from "../../common/types/chain.js";
+import type { AccountId } from "../../common/types/lending.js";
+import type {
+  CreateAccountMessageData,
+  InviteAddressMessageData,
+  MessageAdapters,
+  MessageBuilderParams,
+  OptionalFeeParams,
+  UnregisterAddressMessageData,
+} from "../../common/types/message.js";
+import type {
+  PrepareAcceptInviteAddressCall,
+  PrepareCreateAccountCall,
+  PrepareInviteAddressCall,
+  PrepareUnregisterAddressCall,
+} from "../../common/types/module.js";
+
+export const prepare = {
+  async createAccount(accountId: AccountId, adapters: MessageAdapters, refAccountId: AccountId = NULL_ACCOUNT_ID) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    // check adapters are compatible
+    assertAdapterSupportsDataMessage(folksChain.folksChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(folksChain.folksChainId, folksChain.network);
+    const hubChain = getHubChain(folksChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: FolksCore.getFolksSigner().signer,
+      chainType: folksChain.chainType,
+    });
+
+    const data: CreateAccountMessageData = { refAccountId };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.CreateAccount,
+      sender: spokeChain.spokeCommonAddress,
+      destinationChainId: hubChain.folksChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: "0x",
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      folksChain.folksChainId,
+      hubChain.folksChainId,
+      FolksCore.getHubProvider(),
+      folksChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams,
+    );
+
+    const messageToSend = buildMessageToSend(folksChain.chainType, messageBuilderParams, feeParams);
+
+    switch (folksChain.chainType) {
+      case ChainType.EVM:
+        return await FolksEvmAccount.prepare.createAccount(
+          FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+          convertFromGenericAddress(userAddress, folksChain.chainType),
+          messageToSend,
+          accountId,
+          refAccountId,
+          spokeChain,
+        );
+      default:
+        return exhaustiveCheck(folksChain.chainType);
+    }
+  },
+
+  async inviteAddress(
+    accountId: AccountId,
+    folksChainIdToInvite: FolksChainId,
+    addressToInvite: GenericAddress,
+    adapters: MessageAdapters,
+    refAccountId: AccountId = NULL_ACCOUNT_ID,
+  ) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    // check adapters are compatible
+    assertAdapterSupportsDataMessage(folksChain.folksChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(folksChain.folksChainId, folksChain.network);
+    const hubChain = getHubChain(folksChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: FolksCore.getFolksSigner().signer,
+      chainType: folksChain.chainType,
+    });
+
+    const data: InviteAddressMessageData = {
+      folksChainIdToInvite,
+      addressToInvite,
+      refAccountId,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.InviteAddress,
+      sender: spokeChain.spokeCommonAddress,
+      destinationChainId: hubChain.folksChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: "0x",
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      folksChain.folksChainId,
+      hubChain.folksChainId,
+      FolksCore.getHubProvider(),
+      folksChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams,
+    );
+
+    const messageToSend = buildMessageToSend(folksChain.chainType, messageBuilderParams, feeParams);
+
+    switch (folksChain.chainType) {
+      case ChainType.EVM:
+        return await FolksEvmAccount.prepare.inviteAddress(
+          FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+          convertFromGenericAddress(userAddress, folksChain.chainType),
+          messageToSend,
+          accountId,
+          folksChainIdToInvite,
+          addressToInvite,
+          refAccountId,
+          spokeChain,
+        );
+      default:
+        return exhaustiveCheck(folksChain.chainType);
+    }
+  },
+
+  async acceptInvite(accountId: AccountId, adapters: MessageAdapters) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    // check adapters are compatible
+    assertAdapterSupportsDataMessage(folksChain.folksChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(folksChain.folksChainId, folksChain.network);
+    const hubChain = getHubChain(folksChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: FolksCore.getFolksSigner().signer,
+      chainType: folksChain.chainType,
+    });
+
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.AcceptInviteAddress,
+      sender: spokeChain.spokeCommonAddress,
+      destinationChainId: hubChain.folksChainId,
+      handler: hubChain.hubAddress,
+      data: "0x",
+      extraArgs: "0x",
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      folksChain.folksChainId,
+      hubChain.folksChainId,
+      FolksCore.getHubProvider(),
+      folksChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams,
+    );
+
+    const messageToSend = buildMessageToSend(folksChain.chainType, messageBuilderParams, feeParams);
+
+    switch (folksChain.chainType) {
+      case ChainType.EVM:
+        return await FolksEvmAccount.prepare.acceptInvite(
+          FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+          convertFromGenericAddress(userAddress, folksChain.chainType),
+          messageToSend,
+          accountId,
+          spokeChain,
+        );
+      default:
+        return exhaustiveCheck(folksChain.chainType);
+    }
+  },
+
+  async unregisterAddress(accountId: AccountId, folksChainIdToUnregister: FolksChainId, adapters: MessageAdapters) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    // check adapters are compatible
+    assertAdapterSupportsDataMessage(folksChain.folksChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(folksChain.folksChainId, folksChain.network);
+    const hubChain = getHubChain(folksChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: FolksCore.getFolksSigner().signer,
+      chainType: folksChain.chainType,
+    });
+
+    const data: UnregisterAddressMessageData = {
+      folksChainIdToUnregister,
+    };
+
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.UnregisterAddress,
+      sender: spokeChain.spokeCommonAddress,
+      destinationChainId: hubChain.folksChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: "0x",
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      folksChain.folksChainId,
+      hubChain.folksChainId,
+      FolksCore.getHubProvider(),
+      folksChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams,
+    );
+
+    const messageToSend = buildMessageToSend(folksChain.chainType, messageBuilderParams, feeParams);
+
+    switch (folksChain.chainType) {
+      case ChainType.EVM:
+        return await FolksEvmAccount.prepare.unregisterAddress(
+          FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+          convertFromGenericAddress(userAddress, folksChain.chainType),
+          messageToSend,
+          accountId,
+          folksChainIdToUnregister,
+          spokeChain,
+        );
+      default:
+        return exhaustiveCheck(folksChain.chainType);
+    }
+  },
+};
+
+export const write = {
+  async createAccount(
+    accountId: AccountId,
+    prepareCall: PrepareCreateAccountCall,
+    refAccountId: AccountId = NULL_ACCOUNT_ID,
+  ) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    assertSpokeChainSupported(folksChain.folksChainId, folksChain.network);
+
+    switch (folksChain.chainType) {
+      case ChainType.EVM:
+        return await FolksEvmAccount.write.createAccount(
+          FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+          FolksCore.getSigner<ChainType.EVM>(),
+          accountId,
+          refAccountId,
+          prepareCall,
+        );
+      default:
+        return exhaustiveCheck(folksChain.chainType);
+    }
+  },
+
+  async inviteAddress(
+    accountId: AccountId,
+    folksChainIdToInvite: FolksChainId,
+    addressToInvite: GenericAddress,
+    prepareCall: PrepareInviteAddressCall,
+    refAccountId: AccountId = NULL_ACCOUNT_ID,
+  ) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    assertSpokeChainSupported(folksChain.folksChainId, folksChain.network);
+
+    switch (folksChain.chainType) {
+      case ChainType.EVM:
+        return await FolksEvmAccount.write.inviteAddress(
+          FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+          FolksCore.getSigner<ChainType.EVM>(),
+          accountId,
+          folksChainIdToInvite,
+          addressToInvite,
+          refAccountId,
+          prepareCall,
+        );
+      default:
+        return exhaustiveCheck(folksChain.chainType);
+    }
+  },
+
+  async acceptInvite(accountId: AccountId, prepareCall: PrepareAcceptInviteAddressCall) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    assertSpokeChainSupported(folksChain.folksChainId, folksChain.network);
+
+    switch (folksChain.chainType) {
+      case ChainType.EVM:
+        return await FolksEvmAccount.write.acceptInvite(
+          FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+          FolksCore.getSigner<ChainType.EVM>(),
+          accountId,
+          prepareCall,
+        );
+      default:
+        return exhaustiveCheck(folksChain.chainType);
+    }
+  },
+
+  async unregisterAddress(
+    accountId: AccountId,
+    folksChainIdToUnregister: FolksChainId,
+    prepareCall: PrepareUnregisterAddressCall,
+  ) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    assertSpokeChainSupported(folksChain.folksChainId, folksChain.network);
+
+    switch (folksChain.chainType) {
+      case ChainType.EVM:
+        return await FolksEvmAccount.write.unregisterAddress(
+          FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+          FolksCore.getSigner<ChainType.EVM>(),
+          accountId,
+          folksChainIdToUnregister,
+          prepareCall,
+        );
+      default:
+        return exhaustiveCheck(folksChain.chainType);
+    }
+  },
+};
+
+export const read = {
+  async accountInfo(accountId: AccountId, folksChainIds?: Array<FolksChainId>): Promise<AccountInfo> {
+    return FolksHubAccount.getAccountInfo(
+      FolksCore.getHubProvider(),
+      FolksCore.getSelectedNetwork(),
+      accountId,
+      folksChainIds,
+    );
+  },
+
+  async accountIdByAddress(address: GenericAddress): Promise<AccountIdByAddress> {
+    return FolksHubAccount.getAccountIdByAddress(FolksCore.getHubProvider(), FolksCore.getSelectedNetwork(), address);
+  },
+
+  async accountIdByAddressOnChain(address: GenericAddress, folksChainId: FolksChainId): Promise<AccountId | null> {
+    return FolksHubAccount.getAccountIdByAddressOnChain(
+      FolksCore.getHubProvider(),
+      FolksCore.getSelectedNetwork(),
+      address,
+      folksChainId,
+    );
+  },
+
+  async invitationByAddress(address: GenericAddress, folksChainId?: FolksChainId) {
+    return FolksHubAccount.getInvitationByAddress(
+      FolksCore.getHubProvider(),
+      FolksCore.getSelectedNetwork(),
+      address,
+      folksChainId,
+    );
+  },
+};

package/src/xchain/modules/folks-gmp.ts

@@ -0,0 +1,129 @@
+import { getEvmSignerAddress } from "../../chains/evm/common/utils/chain.js";
+import { FolksHubGmp } from "../../chains/evm/hub/modules/index.js";
+import { getHubChain } from "../../chains/evm/hub/utils/chain.js";
+import { FolksEvmGmp } from "../../chains/evm/spoke/modules/index.js";
+import { assertHubChainSelected, getSpokeChain } from "../../common/utils/chain.js";
+import { FolksCore } from "../core/folks-core.js";
+
+import type { PrepareReverseMessageCall } from "../../chains/evm/common/types/module.js";
+import type { ChainType } from "../../common/types/chain.js";
+import type { MessageId, ReverseMessageExtraAgrs } from "../../common/types/gmp.js";
+import type { AdapterType } from "../../common/types/message.js";
+import type { PrepareRetryMessageCall } from "../../common/types/module.js";
+
+export const prepare = {
+  async retryMessage(adapterId: AdapterType, messageId: MessageId, value: bigint, isHub = true) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    if (isHub) {
+      assertHubChainSelected(folksChain.folksChainId, folksChain.network);
+      return await FolksHubGmp.prepare.retryMessage(
+        FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+        getEvmSignerAddress(FolksCore.getSigner()),
+        adapterId,
+        messageId,
+        value,
+        getHubChain(folksChain.network),
+      );
+    } else {
+      return await FolksEvmGmp.prepare.retryMessage(
+        FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+        getEvmSignerAddress(FolksCore.getSigner()),
+        adapterId,
+        messageId,
+        value,
+        getSpokeChain(folksChain.folksChainId, folksChain.network),
+      );
+    }
+  },
+
+  async reverseMessage(
+    adapterId: AdapterType,
+    messageId: MessageId,
+    extraArgs: ReverseMessageExtraAgrs,
+    value: bigint,
+    isHub = true,
+  ) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+
+    if (isHub) {
+      assertHubChainSelected(folksChain.folksChainId, folksChain.network);
+      return await FolksHubGmp.prepare.reverseMessage(
+        FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+        getEvmSignerAddress(FolksCore.getSigner()),
+        adapterId,
+        messageId,
+        extraArgs,
+        value,
+        getHubChain(folksChain.network),
+      );
+    } else {
+      return await FolksEvmGmp.prepare.reverseMessage(
+        FolksCore.getProvider<ChainType.EVM>(folksChain.folksChainId),
+        getEvmSignerAddress(FolksCore.getSigner()),
+        adapterId,
+        messageId,
+        extraArgs,
+        value,
+        getSpokeChain(folksChain.folksChainId, folksChain.network),
+      );
+    }
+  },
+};
+
+export const write = {
+  async retryMessage(adapterId: AdapterType, messageId: MessageId, prepareCall: PrepareRetryMessageCall) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+    const { isHub } = prepareCall;
+
+    if (isHub) {
+      assertHubChainSelected(folksChain.folksChainId, folksChain.network);
+      return await FolksHubGmp.write.retryMessage(
+        FolksCore.getHubProvider(),
+        FolksCore.getSigner<ChainType.EVM>(),
+        adapterId,
+        messageId,
+        prepareCall,
+      );
+    } else {
+      return await FolksEvmGmp.write.retryMessage(
+        FolksCore.getHubProvider(),
+        FolksCore.getSigner<ChainType.EVM>(),
+        adapterId,
+        messageId,
+        prepareCall,
+      );
+    }
+  },
+
+  async reverseMessage(
+    adapterId: AdapterType,
+    messageId: MessageId,
+    extraArgs: ReverseMessageExtraAgrs,
+    prepareCall: PrepareReverseMessageCall,
+  ) {
+    const folksChain = FolksCore.getSelectedFolksChain();
+    const { isHub } = prepareCall;
+
+    if (isHub) {
+      assertHubChainSelected(folksChain.folksChainId, folksChain.network);
+      return await FolksHubGmp.write.reverseMessage(
+        FolksCore.getHubProvider(),
+        FolksCore.getSigner<ChainType.EVM>(),
+        adapterId,
+        messageId,
+        extraArgs,
+        prepareCall,
+      );
+    } else {
+      return await FolksEvmGmp.write.reverseMessage(
+        FolksCore.getHubProvider(),
+        FolksCore.getSigner<ChainType.EVM>(),
+        adapterId,
+        messageId,
+        extraArgs,
+        prepareCall,
+      );
+    }
+  },
+};