feat(ecash): add testnet support

Author: Amatack

packages/extension/src/libs/activity-state/wrap-activity-handler.ts

@@ -18,7 +18,8 @@ export default (activityHandler: ActivityHandlerType): ActivityHandlerType => {
     };
 
     // Use shorter cache TTL for eCash due to faster finality
-    const cacheTTL = network.name === 'XEC' ? ECASH_CACHE_TTL : CACHE_TTL;
+    const isECash = network.name === 'XEC' || network.name === 'XECTest';
+    const cacheTTL = isECash ? ECASH_CACHE_TTL : CACHE_TTL;
 
     const [activities, cacheTime] = await Promise.all([
       activityState.getAllActivities(options),

packages/extension/src/providers/ecash/libs/activity-handlers.ts

@@ -18,6 +18,7 @@ export const chronikHandler: ActivityHandlerType = async (
   address,
 ): Promise<Activity[]> => {
   try {
+    const cashAddrPrefix = (network as any).cashAddrPrefix ?? 'ecash';
     const normalizedAddress = getAddressWithoutPrefix(address);
 
     const api = (await network.api()) as unknown as ChronikAPI;
@@ -44,24 +45,37 @@ export const chronikHandler: ActivityHandlerType = async (
     for (const tx of txHistory) {
       try {
         const isReceive = tx.outputs.some((output: any) => {
-          const outputAddress = scriptToAddress(output.outputScript);
+          const outputAddress = scriptToAddress(
+            output.outputScript,
+            cashAddrPrefix,
+          );
           return outputAddress === normalizedAddress;
         });
 
         const isSend = tx.inputs.some((input: any) => {
-          const inputAddress = scriptToAddress(input.outputScript);
+          const inputAddress = scriptToAddress(
+            input.outputScript ?? '',
+            cashAddrPrefix,
+          );
           return inputAddress === normalizedAddress;
         });
 
-        const value = isReceive
-          ? calculateTransactionValue(tx.outputs, normalizedAddress, true)
-          : calculateTransactionValue(tx.outputs, normalizedAddress, false);
+        const value =
+          isReceive || isSend
+            ? calculateTransactionValue(
+                tx.outputs,
+                normalizedAddress,
+                isReceive,
+                cashAddrPrefix,
+              )
+            : '0';
 
         const { fromAddress, toAddress } = getTransactionAddresses(
           tx,
           normalizedAddress,
           isReceive,
           isSend,
+          cashAddrPrefix,
         );
 
         const fee = isSend ? calculateOnchainTxFee(tx) : 0;
@@ -77,13 +91,13 @@ export const chronikHandler: ActivityHandlerType = async (
           blockNumber: tx.block?.height || 0,
           fee,
           transactionHash: tx.txid,
-          timestamp: tx.block?.timestamp || Math.floor(timestamp / 1000),
+          timestamp,
           inputs: tx.inputs.map((input: any) => ({
-            address: scriptToAddress(input.outputScript),
+            address: scriptToAddress(input.outputScript ?? '', cashAddrPrefix),
             value: Number(extractSats(input)),
           })),
           outputs: tx.outputs.map((output: any) => ({
-            address: scriptToAddress(output.outputScript),
+            address: scriptToAddress(output.outputScript, cashAddrPrefix),
             value: Number(extractSats(output)),
             pkscript: output.outputScript || '',
           })),
@@ -106,7 +120,7 @@ export const chronikHandler: ActivityHandlerType = async (
           type: ActivityType.transaction,
           value,
           transactionHash: tx.txid,
-          timestamp,
+          timestamp: timestamp * 1000,
           token: tokenInfo,
           rawInfo,
         };

packages/extension/src/providers/ecash/libs/api-chronik.ts

@@ -1,6 +1,7 @@
 import { ProviderAPIInterface } from '@/types/provider';
 import { BTCRawInfo } from '@/types/activity';
 import { ChronikClient } from 'chronik-client';
+import { WatchOnlyWallet } from 'ecash-wallet';
 import { getAddress } from '../types/ecash-network';
 import { ECashNetworkInfo, ChronikTx } from '../types/ecash-chronik';
 import { Script, Address } from 'ecash-lib';
@@ -32,7 +33,7 @@ export class ChronikAPI extends ProviderAPIInterface {
     return this.withErrorHandling(
       'init',
       async () => {
-        await this.chronik.blockchainInfo();
+        await this.chronik.chronikInfo();
       },
       () => {
         throw new Error('Failed to initialize Chronik API');
@@ -41,7 +42,7 @@ export class ChronikAPI extends ProviderAPIInterface {
   }
 
   private ensurePrefix(address: string): string {
-    if (address.startsWith('ecash:') || address.startsWith('ectest:')) {
+    if (address.includes(':')) {
       return address;
     }
     return `${this.networkInfo.cashAddrPrefix}:${address}`;
@@ -50,40 +51,25 @@ export class ChronikAPI extends ProviderAPIInterface {
   private async withErrorHandling<T>(
     method: string,
     operation: () => Promise<T>,
-    fallback: () => T,
+    fallback?: () => T | Promise<T>,
   ): Promise<T> {
     try {
       return await operation();
     } catch (error) {
-      console.error(`❌ [${method}] Error:`, error);
-      return fallback();
+      console.error(`[ChronikAPI:${method}]`, error);
+      if (fallback) return await fallback();
+      throw error;
     }
   }
 
-  private calculateUTXOBalance(utxos: any[]): bigint {
-    return utxos.reduce((total, utxo) => {
-      if (!utxo.token) {
-        const value = BigInt((utxo as any).sats || utxo.value || 0);
-        return total + value;
-      }
-      return total;
-    }, BigInt(0));
-  }
-
   async getBalance(pubkey: string): Promise<string> {
     return this.withErrorHandling(
       'getBalance',
       async () => {
         const address = getAddress(pubkey);
-
-        const addressWithPrefix = this.ensurePrefix(address);
-        const utxoResponse = await this.chronik
-          .address(addressWithPrefix)
-          .utxos();
-
-        const totalSatoshis = this.calculateUTXOBalance(utxoResponse.utxos);
-
-        return totalSatoshis.toString();
+        const wallet = WatchOnlyWallet.fromAddress(address, this.chronik);
+        await wallet.sync();
+        return wallet.balanceSats.toString();
       },
       () => '0',
     );
@@ -103,7 +89,7 @@ export class ChronikAPI extends ProviderAPIInterface {
     );
   }
 
-  async getTransactionHistory(address: string): Promise<any[]> {
+  async getTransactionHistory(address: string): Promise<ChronikTx[]> {
     return this.withErrorHandling(
       'getTransactionHistory',
       async () => {
@@ -122,23 +108,19 @@ export class ChronikAPI extends ProviderAPIInterface {
       async () => {
         const tx = await this.chronik.tx(hash);
 
-        if (!tx.block) {
-          return null; // Transaction is in mempool
-        }
-
         const rawInfo: BTCRawInfo = {
-          blockNumber: tx.block.height,
+          blockNumber: tx.block?.height ?? 0,
           fee: this.calculateFee(tx as any),
           transactionHash: tx.txid,
-          timestamp: tx.block.timestamp,
-          inputs: tx.inputs.map((input: any) => ({
-            address: this.scriptToAddress(input.outputScript || ''),
-            value: input.value || '0',
-            pkscript: input.outputScript || '',
+          timestamp: tx.block?.timestamp ?? Math.floor(Date.now() / 1000),
+          inputs: tx.inputs.map(input => ({
+            address: this.scriptToAddress(input.outputScript ?? ''),
+            value: Number(input.sats),
+            pkscript: input.outputScript ?? '',
           })),
-          outputs: tx.outputs.map((output: any) => ({
+          outputs: tx.outputs.map(output => ({
             address: this.scriptToAddress(output.outputScript),
-            value: output.value,
+            value: Number(output.sats),
             pkscript: output.outputScript,
           })),
         };
@@ -151,11 +133,11 @@ export class ChronikAPI extends ProviderAPIInterface {
 
   private calculateFee(tx: ChronikTx): number {
     const inputSum = tx.inputs.reduce(
-      (sum, input) => sum + BigInt(input.value || 0),
+      (sum, input) => sum + input.sats,
       BigInt(0),
     );
     const outputSum = tx.outputs.reduce(
-      (sum, output) => sum + BigInt(output.value || 0),
+      (sum, output) => sum + output.sats,
       BigInt(0),
     );
     return Number(inputSum - outputSum);
@@ -167,13 +149,15 @@ export class ChronikAPI extends ProviderAPIInterface {
     try {
       const scriptBytes = Buffer.from(scriptHex, 'hex');
       const script = new Script(scriptBytes);
-      const address = Address.fromScript(script);
-      const fullAddress = address.toString();
+      const fullAddress = Address.fromScript(
+        script,
+        this.networkInfo.cashAddrPrefix,
+      ).toString();
 
       return fullAddress.split(':')[1] || fullAddress;
     } catch (error) {
       console.error(
-        '[scriptToAddress] Invalid script:',
+        '[scriptToAddress] Could not derive address from script, only p2pkh and p2sh are supported:',
         scriptHex.slice(0, 20),
         error,
       );

packages/extension/src/providers/ecash/libs/utils.ts

@@ -12,18 +12,22 @@ export const isValidECashAddress = (address: string): boolean => {
 
 const scriptAddressCache = new Map<string, string>();
 
-export function scriptToAddress(script: string): string {
+export function scriptToAddress(
+  script: string,
+  cashAddrPrefix: string = 'ecash',
+): string {
   if (!script) return 'Unknown';
 
-  if (scriptAddressCache.has(script)) {
-    return scriptAddressCache.get(script)!;
+  const cacheKey = `${cashAddrPrefix}:${script}`;
+  if (scriptAddressCache.has(cacheKey)) {
+    return scriptAddressCache.get(cacheKey)!;
   }
 
   try {
-    const address = Address.fromScriptHex(script);
+    const address = Address.fromScriptHex(script, cashAddrPrefix);
     const addressWithoutPrefix = getAddressWithoutPrefix(address);
 
-    scriptAddressCache.set(script, addressWithoutPrefix);
+    scriptAddressCache.set(cacheKey, addressWithoutPrefix);
     return addressWithoutPrefix;
   } catch (error) {
     console.error('[scriptToAddress] Error:', error, script.slice(0, 20));
@@ -33,7 +37,7 @@ export function scriptToAddress(script: string): string {
         ? `${script.slice(0, 8)}...${script.slice(-8)}`
         : script;
 
-    scriptAddressCache.set(script, fallback);
+    scriptAddressCache.set(cacheKey, fallback);
     return fallback;
   }
 }
@@ -47,36 +51,36 @@ export function extractSats(item: any): string {
 }
 
 export function sumSatoshis(items: any[]): string {
-  return items.reduce((sum, item) => {
-    return toBN(sum)
-      .add(toBN(extractSats(item)))
-      .toString();
-  }, '0');
+  return items
+    .reduce((sum, item) => sum.add(toBN(extractSats(item))), toBN('0'))
+    .toString();
 }
 
 /**
  * Calculate transaction value for receive or send
  * @param outputs - Array of transaction outputs
  * @param normalizedAddress - The address to check against
  * @param isReceive - true for received funds, false for sent funds
+ * @param cashAddrPrefix - The cash address prefix (default: 'ecash')
  */
 export function calculateTransactionValue(
   outputs: any[],
   normalizedAddress: string,
   isReceive: boolean,
+  cashAddrPrefix: string = 'ecash',
 ): string {
   return outputs
     .filter((output: any) => {
-      const outputAddress = scriptToAddress(output.outputScript);
+      const outputAddress = scriptToAddress(
+        output.outputScript,
+        cashAddrPrefix,
+      );
       return isReceive
         ? outputAddress === normalizedAddress
         : outputAddress !== normalizedAddress;
     })
-    .reduce((sum: string, output: any) => {
-      return toBN(sum)
-        .add(toBN(extractSats(output)))
-        .toString();
-    }, '0');
+    .reduce((sum, output) => sum.add(toBN(extractSats(output))), toBN('0'))
+    .toString();
 }
 
 export function calculateOnchainTxFee(tx: any): number {
@@ -90,23 +94,27 @@ export function getTransactionAddresses(
   normalizedAddress: string,
   isReceive: boolean,
   isSend: boolean,
+  cashAddrPrefix: string = 'ecash',
 ): { fromAddress: string; toAddress: string } {
   let fromAddress = 'Unknown';
   let toAddress = 'Unknown';
 
   if (isReceive) {
     fromAddress = tx.inputs[0]?.outputScript
-      ? scriptToAddress(tx.inputs[0].outputScript)
+      ? scriptToAddress(tx.inputs[0].outputScript, cashAddrPrefix)
       : 'Unknown';
     toAddress = normalizedAddress;
   } else if (isSend) {
     fromAddress = normalizedAddress;
     const recipientOutput = tx.outputs.find((output: any) => {
-      const outputAddress = scriptToAddress(output.outputScript);
+      const outputAddress = scriptToAddress(
+        output.outputScript,
+        cashAddrPrefix,
+      );
       return outputAddress !== normalizedAddress;
     });
     toAddress = recipientOutput
-      ? scriptToAddress(recipientOutput.outputScript)
+      ? scriptToAddress(recipientOutput.outputScript, cashAddrPrefix)
       : 'Unknown';
   }
 
@@ -115,16 +123,16 @@ export function getTransactionAddresses(
 
 export function getTransactionTimestamp(tx: any): number {
   if (tx.block?.timestamp) {
-    return tx.block.timestamp * 1000;
+    return tx.block.timestamp;
   }
   if (tx.timeFirstSeen) {
-    return parseInt(tx.timeFirstSeen) * 1000;
+    return Number(tx.timeFirstSeen);
   }
-  return Date.now();
+  return Math.floor(Date.now() / 1000);
 }
 
 export function getAddressWithoutPrefix(address: Address | string): string {
   const fullAddress =
     typeof address === 'string' ? address : address.toString();
-  return fullAddress.replace(/^ecash:/, '');
+  return fullAddress.replace(/^\w+:/, '');
 }