@townsq/mm-sdk 1.0.1

package/src/lifeline/modules/ts-account.ts

@@ -0,0 +1,420 @@
+import { EvmAddress, GenericAddress } from '../../common/types/address.js';
+import { ChainType, TSChainId } from '../../common/types/chain.js';
+import {
+  convertFromGenericAddress,
+  convertToGenericAddress,
+} from '../../common/utils/address.js';
+import { TSHubAccount } from '../../chains/evm/hub/modules/index.js';
+import { TSCore } from '../core/ts-core.js';
+import { AccountId, Nonce } from '../../common/types/lending.js';
+import { AccountInfo } from '../../chains/evm/hub/types/account.js';
+import { MessageAdapterParams } from '../../common/types/adapter.js';
+import {
+  Action,
+  CreateAccountMessageData,
+  InviteAddressMessageData,
+  MessageAdapters,
+  MessageBuilderParams,
+  OptionalFeeParams,
+  UnregisterAddressMessageData,
+} from '../../common/types/message.js';
+import { NULL_ACCOUNT_ID } from '../../common/constants/lending.js';
+import { assertAdapterSupportsDataMessage } from '../../common/utils/adapter.js';
+import {
+  assertSpokeChainSupported,
+  getSignerGenericAddress,
+  getSpokeChain,
+} from '../../common/utils/chain.js';
+import { getHubChain } from '../../chains/evm/hub/utils/chain.js';
+import { buildAccountId } from '../../common/utils/lending.js';
+import {
+  buildMessageToSend,
+  estimateAdapterReceiveGasLimit,
+} from '../../common/utils/messages.js';
+import { MessageDirection } from '../../common/types/gmp.js';
+import { TSEvmAccount } from '../../chains/evm/spoke/modules/index.js';
+import { exhaustiveCheck } from '../../utils/exhaustive-check.js';
+import {
+  PrepareAcceptInviteAddressCall,
+  PrepareCreateAccountCall,
+  PrepareInviteAddressCall,
+  PrepareUnregisterAddressCall,
+} from '../../common/types/module.js';
+export const prepare = {
+  async createAccount(
+    nonce: Nonce,
+    adapters: MessageAdapters,
+    refAccountId: AccountId = NULL_ACCOUNT_ID
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    // check adapters are compatible
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const accountId = buildAccountId(userAddress, tsChain.tsChainId, nonce);
+
+    const data: CreateAccountMessageData = { nonce, refAccountId };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.CreateAccount,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: '0x',
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmAccount.prepare.createAccount(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          nonce,
+          refAccountId,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async inviteAddress(
+    accountId: AccountId,
+    tsChainIdToInvite: TSChainId,
+    addressToInvite: GenericAddress,
+    adapters: MessageAdapters,
+    refAccountId: AccountId = NULL_ACCOUNT_ID
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    // check adapters are compatible
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const data: InviteAddressMessageData = {
+      tsChainIdToInvite,
+      addressToInvite,
+      refAccountId,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.InviteAddress,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: '0x',
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmAccount.prepare.inviteAddress(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          tsChainIdToInvite,
+          addressToInvite,
+          refAccountId,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async acceptInvite(accountId: AccountId, adapters: MessageAdapters) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    // check adapters are compatible
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.AcceptInviteAddress,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data: '0x',
+      extraArgs: '0x',
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmAccount.prepare.acceptInvite(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async unregisterAddress(
+    accountId: AccountId,
+    tsChainIdToUnregister: TSChainId,
+    adapters: MessageAdapters
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    // check adapters are compatible
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const data: UnregisterAddressMessageData = {
+      tsChainIdToUnregister,
+    };
+
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.UnregisterAddress,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: '0x',
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmAccount.prepare.unregisterAddress(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          tsChainIdToUnregister,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+};
+
+export const write = {
+  async createAccount(
+    nonce: Nonce,
+    prepareCall: PrepareCreateAccountCall,
+    refAccountId: AccountId = NULL_ACCOUNT_ID
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmAccount.write.createAccount(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          nonce,
+          refAccountId,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async inviteAddress(
+    accountId: AccountId,
+    tsChainIdToInvite: TSChainId,
+    addressToInvite: GenericAddress,
+    prepareCall: PrepareInviteAddressCall,
+    refAccountId: AccountId = NULL_ACCOUNT_ID
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmAccount.write.inviteAddress(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          tsChainIdToInvite,
+          addressToInvite,
+          refAccountId,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async acceptInvite(
+    accountId: AccountId,
+    prepareCall: PrepareAcceptInviteAddressCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmAccount.write.acceptInvite(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async unregisterAddress(
+    accountId: AccountId,
+    tsChainIdToUnregister: TSChainId,
+    prepareCall: PrepareUnregisterAddressCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmAccount.write.unregisterAddress(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          tsChainIdToUnregister,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+};
+
+export const read = {
+  getAccountIdOfAddressOnChain: async (address: EvmAddress) => {
+    const addressBytes = convertToGenericAddress(address, ChainType.EVM);
+    return TSHubAccount.getAccountIdByAddress(
+      TSCore.getHubProvider(),
+      TSCore.getSelectedNetwork(),
+      addressBytes
+    );
+  },
+  async isAccountCreated(accountId: AccountId) {
+    return TSHubAccount.isAccountCreated(
+      TSCore.getHubProvider(),
+      TSCore.getSelectedNetwork(),
+      accountId
+    );
+  },
+  async accountInfo(
+    accountId: AccountId,
+    tsChainIds?: Array<TSChainId>
+  ): Promise<AccountInfo> {
+    return TSHubAccount.getAccountInfo(
+      TSCore.getHubProvider(),
+      TSCore.getSelectedNetwork(),
+      accountId,
+      tsChainIds
+    );
+  },
+};

package/src/lifeline/modules/ts-gmp.ts

@@ -0,0 +1,5 @@
+export const prepare = {};
+
+export const write = {};
+
+export const util = {};