@tomo-inc/chains-service 0.0.2

package/src/api/utils/signature.ts

@@ -0,0 +1,60 @@
+import CryptoJS from "crypto-js";
+
+interface SignConfig {
+  method: string;
+  url: string;
+  data?: any;
+  apiKey: string;
+  apiSecret: string;
+  salt: string;
+  debug?: boolean;
+}
+
+/**
+ * Generate signature for API request
+ * @param config Sign configuration
+ * @returns Signature and timestamp
+ */
+export function generateSignature(config: SignConfig): { signature: string; timestamp: string } {
+  const timestamp = Math.floor(Date.now() / 1000).toString();
+  const method = config.method.toUpperCase();
+  let data = config.data ? config.data : {};
+  if (method === "GET") {
+    data = JSON.stringify({ key: "value" });
+  } else {
+    if (typeof data !== "string") {
+      data = JSON.stringify(data);
+    }
+  }
+
+  const message = [method, config.url, timestamp, data, config.apiKey, config.apiSecret, config.salt].join("");
+
+  // if (config.debug) {
+  //   console.log("Signature debug:", message);
+  // }
+
+  const signature = CryptoJS.SHA256(message).toString();
+  return { signature, timestamp };
+}
+
+/**
+ * Cube signature generation function
+ * @param data - data
+ * @param salt - salt
+ * @returns signed request object
+ */
+export const generateCubeSignature = async (data: any, salt: string) => {
+  if (!salt) {
+    throw new Error("salt is required");
+  }
+
+  const timestamp = Date.now().toString();
+  const req = {
+    ...data,
+    timestamp,
+  };
+  const reqString = JSON.stringify(req);
+  const signature = CryptoJS.SHA256(reqString + salt).toString();
+
+  return { timestamp, signature };
+};

package/src/api/wallet.ts

@@ -0,0 +1,57 @@
+import {
+  CreateWalletParams,
+  DeleteWalletParams,
+  IPublicApiBaseConfig,
+  RemoteResponse,
+  SyncWalletParams,
+} from "./types";
+import { BasePublicService } from "./base";
+import { TomoAppInfo } from "../types";
+
+export class WalletAPIs extends BasePublicService {
+  private static instance: WalletAPIs;
+
+  private constructor(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    super(apiBase, tomoAppInfo);
+  }
+
+  public static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo) {
+    if (!this.instance) {
+      this.instance = new WalletAPIs(apiBase, tomoAppInfo);
+    }
+    return this.instance;
+  }
+
+  async createWallet(params: CreateWalletParams): Promise<RemoteResponse<any>> {
+    try {
+      if (!params) throw new Error("Params is required");
+      const res = await this.walletApi.post("/v1/wallet/create", params, {});
+      return res?.data || {};
+    } catch (error: any) {
+      if (error?.response?.data?.code === "60003") {
+        return { success: false, message: "Wallet already exists", data: null };
+      }
+      console.error("Failed to create wallet:", error);
+      throw error;
+    }
+  }
+
+  async syncWallet(params: SyncWalletParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.post("/v1/wallet/sync", params, {});
+      return res?.data || {};
+    } catch (error) {
+      console.error("Failed to sync wallet:", error);
+      throw error;
+    }
+  }
+  async deleteWallet(params: DeleteWalletParams): Promise<RemoteResponse<any>> {
+    try {
+      const res = await this.walletApi.post("/v1/wallet/delete", params, {});
+      return res?.data || {};
+    } catch (error) {
+      console.error("Failed to sync wallet:", error);
+      throw error;
+    }
+  }
+}

package/src/base/network.ts

@@ -0,0 +1,55 @@
+import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+
+import { INetwork } from "../types";
+import { NetworkAPIs } from "../api/network";
+
+//chainType = all for wallet
+export class Networks {
+  private chainType: ChainTypes | "";
+  public networkAPIs: NetworkAPIs;
+
+  public constructor(networkAPIs: NetworkAPIs, chainType?: ChainTypes) {
+    this.chainType = chainType || "";
+    this.networkAPIs = networkAPIs;
+  }
+
+  public setChainType(chainType: ChainTypes): void {
+    this.chainType = chainType;
+  }
+
+  public async getNetworks(chainType?: ChainTypes | ""): Promise<INetwork[]> {
+    const networks = this.networkAPIs.getAllNetworks(chainType || "");
+    return networks;
+  }
+
+  public async getNetworkByChainId(chainId: string): Promise<INetwork> {
+    const network = await this.networkAPIs.getNetworkByChainId(chainId);
+    if (!network) {
+      throw new Error("Network not found");
+    }
+    return network;
+  }
+
+  public async getNetworkByChainIndex(chainIndex: number): Promise<INetwork> {
+    const network = await this.networkAPIs.getNetworkByChainIndex(chainIndex);
+    if (!network) {
+      throw new Error("Network not found");
+    }
+    return network;
+  }
+
+  public async getCurrentNetwork(): Promise<INetwork> {
+    const chainType = this.chainType as keyof typeof SupportedChainTypes;
+    let chainId = await this.networkAPIs.getCurrentNetwork(chainType);
+    if (chainId === "") {
+      chainId = SupportedChainTypes?.[chainType]?.chainId || "";
+    }
+    return this.getNetworkByChainId(chainId);
+  }
+
+  public async setCurrentNetwork(chainId: string): Promise<boolean> {
+    const chainType = this.chainType || "";
+    await this.networkAPIs.setCurrentNetwork(chainType, chainId);
+    return true;
+  }
+}

package/src/base/service.ts

@@ -0,0 +1,33 @@
+import { Networks } from "./network";
+import { Tokens } from "./token";
+import { Transactions } from "./transaction";
+
+import { CONFIG } from "../config";
+import { tomoPublicApiService } from "../api";
+import { TomoAppInfo } from "../types";
+
+export class BaseService {
+  public isDappConnected: boolean;
+  public approveParams: any;
+  public accountInfo: any;
+  public networks: Networks;
+  public tokens: Tokens;
+  public transactions: Transactions;
+
+  public constructor(tomoAppInfo: TomoAppInfo, accountInfo?: any) {
+    if (!tomoAppInfo.tomoStage || !CONFIG[tomoAppInfo.tomoStage]) {
+      throw new Error("Tomo stage is required");
+    }
+    const baseUrlConfig = CONFIG[tomoAppInfo.tomoStage];
+    const { tokenAPIs, transactionAPIs, networkAPIs } = tomoPublicApiService(baseUrlConfig, tomoAppInfo);
+    this.accountInfo = accountInfo;
+    this.networks = new Networks(networkAPIs);
+    this.tokens = new Tokens(tokenAPIs);
+    this.transactions = new Transactions(transactionAPIs);
+    this.isDappConnected = false;
+  }
+
+  public async setApproveParams(params: any) {
+    this.approveParams = params;
+  }
+}

package/src/base/token.ts

@@ -0,0 +1,43 @@
+//types
+import { TokenInfo } from "../types";
+import { TokenAPIs } from "../api/token";
+
+export class Tokens {
+  public tokenAPIs: TokenAPIs;
+
+  public constructor(tokenService: TokenAPIs) {
+    this.tokenAPIs = tokenService;
+  }
+
+  public async searchTokens({ chainIndex, query }: { chainIndex?: number; query?: string }): Promise<TokenInfo[]> {
+    const { data: tokens = [] }: any = await this.tokenAPIs.queryRemoteTokens({ keyword: query || "", chainIndex });
+    return tokens;
+  }
+
+  // public async addToken(tokenInfo: Omit<TokenInfo, "id">): Promise<TokenInfo> {
+  //   const { data: tokenInfoData }: any = await this.tokenService.addCustomToken(tokenInfo as any);
+  //   return tokenInfoData;
+  // }
+
+  public async getTokenInfo({ address, chainIndex }: { address: string; chainIndex: number }): Promise<TokenInfo> {
+    const {
+      data: { data: tokenInfo },
+    }: any = await this.tokenAPIs.getTokenInfo({ address, chainIndex });
+    return tokenInfo;
+  }
+
+  public async getTokenRiskInfo(_params: { chainIndex: number; tokenAddress: string }): Promise<any> {
+    const { data: tokenRiskInfo }: any = await this.tokenAPIs.getTokenRisk(_params);
+    return tokenRiskInfo;
+  }
+
+  public async getTokenDetail(_params: { chainName: string; chainIndex: number; tokenAddress: string }): Promise<any> {
+    const { data }: any = await this.tokenAPIs.getTokenDetail(_params);
+    return data;
+  }
+
+  // public async addMyToken(tokenId: string): Promise<boolean> {
+  //   const { success = false } = (await this.tokenService.addAccountToken({ tokenId })) as { success: boolean };
+  //   return success;
+  // }
+}

package/src/base/transaction.ts

@@ -0,0 +1,58 @@
+import { TransactionAPIs } from "../api/transaction";
+import { QueryGasParams } from "../types";
+
+import { ChainTypes } from "@tomo-inc/wallet-utils";
+const MYDOGE_PLATFORM_IN_SERVICE = 4;
+
+const notSupportChainTypes = {
+  [ChainTypes.BTC]: true,
+  [ChainTypes.COSMOS]: true,
+  [ChainTypes.DOGE]: true,
+};
+
+//src/background/services/socials/tomo.ts
+export class Transactions {
+  public transactionAPIs: TransactionAPIs;
+
+  public constructor(transactionAPIs: TransactionAPIs) {
+    this.transactionAPIs = transactionAPIs;
+  }
+
+  /*
+    baseFee: 1
+    gasLimit: 0
+    priorityFeeHigh: 0
+    priorityFeeLow: 0
+    priorityFeeMedium: 0
+    */
+  public async queryGasInfo({ chainType, params }: { chainType: string; params: QueryGasParams }): Promise<any> {
+    try {
+      const res: any = await this.transactionAPIs.queryGasInfo(chainType, params as any);
+      return {
+        success: res?.code === 0,
+        data: res?.result || {},
+      };
+    } catch (err: any) {
+      return {
+        success: false,
+        message: err?.message || "Failed to query gas info",
+      };
+    }
+  }
+
+  public async getTransactions(params: {
+    walletId: string;
+    chainIndex: number;
+    pageLimit?: number;
+    cursor?: string;
+  }): Promise<{ cursor: string; transactionList: any[] }> {
+    const res: any = await this.transactionAPIs.getTransactions(params);
+    const { cursor = "", transactionList = [] } = res || {};
+    return { cursor, transactionList };
+  }
+
+  public async getTransaction(params: { walletId: string; txHash: string; chainIndex: number }): Promise<any> {
+    const res: any = await this.transactionAPIs.getTransaction(params);
+    return res?.data || {};
+  }
+}

package/src/config.ts

@@ -0,0 +1,21 @@
+import { TomoApiDomains, TomoStage } from "@tomo-inc/wallet-utils";
+
+function getConfig(tomoStage: TomoStage) {
+  const domain = TomoApiDomains[tomoStage];
+  if (!domain) {
+    throw new Error("Invalid tomo stage");
+  }
+  return {
+    rpcBaseUrl: `${domain}`,
+    walletBaseUrl: `${domain}/wallet`,
+    txBaseUrl: `${domain}/quote`,
+    tokenBaseUrl: `${domain}/token`,
+    userBaseUrl: `${domain}/user/api`,
+  };
+}
+
+export const CONFIG = {
+  prod: getConfig("prod"),
+  pre: getConfig("pre"),
+  dev: getConfig("dev"),
+};

package/src/dogecoin/base.ts

@@ -0,0 +1,39 @@
+export function fromHex(hex: string): Uint8Array {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+
+  const paddedHex = cleanHex.length % 2 === 0 ? cleanHex : "0" + cleanHex;
+
+  const bytes = new Uint8Array(paddedHex.length / 2);
+  for (let i = 0; i < paddedHex.length; i += 2) {
+    bytes[i / 2] = parseInt(paddedHex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+
+export function toHex(data: Uint8Array | Buffer | string): string {
+  if (typeof data === "string") {
+    return data.startsWith("0x") ? data.slice(2) : data;
+  }
+
+  const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  return buffer.toString("hex");
+}
+
+export function toBase64(data: Uint8Array | Buffer | string): string {
+  if (typeof data === "string") {
+    const buffer = Buffer.from(data, "hex");
+    return buffer.toString("base64");
+  }
+
+  const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  return buffer.toString("base64");
+}
+
+export function fromBase64(base64: string): Uint8Array {
+  const buffer = Buffer.from(base64, "base64");
+  return new Uint8Array(buffer);
+}
+
+export function toBase58(data: Uint8Array | Buffer | string): string {
+  throw new Error("toBase58 requires bs58 package. Install it: pnpm add bs58");
+}

package/src/dogecoin/config.ts

@@ -0,0 +1,43 @@
+import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+
+export const BaseConfig = SupportedChainTypes[ChainTypes.DOGE] as any;
+
+export const BLOCK_CONFIRMATIONS = 1;
+export const FEE_RATE_KB = 0.5;
+
+export const DOGE_DECIMALS = 8;
+export const DECIMALS = 100000000; //10..8
+
+export const NOWNODES_SLEEP_S = 10;
+export const MAX_CHUNK_LEN = 240;
+export const MAX_PAYLOAD_LEN = 1500;
+
+export const TRANSACTION_PAGE_SIZE = 10;
+
+export const NETWORK = "livenet";
+export const MYDOGE_BASE_URL = "https://api.mydoge.com";
+export const TX_LINK = "https://chain.so/tx/DOGE/";
+
+export const RPC_URL = "https://api.bitcore.io/api/DOGE/mainnet";
+export const RPC_TIMEOUT = 20 * 1000;
+
+export const TX_OVERHEAD = 10;
+export const P2SH_INPUT_SIZE = 148;
+export const TX_OUTPUT_SIZE = 34;
+
+export const DEFAULT_OUTPUT_COUNT = 2;
+
+export const TX_SIZE = 1 * P2SH_INPUT_SIZE + DEFAULT_OUTPUT_COUNT * TX_OUTPUT_SIZE + TX_OVERHEAD;
+
+export const network = {
+  messagePrefix: "\x19Dogecoin Signed Message:\n",
+  bech32: "dc",
+  bip44: 3,
+  bip32: {
+    public: 0x02facafd,
+    private: 0x02fac398,
+  },
+  pubKeyHash: 0x1e,
+  scriptHash: 0x16,
+  wif: 0x9e,
+};