Fixing signer issue for getFee

Author: ekenigs

packages/sdk/src/contract/contract.factory.ts

@@ -1,6 +1,5 @@
 import { ContractConfig } from '@moonbeam-network/xcm-builder';
 import { AnyChain } from '@moonbeam-network/xcm-types';
-import { EvmSigner } from '../sdk.interfaces';
 import {
   BalanceContractInterface,
   TransferContractInterface,
@@ -10,21 +9,20 @@ import { Erc20, Xtokens } from './contracts';
 export function createContract(
   chain: AnyChain,
   config: ContractConfig,
-  signer?: EvmSigner,
 ): TransferContractInterface | BalanceContractInterface {
-  if (config.module === 'Erc20' && chain.isEvmParachain()) {
+  if (!chain.isEvmParachain()) {
+    throw new Error('Chain is not an EVM parachain');
+  }
+
+  if (config.module === 'Erc20') {
     return new Erc20(config, chain);
   }
 
   if (config.module === 'Xtokens') {
-    if (!signer) {
-      throw new Error('Signer is required for Xtokens contract');
-    }
-
     const address =
       'contracts' in chain ? chain?.contracts?.Xtokens : undefined;
 
-    return new Xtokens(config, signer, address);
+    return new Xtokens(config, chain, address);
   }
 
   throw new Error(`Contract ${config.module} not found`);

packages/sdk/src/contract/contract.interfaces.ts

@@ -1,12 +1,13 @@
 import { Hash, PublicClient, WalletClient } from 'viem';
+import { EvmSigner } from '../sdk.interfaces';
 
 export interface BaseContractInterface {
   readonly address: string;
 }
 
 export interface TransferContractInterface extends BaseContractInterface {
-  transfer(): Promise<Hash>;
-  getFee(amount: bigint): Promise<bigint>;
+  transfer(signer: EvmSigner): Promise<Hash>;
+  getFee(amount: bigint, address: string): Promise<bigint>;
 }
 
 export interface BalanceContractInterface extends BaseContractInterface {

packages/sdk/src/contract/contracts/Xtokens/Xtokens.ts

@@ -1,12 +1,6 @@
 import { ContractConfig } from '@moonbeam-network/xcm-builder';
-import {
-  Address,
-  Hash,
-  PublicClient,
-  WalletClient,
-  createPublicClient,
-  http,
-} from 'viem';
+import { Address, Hash, PublicClient, createPublicClient, http } from 'viem';
+import { EvmParachain } from '@moonbeam-network/xcm-types';
 import { EvmSigner } from '../../../sdk.interfaces';
 import { TransferContractInterface } from '../../contract.interfaces';
 import { XTOKENS_ABI } from './XtokensABI';
@@ -15,39 +9,36 @@ export class Xtokens implements TransferContractInterface {
   readonly defaultMoonChainAddress =
     '0x0000000000000000000000000000000000000804';
 
-  readonly address: Address;
+  readonly address: string;
 
   readonly #config: ContractConfig;
 
   readonly #publicClient: PublicClient;
 
-  readonly #walletClient: WalletClient;
-
-  constructor(config: ContractConfig, signer: EvmSigner, address?: Address) {
+  constructor(config: ContractConfig, chain: EvmParachain, address?: string) {
     this.#config = config;
     this.address = address ?? this.defaultMoonChainAddress;
-    this.#walletClient = signer;
     this.#publicClient = createPublicClient({
-      chain: signer.chain,
+      chain: chain.getViemChain(),
       transport: http(),
     });
   }
 
-  async transfer(): Promise<Hash> {
+  async transfer(signer: EvmSigner): Promise<Hash> {
     const { request } = await this.#publicClient.simulateContract({
       abi: XTOKENS_ABI,
-      account: this.#walletClient.account,
-      address: this.address,
+      account: signer.account,
+      address: this.address as Address,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       args: this.#config.args as any,
       functionName: this.#config.func as 'transfer',
     });
-    const hash = await this.#walletClient.writeContract(request);
+    const hash = await signer.writeContract(request);
 
     return hash;
   }
 
-  async getFee(amount: bigint): Promise<bigint> {
+  async getFee(amount: bigint, address: string): Promise<bigint> {
     if (amount === 0n) {
       return 0n;
     }
@@ -59,8 +50,8 @@ export class Xtokens implements TransferContractInterface {
     try {
       const gas = await this.#publicClient.estimateContractGas({
         abi: XTOKENS_ABI,
-        account: this.#walletClient.account,
-        address: this.address,
+        account: address as Address,
+        address: this.address as Address,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         args: this.#config.args as any,
         functionName: this.#config.func as 'transfer',

packages/sdk/src/getTransferData/getSourceData.ts

@@ -295,6 +295,7 @@ export async function getFee({
     }
 
     return getContractFee({
+      address: sourceAddress,
       balance,
       chain: chain as EvmParachain,
       config: contract,
@@ -323,18 +324,20 @@ export async function getFee({
 }
 
 export async function getContractFee({
+  address,
   balance,
   config,
   decimals,
   chain,
 }: {
+  address: string;
   balance: bigint;
   config: ContractConfig;
   decimals: number;
   chain: EvmParachain;
 }): Promise<bigint> {
   const contract = createContract(chain, config) as TransferContractInterface;
-  const fee = await contract.getFee(balance);
+  const fee = await contract.getFee(balance, address);
 
   return convertDecimals(fee, 18, decimals);
 }

packages/sdk/src/getTransferData/getTransferData.ts

@@ -123,8 +123,8 @@ export async function getTransferData({
         }
 
         return (
-          createContract(chain, contract, signer) as TransferContractInterface
-        ).transfer();
+          createContract(chain, contract) as TransferContractInterface
+        ).transfer(signer);
       }
 
       if (extrinsic) {