@tomo-inc/chains-service 0.0.23 → 0.0.24

package/dist/index.cjs

@@ -2925,9 +2925,12 @@ function generateSignature(config) {
 // src/api/utils/index.ts
 var formatJwtToken = (jwtToken) => `Bearer ${jwtToken}`;
 function signRequest(params, clientId, signParams) {
+  if (!params.headers) {
+    params.headers = {};
+  }
   if (typeof signParams === "string") {
     const jwtToken = signParams;
-    Object.assign(params.headers ?? {}, {
+    Object.assign(params.headers, {
       "client-id": clientId,
       Authorization: formatJwtToken(jwtToken)
     });
@@ -2942,7 +2945,7 @@ function signRequest(params, clientId, signParams) {
     apiSecret,
     salt
   });
-  Object.assign(params.headers ?? {}, {
+  Object.assign(params.headers, {
     "X-APP-Key": apiKey,
     "X-Signature": signature,
     "X-Timestamp": timestamp,
@@ -3854,11 +3857,17 @@ var NetworkAPIs = class _NetworkAPIs extends BasePublicService {
   getCacheId(chainType) {
     return `tomo-${chainType}-currentChainId`;
   }
+  /** Map ChainTypeEnum to network-data platformType where they differ */
+  static platformTypeForChain = {
+    [walletUtils.ChainTypeEnum.DOGECOIN]: "DOGE",
+    [walletUtils.ChainTypeEnum.BITCOIN]: "BTC"
+  };
   getAllNetworks(chainType) {
     if (chainType === "") {
       return this.chains;
     }
-    return this.chains.filter((chain) => chain.platformType === chainType.toUpperCase());
+    const platformType = _NetworkAPIs.platformTypeForChain[chainType] ?? chainType.toUpperCase();
+    return this.chains.filter((chain) => chain.platformType === platformType);
   }
   async getCurrentNetwork(chainType) {
     if (!walletUtils.SupportedChainTypes?.[chainType]) {
@@ -3968,15 +3977,16 @@ function fromBase64(base64) {
   return new Uint8Array(buffer);
 }
 function toBase58(data) {
+  console.warn("toBase58:", data);
   throw new Error("toBase58 requires bs58 package. Install it: pnpm add bs58");
 }
-var BaseConfig = walletUtils.SupportedChainTypes[walletUtils.ChainTypeEnum.DOGE];
+var BaseConfig = walletUtils.SupportedChainTypes[walletUtils.ChainTypeEnum.DOGECOIN];
 var BLOCK_CONFIRMATIONS = 1;
 var FEE_RATE_KB = 0.5;
 var DECIMALS = 1e8;
 var TRANSACTION_PAGE_SIZE = 10;
 var MYDOGE_BASE_URL = "https://api.mydoge.com";
-var RPC_URL_TOMO = "https://wallet-pro.tomo.inc/rpc/v1/doge_coin";
+var RPC_URL_TOMO = "https://wallet-test.tomo.inc/rpc/v1/doge_coin";
 var RPC_URL = "https://api.bitcore.io/api/DOGE/mainnet";
 var RPC_TIMEOUT = 20 * 1e3;
 var TX_OVERHEAD = 10;
@@ -4567,11 +4577,7 @@ var DogecoinService = class _DogecoinService extends BaseService {
       gasLimitParam,
       addressList: [txData.from]
     };
-    const {
-      data: gasInfo,
-      success,
-      message
-    } = await this.transactions.queryGasInfo({
+    const { data: gasInfo, success } = await this.transactions.queryGasInfo({
       chainType: this.chainType,
       params: queryGasParams
     });
@@ -4623,6 +4629,9 @@ var DogecoinService = class _DogecoinService extends BaseService {
   async signPsbt({ psbtHex, options }) {
     const psbtBase64 = toBase64(fromHex(psbtHex));
     const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+    if (!options) {
+      console.warn("not support options.");
+    }
     if (!signedPsbt) {
       throw new Error("error psbtHex:" + psbtHex);
     }
@@ -4630,6 +4639,7 @@ var DogecoinService = class _DogecoinService extends BaseService {
     return signedRawTx;
   }
   async signPsbts({ psbtHexs, options }) {
+    console.warn("signPsbsts:", psbtHexs, options);
     throw new Error("not implemented");
   }
   async requestTransaction(txData) {
@@ -4659,6 +4669,9 @@ var DogecoinService = class _DogecoinService extends BaseService {
     fee = 0,
     options
   }) {
+    if (options) {
+      console.warn("not support options");
+    }
     if (fee <= 0) {
       throw new Error("fee is required");
     }
@@ -4753,7 +4766,7 @@ var TxTypes = /* @__PURE__ */ ((TxTypes2) => {
 
 // src/evm/utils.ts
 var isEvmChain = (network2) => {
-  return network2 && network2?.platformType === "EVM";
+  return network2?.platformType === "EVM" || false;
 };
 var getAllTypeChainIds = ({ chainId, chainType }) => {
   if (viem.isHex(chainId)) {
@@ -4767,7 +4780,7 @@ var getAllTypeChainIds = ({ chainId, chainType }) => {
   }
   const chainIdHex = viem.toHex(Number(chainId));
   return {
-    chainId,
+    chainId: String(chainId),
     chainIdHex,
     chainUid: `${chainType}:${chainId}`
   };
@@ -5081,7 +5094,7 @@ var EvmService = class _EvmService extends BaseService {
     }
   }
 };
-var BaseConfig2 = walletUtils.SupportedChainTypes[walletUtils.ChainTypeEnum.SOL];
+var BaseConfig2 = walletUtils.SupportedChainTypes[walletUtils.ChainTypeEnum.SOLANA];
 var TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 var MSG_PREFIX = "\xFFsolana offchain";
 
@@ -5120,15 +5133,7 @@ async function createLegacyTx({ from = "", to = "", amount = 0 }, connection) {
   transaction.lastValidBlockHeight = lastValidBlockHeight;
   return transaction;
 }
-async function createTokenLegacyTransaction2({
-  from = "",
-  to = "",
-  amount = 0,
-  tokenAddress = "",
-  priorityFee = 0,
-  // microLamports (1 SOL = 1e6 microLamports)
-  decimals = 6
-}, connection) {
+async function createTokenLegacyTransaction2({ from = "", to = "", amount = 0, tokenAddress = "", decimals = 6 }, connection) {
   try {
     const fromPubkey = new web3_js.PublicKey(from);
     const toPubkey = new web3_js.PublicKey(to);
@@ -5281,7 +5286,7 @@ var SolanaService = class _SolanaService extends BaseService {
       web3_js.VersionedTransaction.deserialize(hexBuffer);
       rawTx = hexBuffer;
     } catch (error) {
-      const base58Buffer = Buffer.from(toBase58());
+      const base58Buffer = Buffer.from(toBase58(signedTx));
       web3_js.VersionedTransaction.deserialize(base58Buffer);
       rawTx = base58Buffer;
     }
@@ -5333,9 +5338,11 @@ var SolanaService = class _SolanaService extends BaseService {
     return signature;
   }
   async signAllTransactions({ rawTransactions }) {
+    console.warn("signAllTransactions:", rawTransactions);
     throw new Error("no support");
   }
   async signAndSendAllTransactions({ rawTransactions }) {
+    console.warn("signAndSendAllTransactions:", rawTransactions);
     throw new Error("no support");
   }
   async queryRent(params) {

package/dist/index.d.cts

@@ -309,6 +309,8 @@ declare class NetworkAPIs extends BasePublicService {
     private constructor();
     static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo): NetworkAPIs;
     getCacheId(chainType: ChainTypeEnum | ""): string;
+    /** Map ChainTypeEnum to network-data platformType where they differ */
+    private static readonly platformTypeForChain;
     getAllNetworks(chainType: ChainTypeEnum | ""): any[];
     getCurrentNetwork(chainType: ChainTypeEnum): Promise<string>;
     setCurrentNetwork(chainType: ChainTypeEnum | "", chainId: string): Promise<void>;

package/dist/index.d.ts

@@ -309,6 +309,8 @@ declare class NetworkAPIs extends BasePublicService {
     private constructor();
     static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo): NetworkAPIs;
     getCacheId(chainType: ChainTypeEnum | ""): string;
+    /** Map ChainTypeEnum to network-data platformType where they differ */
+    private static readonly platformTypeForChain;
     getAllNetworks(chainType: ChainTypeEnum | ""): any[];
     getCurrentNetwork(chainType: ChainTypeEnum): Promise<string>;
     setCurrentNetwork(chainType: ChainTypeEnum | "", chainId: string): Promise<void>;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { SupportedChainTypes, ChainTypeEnum, TomoApiDomains, cache, getExplorerUrl } from '@tomo-inc/wallet-utils';
+import { ChainTypeEnum, SupportedChainTypes, cache, TomoApiDomains, getExplorerUrl } from '@tomo-inc/wallet-utils';
 import axios from 'axios';
 import CryptoJS from 'crypto-js';
 import Bignumber, { BigNumber } from 'bignumber.js';
@@ -2917,9 +2917,12 @@ function generateSignature(config) {
 // src/api/utils/index.ts
 var formatJwtToken = (jwtToken) => `Bearer ${jwtToken}`;
 function signRequest(params, clientId, signParams) {
+  if (!params.headers) {
+    params.headers = {};
+  }
   if (typeof signParams === "string") {
     const jwtToken = signParams;
-    Object.assign(params.headers ?? {}, {
+    Object.assign(params.headers, {
       "client-id": clientId,
       Authorization: formatJwtToken(jwtToken)
     });
@@ -2934,7 +2937,7 @@ function signRequest(params, clientId, signParams) {
     apiSecret,
     salt
   });
-  Object.assign(params.headers ?? {}, {
+  Object.assign(params.headers, {
     "X-APP-Key": apiKey,
     "X-Signature": signature,
     "X-Timestamp": timestamp,
@@ -3846,11 +3849,17 @@ var NetworkAPIs = class _NetworkAPIs extends BasePublicService {
   getCacheId(chainType) {
     return `tomo-${chainType}-currentChainId`;
   }
+  /** Map ChainTypeEnum to network-data platformType where they differ */
+  static platformTypeForChain = {
+    [ChainTypeEnum.DOGECOIN]: "DOGE",
+    [ChainTypeEnum.BITCOIN]: "BTC"
+  };
   getAllNetworks(chainType) {
     if (chainType === "") {
       return this.chains;
     }
-    return this.chains.filter((chain) => chain.platformType === chainType.toUpperCase());
+    const platformType = _NetworkAPIs.platformTypeForChain[chainType] ?? chainType.toUpperCase();
+    return this.chains.filter((chain) => chain.platformType === platformType);
   }
   async getCurrentNetwork(chainType) {
     if (!SupportedChainTypes?.[chainType]) {
@@ -3960,15 +3969,16 @@ function fromBase64(base64) {
   return new Uint8Array(buffer);
 }
 function toBase58(data) {
+  console.warn("toBase58:", data);
   throw new Error("toBase58 requires bs58 package. Install it: pnpm add bs58");
 }
-var BaseConfig = SupportedChainTypes[ChainTypeEnum.DOGE];
+var BaseConfig = SupportedChainTypes[ChainTypeEnum.DOGECOIN];
 var BLOCK_CONFIRMATIONS = 1;
 var FEE_RATE_KB = 0.5;
 var DECIMALS = 1e8;
 var TRANSACTION_PAGE_SIZE = 10;
 var MYDOGE_BASE_URL = "https://api.mydoge.com";
-var RPC_URL_TOMO = "https://wallet-pro.tomo.inc/rpc/v1/doge_coin";
+var RPC_URL_TOMO = "https://wallet-test.tomo.inc/rpc/v1/doge_coin";
 var RPC_URL = "https://api.bitcore.io/api/DOGE/mainnet";
 var RPC_TIMEOUT = 20 * 1e3;
 var TX_OVERHEAD = 10;
@@ -4559,11 +4569,7 @@ var DogecoinService = class _DogecoinService extends BaseService {
       gasLimitParam,
       addressList: [txData.from]
     };
-    const {
-      data: gasInfo,
-      success,
-      message
-    } = await this.transactions.queryGasInfo({
+    const { data: gasInfo, success } = await this.transactions.queryGasInfo({
       chainType: this.chainType,
       params: queryGasParams
     });
@@ -4615,6 +4621,9 @@ var DogecoinService = class _DogecoinService extends BaseService {
   async signPsbt({ psbtHex, options }) {
     const psbtBase64 = toBase64(fromHex(psbtHex));
     const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+    if (!options) {
+      console.warn("not support options.");
+    }
     if (!signedPsbt) {
       throw new Error("error psbtHex:" + psbtHex);
     }
@@ -4622,6 +4631,7 @@ var DogecoinService = class _DogecoinService extends BaseService {
     return signedRawTx;
   }
   async signPsbts({ psbtHexs, options }) {
+    console.warn("signPsbsts:", psbtHexs, options);
     throw new Error("not implemented");
   }
   async requestTransaction(txData) {
@@ -4651,6 +4661,9 @@ var DogecoinService = class _DogecoinService extends BaseService {
     fee = 0,
     options
   }) {
+    if (options) {
+      console.warn("not support options");
+    }
     if (fee <= 0) {
       throw new Error("fee is required");
     }
@@ -4745,7 +4758,7 @@ var TxTypes = /* @__PURE__ */ ((TxTypes2) => {
 
 // src/evm/utils.ts
 var isEvmChain = (network2) => {
-  return network2 && network2?.platformType === "EVM";
+  return network2?.platformType === "EVM" || false;
 };
 var getAllTypeChainIds = ({ chainId, chainType }) => {
   if (isHex(chainId)) {
@@ -4759,7 +4772,7 @@ var getAllTypeChainIds = ({ chainId, chainType }) => {
   }
   const chainIdHex = toHex$1(Number(chainId));
   return {
-    chainId,
+    chainId: String(chainId),
     chainIdHex,
     chainUid: `${chainType}:${chainId}`
   };
@@ -5073,7 +5086,7 @@ var EvmService = class _EvmService extends BaseService {
     }
   }
 };
-var BaseConfig2 = SupportedChainTypes[ChainTypeEnum.SOL];
+var BaseConfig2 = SupportedChainTypes[ChainTypeEnum.SOLANA];
 var TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 var MSG_PREFIX = "\xFFsolana offchain";
 
@@ -5112,15 +5125,7 @@ async function createLegacyTx({ from = "", to = "", amount = 0 }, connection) {
   transaction.lastValidBlockHeight = lastValidBlockHeight;
   return transaction;
 }
-async function createTokenLegacyTransaction2({
-  from = "",
-  to = "",
-  amount = 0,
-  tokenAddress = "",
-  priorityFee = 0,
-  // microLamports (1 SOL = 1e6 microLamports)
-  decimals = 6
-}, connection) {
+async function createTokenLegacyTransaction2({ from = "", to = "", amount = 0, tokenAddress = "", decimals = 6 }, connection) {
   try {
     const fromPubkey = new PublicKey(from);
     const toPubkey = new PublicKey(to);
@@ -5273,7 +5278,7 @@ var SolanaService = class _SolanaService extends BaseService {
       VersionedTransaction.deserialize(hexBuffer);
       rawTx = hexBuffer;
     } catch (error) {
-      const base58Buffer = Buffer.from(toBase58());
+      const base58Buffer = Buffer.from(toBase58(signedTx));
       VersionedTransaction.deserialize(base58Buffer);
       rawTx = base58Buffer;
     }
@@ -5325,9 +5330,11 @@ var SolanaService = class _SolanaService extends BaseService {
     return signature;
   }
   async signAllTransactions({ rawTransactions }) {
+    console.warn("signAllTransactions:", rawTransactions);
     throw new Error("no support");
   }
   async signAndSendAllTransactions({ rawTransactions }) {
+    console.warn("signAndSendAllTransactions:", rawTransactions);
     throw new Error("no support");
   }
   async queryRent(params) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/chains-service",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,
@@ -28,6 +28,7 @@
   "devDependencies": {
     "@types/supertest": "^2.0.12",
     "@vitest/browser": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
     "playwright": "^1.44.1",
     "supertest": "^6.3.0",
     "tsup": "^8.0.0",

package/project.json

@@ -50,7 +50,7 @@
       "executor": "nx:run-commands",
       "outputs": ["{projectRoot}/coverage"],
       "options": {
-        "command": "vitest run",
+        "command": "vitest run --coverage",
         "cwd": "packages/chains-service"
       }
     },

package/src/__tests__/config.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { CONFIG, getConfig } from "../config";
+
+describe("config", () => {
+  describe("getConfig", () => {
+    it("should throw when tomo stage is invalid", () => {
+      expect(() => getConfig("invalid" as any)).toThrow("Invalid tomo stage");
+    });
+  });
+
+  describe("CONFIG", () => {
+    it("should have config for prod stage", () => {
+      expect(CONFIG.prod).toBeDefined();
+      expect(CONFIG.prod.rpcBaseUrl).toBeDefined();
+      expect(CONFIG.prod.walletBaseUrl).toBeDefined();
+      expect(CONFIG.prod.txBaseUrl).toBeDefined();
+      expect(CONFIG.prod.tokenBaseUrl).toBeDefined();
+      expect(CONFIG.prod.userBaseUrl).toBeDefined();
+    });
+
+    it("should have config for pre stage", () => {
+      expect(CONFIG.pre).toBeDefined();
+      expect(CONFIG.pre.rpcBaseUrl).toBeDefined();
+      expect(CONFIG.pre.walletBaseUrl).toBeDefined();
+      expect(CONFIG.pre.txBaseUrl).toBeDefined();
+      expect(CONFIG.pre.tokenBaseUrl).toBeDefined();
+      expect(CONFIG.pre.userBaseUrl).toBeDefined();
+    });
+
+    it("should have config for dev stage", () => {
+      expect(CONFIG.dev).toBeDefined();
+      expect(CONFIG.dev.rpcBaseUrl).toBeDefined();
+      expect(CONFIG.dev.walletBaseUrl).toBeDefined();
+      expect(CONFIG.dev.txBaseUrl).toBeDefined();
+      expect(CONFIG.dev.tokenBaseUrl).toBeDefined();
+      expect(CONFIG.dev.userBaseUrl).toBeDefined();
+    });
+
+    it("should have correct URL structure", () => {
+      expect(CONFIG.dev.walletBaseUrl).toContain("/wallet");
+      expect(CONFIG.dev.txBaseUrl).toContain("/quote");
+      expect(CONFIG.dev.tokenBaseUrl).toBeDefined();
+      expect(CONFIG.dev.userBaseUrl).toContain("/user/api");
+    });
+  });
+});

package/src/__tests__/dogecoin-utils.test.ts

@@ -0,0 +1,147 @@
+import * as walletUtils from "@tomo-inc/wallet-utils";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { addUsedUtxos, getUsedUtxos, toBitcoin, toSatoshi, TransactionParser } from "../dogecoin/utils";
+
+// Mock cache while preserving other exports
+vi.mock("@tomo-inc/wallet-utils", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@tomo-inc/wallet-utils")>();
+  return {
+    ...actual,
+    cache: {
+      get: vi.fn(),
+      set: vi.fn(),
+    },
+  };
+});
+
+describe("dogecoin utils", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("toSatoshi", () => {
+    it("should convert DOGE to satoshi", () => {
+      expect(toSatoshi(1)).toBe(100000000);
+      expect(toSatoshi(0.5)).toBe(50000000);
+      expect(toSatoshi("1")).toBe(100000000);
+    });
+
+    it("should throw error for invalid amount", () => {
+      expect(() => toSatoshi(-1)).toThrow("Invalid amount");
+      expect(() => toSatoshi("invalid")).toThrow();
+    });
+
+    it("should handle zero amount", () => {
+      expect(toSatoshi(0)).toBe(0);
+    });
+  });
+
+  describe("toBitcoin", () => {
+    it("should convert satoshi to DOGE", () => {
+      expect(toBitcoin(100000000)).toBe(1);
+      expect(toBitcoin(50000000)).toBe(0.5);
+      expect(toBitcoin("100000000")).toBe(1);
+    });
+
+    it("should throw error for invalid amount", () => {
+      expect(() => toBitcoin(-1)).toThrow("Invalid Koinu amount");
+      expect(() => toBitcoin("invalid")).toThrow();
+    });
+
+    it("should handle zero amount", () => {
+      expect(toBitcoin(0)).toBe(0);
+    });
+  });
+
+  describe("addUsedUtxos", () => {
+    it("should add used UTXOs to cache", () => {
+      const cache = vi.mocked(walletUtils.cache);
+      cache.get.mockReturnValue({});
+      cache.set.mockImplementation(() => true);
+
+      const newUsedUtxos = {
+        txid1: 1,
+        txid2: 1,
+      };
+
+      addUsedUtxos(newUsedUtxos);
+
+      expect(cache.set).toHaveBeenCalled();
+    });
+  });
+
+  describe("getUsedUtxos", () => {
+    it("should get used UTXOs from cache", () => {
+      const cache = vi.mocked(walletUtils.cache);
+      const mockUsedUtxos = { txid1: 1, txid2: 1 };
+      cache.get.mockReturnValue(mockUsedUtxos);
+
+      const result = getUsedUtxos();
+      expect(result).toEqual(mockUsedUtxos);
+    });
+
+    it("should return empty object if cache is empty", () => {
+      const cache = vi.mocked(walletUtils.cache);
+      cache.get.mockReturnValue(null);
+
+      const result = getUsedUtxos();
+      expect(result).toEqual({});
+    });
+  });
+
+  describe("TransactionParser", () => {
+    it("should create parser instance", () => {
+      const parser = new TransactionParser("rawTxHex");
+      expect(parser.rawTx).toBe("rawTxHex");
+    });
+
+    describe("hexToText", () => {
+      it("should convert hex to text", () => {
+        const parser = new TransactionParser("");
+        const result = parser.hexToText("48656c6c6f"); // "Hello" in hex
+        expect(result).toBe("Hello");
+      });
+
+      it("should handle empty hex", () => {
+        const parser = new TransactionParser("");
+        const result = parser.hexToText("");
+        expect(result).toBe("");
+      });
+    });
+
+    describe("extractOPReturnData", () => {
+      it("should extract OP_RETURN data when present", () => {
+        const rawTx = "6f72647b2274797065223a2274657374227d"; // Contains "ord" and JSON
+        const parser = new TransactionParser(rawTx);
+        const result = parser.extractOPReturnData();
+        expect(result).toBeDefined();
+      });
+
+      it("should return null when OP_RETURN data not present", () => {
+        const parser = new TransactionParser("normalTxData");
+        const result = parser.extractOPReturnData();
+        expect(result).toBeNull();
+      });
+    });
+
+    describe("parseInputs", () => {
+      it("should parse transaction inputs", () => {
+        const rawTx = "0100000001" + "a".repeat(64) + "00000000" + "6f7264";
+        const parser = new TransactionParser(rawTx);
+        const inputs = parser.parseInputs();
+        expect(Array.isArray(inputs)).toBe(true);
+      });
+    });
+
+    describe("parseScript", () => {
+      it("should parse transaction script", () => {
+        const rawTx = "0100000001" + "a".repeat(64) + "00000000";
+        const parser = new TransactionParser(rawTx);
+        const result = parser.parseScript();
+        expect(result).toHaveProperty("version");
+        expect(result).toHaveProperty("inputCount");
+        expect(result).toHaveProperty("inputs");
+      });
+    });
+  });
+});