@tomo-inc/chains-service 0.0.9 → 0.0.10

package/dist/index.cjs

@@ -2909,24 +2909,6 @@ var Transactions = class {
     return res?.data || {};
   }
 };
-function getConfig(tomoStage) {
-  const domain = walletUtils.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`
-  };
-}
-var CONFIG = {
-  prod: getConfig("prod"),
-  pre: getConfig("pre"),
-  dev: getConfig("dev")
-};
 function generateSignature(config) {
   const timestamp = Math.floor(Date.now() / 1e3).toString();
   const method = config.method.toUpperCase();
@@ -3915,6 +3897,24 @@ function tomoPublicApiService(publicApiBase, tomoAppInfo) {
     walletAPIs: WalletAPIs.getInstance(publicApiBase, tomoAppInfo)
   };
 }
+function getConfig(tomoStage) {
+  const domain = walletUtils.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`
+  };
+}
+var CONFIG = {
+  prod: getConfig("prod"),
+  pre: getConfig("pre"),
+  dev: getConfig("dev")
+};
 
 // src/base/service.ts
 var BaseService = class {
@@ -4489,21 +4489,10 @@ var DogecoinService = class _DogecoinService extends BaseService {
   }
   async requestAccounts() {
     const addresses = await this.accountInfo.getCurrent();
-    const { publicKey, address } = addresses?.[0] || {};
-    if (!address) {
-      throw new Error("address is not set");
-    }
-    const { balance = 0 } = await getBalance(address);
-    return {
-      address,
-      balance,
-      approved: true,
-      publicKey
-    };
+    return addresses.map((account) => account.address);
   }
   async getAccounts() {
-    const accounts = await this.accountInfo.getCurrent();
-    return accounts.map((account) => account.address);
+    return await this.requestAccounts();
   }
   async getConnectionStatus() {
     const addresses = await this.accountInfo.getCurrent();
@@ -4525,8 +4514,9 @@ var DogecoinService = class _DogecoinService extends BaseService {
     }
     const { balance = 0 } = await getBalance(address);
     return {
-      address,
-      balance
+      confirmed: balance,
+      unconfirmed: 0,
+      total: balance
     };
   }
   async signMessage({ message, type }) {
@@ -4534,18 +4524,19 @@ var DogecoinService = class _DogecoinService extends BaseService {
       throw new Error("bip322simple not support.");
     }
     const signature = await this.accountInfo.signMessage(message);
-    return {
-      signedMessage: signature
-    };
+    return signature;
   }
   async requestSignedMessage({
     message,
     type
   }) {
-    return await this.signMessage({
+    const signedMessage = await this.signMessage({
       message,
       type
     });
+    return {
+      signedMessage
+    };
   }
   async _queryGasInfo(txData) {
     const { chainId, amount = 0, decimals = 8 } = txData;
@@ -4613,6 +4604,18 @@ var DogecoinService = class _DogecoinService extends BaseService {
       signedRawTx
     };
   }
+  async signPsbt({ psbtHex, options }) {
+    const psbtBase64 = toBase64(fromHex(psbtHex));
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+    if (!signedPsbt) {
+      throw new Error("error psbtHex:" + psbtHex);
+    }
+    const signedRawTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 1e5);
+    return signedRawTx;
+  }
+  async signPsbts({ psbtHexs, options }) {
+    throw new Error("not implemented");
+  }
   async requestTransaction(txData) {
     const spendableUtxos = txData?.spendableUtxos;
     if (txData.amountMismatch) {
@@ -4635,6 +4638,34 @@ var DogecoinService = class _DogecoinService extends BaseService {
       throw new Error("Error: send transaction err." + JSON.stringify(err));
     }
   }
+  async send({
+    toAddress,
+    amount,
+    fee = 0,
+    options
+  }) {
+    if (fee <= 0) {
+      throw new Error("fee is required");
+    }
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    const txData = {
+      to: toAddress,
+      amount: toBitcoin(amount),
+      fee: toBitcoin(fee || 0),
+      from: address
+    };
+    const res = await this.requestTransaction(txData);
+    return res?.txId || "";
+  }
+  async sendDogecoin({
+    toAddress,
+    amount,
+    options,
+    fee
+  }) {
+    return await this.send({ toAddress, amount, options, fee });
+  }
   async getTransactionStatus({ txId }) {
     const transaction = await getTxDetail(txId);
     if (!transaction?.txid) {

package/dist/index.d.cts

@@ -518,12 +518,7 @@ declare class DogecoinService extends BaseService {
     rpcService: typeof API;
     constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
     static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): DogecoinService;
-    requestAccounts(): Promise<{
-        address: string;
-        balance: number;
-        approved: boolean;
-        publicKey: string;
-    }>;
+    requestAccounts(): Promise<string[]>;
     getAccounts(): Promise<string[]>;
     getConnectionStatus(): Promise<{
         connected: boolean;
@@ -531,15 +526,14 @@ declare class DogecoinService extends BaseService {
         selectedWalletAddress: string;
     }>;
     getBalance(): Promise<{
-        address: string;
-        balance: number;
+        confirmed: number;
+        unconfirmed: number;
+        total: number;
     }>;
     signMessage({ message, type }: {
         message: string;
         type?: string;
-    }): Promise<{
-        signedMessage: string;
-    }>;
+    }): Promise<string>;
     requestSignedMessage({ message, type, }: {
         message: string;
         type?: string;
@@ -554,9 +548,35 @@ declare class DogecoinService extends BaseService {
         signedRawTx: string;
         txId?: string;
     } | null>;
+    signPsbt({ psbtHex, options }: {
+        psbtHex: string;
+        options?: any;
+    }): Promise<string>;
+    signPsbts({ psbtHexs, options }: {
+        psbtHexs: string[];
+        options?: any;
+    }): Promise<string[]>;
     requestTransaction(txData: DogeTxData): Promise<{
         txId: string;
     } | null>;
+    send({ toAddress, amount, fee, options, }: {
+        toAddress: string;
+        amount: number;
+        fee: number;
+        options?: {
+            feeRate: number;
+            memo?: string;
+        };
+    }): Promise<string>;
+    sendDogecoin({ toAddress, amount, options, fee, }: {
+        toAddress: string;
+        amount: number;
+        fee: number;
+        options?: {
+            feeRate: number;
+            memo?: string;
+        };
+    }): Promise<string>;
     getTransactionStatus({ txId }: {
         txId: string;
     }): Promise<any>;

package/dist/index.d.ts

@@ -518,12 +518,7 @@ declare class DogecoinService extends BaseService {
     rpcService: typeof API;
     constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
     static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): DogecoinService;
-    requestAccounts(): Promise<{
-        address: string;
-        balance: number;
-        approved: boolean;
-        publicKey: string;
-    }>;
+    requestAccounts(): Promise<string[]>;
     getAccounts(): Promise<string[]>;
     getConnectionStatus(): Promise<{
         connected: boolean;
@@ -531,15 +526,14 @@ declare class DogecoinService extends BaseService {
         selectedWalletAddress: string;
     }>;
     getBalance(): Promise<{
-        address: string;
-        balance: number;
+        confirmed: number;
+        unconfirmed: number;
+        total: number;
     }>;
     signMessage({ message, type }: {
         message: string;
         type?: string;
-    }): Promise<{
-        signedMessage: string;
-    }>;
+    }): Promise<string>;
     requestSignedMessage({ message, type, }: {
         message: string;
         type?: string;
@@ -554,9 +548,35 @@ declare class DogecoinService extends BaseService {
         signedRawTx: string;
         txId?: string;
     } | null>;
+    signPsbt({ psbtHex, options }: {
+        psbtHex: string;
+        options?: any;
+    }): Promise<string>;
+    signPsbts({ psbtHexs, options }: {
+        psbtHexs: string[];
+        options?: any;
+    }): Promise<string[]>;
     requestTransaction(txData: DogeTxData): Promise<{
         txId: string;
     } | null>;
+    send({ toAddress, amount, fee, options, }: {
+        toAddress: string;
+        amount: number;
+        fee: number;
+        options?: {
+            feeRate: number;
+            memo?: string;
+        };
+    }): Promise<string>;
+    sendDogecoin({ toAddress, amount, options, fee, }: {
+        toAddress: string;
+        amount: number;
+        fee: number;
+        options?: {
+            feeRate: number;
+            memo?: string;
+        };
+    }): Promise<string>;
     getTransactionStatus({ txId }: {
         txId: string;
     }): Promise<any>;

package/dist/index.js

@@ -2901,24 +2901,6 @@ var Transactions = class {
     return res?.data || {};
   }
 };
-function getConfig(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`
-  };
-}
-var CONFIG = {
-  prod: getConfig("prod"),
-  pre: getConfig("pre"),
-  dev: getConfig("dev")
-};
 function generateSignature(config) {
   const timestamp = Math.floor(Date.now() / 1e3).toString();
   const method = config.method.toUpperCase();
@@ -3907,6 +3889,24 @@ function tomoPublicApiService(publicApiBase, tomoAppInfo) {
     walletAPIs: WalletAPIs.getInstance(publicApiBase, tomoAppInfo)
   };
 }
+function getConfig(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`
+  };
+}
+var CONFIG = {
+  prod: getConfig("prod"),
+  pre: getConfig("pre"),
+  dev: getConfig("dev")
+};
 
 // src/base/service.ts
 var BaseService = class {
@@ -4481,21 +4481,10 @@ var DogecoinService = class _DogecoinService extends BaseService {
   }
   async requestAccounts() {
     const addresses = await this.accountInfo.getCurrent();
-    const { publicKey, address } = addresses?.[0] || {};
-    if (!address) {
-      throw new Error("address is not set");
-    }
-    const { balance = 0 } = await getBalance(address);
-    return {
-      address,
-      balance,
-      approved: true,
-      publicKey
-    };
+    return addresses.map((account) => account.address);
   }
   async getAccounts() {
-    const accounts = await this.accountInfo.getCurrent();
-    return accounts.map((account) => account.address);
+    return await this.requestAccounts();
   }
   async getConnectionStatus() {
     const addresses = await this.accountInfo.getCurrent();
@@ -4517,8 +4506,9 @@ var DogecoinService = class _DogecoinService extends BaseService {
     }
     const { balance = 0 } = await getBalance(address);
     return {
-      address,
-      balance
+      confirmed: balance,
+      unconfirmed: 0,
+      total: balance
     };
   }
   async signMessage({ message, type }) {
@@ -4526,18 +4516,19 @@ var DogecoinService = class _DogecoinService extends BaseService {
       throw new Error("bip322simple not support.");
     }
     const signature = await this.accountInfo.signMessage(message);
-    return {
-      signedMessage: signature
-    };
+    return signature;
   }
   async requestSignedMessage({
     message,
     type
   }) {
-    return await this.signMessage({
+    const signedMessage = await this.signMessage({
       message,
       type
     });
+    return {
+      signedMessage
+    };
   }
   async _queryGasInfo(txData) {
     const { chainId, amount = 0, decimals = 8 } = txData;
@@ -4605,6 +4596,18 @@ var DogecoinService = class _DogecoinService extends BaseService {
       signedRawTx
     };
   }
+  async signPsbt({ psbtHex, options }) {
+    const psbtBase64 = toBase64(fromHex(psbtHex));
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+    if (!signedPsbt) {
+      throw new Error("error psbtHex:" + psbtHex);
+    }
+    const signedRawTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 1e5);
+    return signedRawTx;
+  }
+  async signPsbts({ psbtHexs, options }) {
+    throw new Error("not implemented");
+  }
   async requestTransaction(txData) {
     const spendableUtxos = txData?.spendableUtxos;
     if (txData.amountMismatch) {
@@ -4627,6 +4630,34 @@ var DogecoinService = class _DogecoinService extends BaseService {
       throw new Error("Error: send transaction err." + JSON.stringify(err));
     }
   }
+  async send({
+    toAddress,
+    amount,
+    fee = 0,
+    options
+  }) {
+    if (fee <= 0) {
+      throw new Error("fee is required");
+    }
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    const txData = {
+      to: toAddress,
+      amount: toBitcoin(amount),
+      fee: toBitcoin(fee || 0),
+      from: address
+    };
+    const res = await this.requestTransaction(txData);
+    return res?.txId || "";
+  }
+  async sendDogecoin({
+    toAddress,
+    amount,
+    options,
+    fee
+  }) {
+    return await this.send({ toAddress, amount, options, fee });
+  }
   async getTransactionStatus({ txId }) {
     const transaction = await getTxDetail(txId);
     if (!transaction?.txid) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/chains-service",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,
@@ -23,7 +23,7 @@
     "bitcoinjs-lib": "^7.0.0",
     "crypto-js": "4.2.0",
     "viem": "2.21.54",
-    "@tomo-inc/wallet-utils": "0.0.8"
+    "@tomo-inc/wallet-utils": "0.0.9"
   },
   "devDependencies": {
     "@types/supertest": "^2.0.12",

package/src/api/network.ts

@@ -1,8 +1,8 @@
 import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
-import { loadNetworks } from "./network-data";
+import { INetwork, TomoAppInfo } from "../types";
 import { BasePublicService } from "./base";
+import { loadNetworks } from "./network-data";
 import { IPublicApiBaseConfig } from "./types";
-import { INetwork, TomoAppInfo } from "../types";
 
 import { cache } from "@tomo-inc/wallet-utils";
 
@@ -29,7 +29,6 @@ export class NetworkAPIs extends BasePublicService {
         nativeCurrency,
       };
     });
-
     this.currentChainId = "1";
   }
 

package/src/api/token.ts

@@ -1,16 +1,16 @@
+import { TomoAppInfo } from "../types";
+import { BasePublicService } from "./base";
 import {
-  GetTokenInfoParams,
-  RemoteResponse,
-  RemoteTokenInfo,
   AddCustomTokenParams,
   DeleteCustomTokenParams,
-  SyncCustomTokenParams,
   GetTokenBalanceParams,
   GetTokenBalanceResponse,
+  GetTokenInfoParams,
   IPublicApiBaseConfig,
+  RemoteResponse,
+  RemoteTokenInfo,
+  SyncCustomTokenParams,
 } from "./types";
-import { BasePublicService } from "./base";
-import { TomoAppInfo } from "../types";
 
 export class TokenAPIs extends BasePublicService {
   private static instance: TokenAPIs;

package/src/base/service.ts

@@ -2,8 +2,8 @@ import { Networks } from "./network";
 import { Tokens } from "./token";
 import { Transactions } from "./transaction";
 
-import { CONFIG } from "../config";
 import { tomoPublicApiService } from "../api";
+import { CONFIG } from "../config";
 import { IAccountInfo, TomoAppInfo } from "../types";
 
 export class BaseService {

package/src/base/token.ts

@@ -1,7 +1,7 @@
 //types
-import { TokenInfo } from "../types";
 import { TokenAPIs } from "../api/token";
 import { GetTokenInfoParams } from "../api/types";
+import { TokenInfo } from "../types";
 
 export class Tokens {
   public tokenAPIs: TokenAPIs;

package/src/dogecoin/service.ts

@@ -12,9 +12,10 @@ import { TransactionParams } from "./type";
 import * as API from "./rpc";
 import * as utils from "./utils";
 import { DogeTxData } from "./type";
+import * as base from "./base";
 
 import { BaseConfig } from "./config";
-import { createPsbt, addUsedUtxos } from "./utils";
+import { createPsbt, addUsedUtxos, toBitcoin } from "./utils";
 
 export class DogecoinService extends BaseService {
   private static instance: DogecoinService;
@@ -34,25 +35,14 @@ export class DogecoinService extends BaseService {
     }
     return DogecoinService.instance;
   }
-  public async requestAccounts(): Promise<{ address: string; balance: number; approved: boolean; publicKey: string }> {
-    const addresses = await this.accountInfo.getCurrent();
-    const { publicKey, address } = addresses?.[0] || {};
-    if (!address) {
-      throw new Error("address is not set");
-    }
-    const { balance = 0 } = await API.getBalance(address);
 
-    return {
-      address,
-      balance,
-      approved: true,
-      publicKey,
-    };
+  public async requestAccounts(): Promise<string[]> {
+    const addresses = await this.accountInfo.getCurrent();
+    return addresses.map((account: { address: string }) => account.address);
   }
 
   public async getAccounts(): Promise<string[]> {
-    const accounts = await this.accountInfo.getCurrent();
-    return accounts.map((account: { address: string }) => account.address);
+    return await this.requestAccounts();
   }
 
   public async getConnectionStatus(): Promise<{ connected: boolean; address: string; selectedWalletAddress: string }> {
@@ -68,7 +58,7 @@ export class DogecoinService extends BaseService {
     };
   }
 
-  public async getBalance(): Promise<{ address: string; balance: number }> {
+  public async getBalance(): Promise<{ confirmed: number; unconfirmed: number; total: number }> {
     const addresses = await this.accountInfo.getCurrent();
     const { address } = addresses?.[0] || {};
     if (!address) {
@@ -78,21 +68,20 @@ export class DogecoinService extends BaseService {
     const { balance = 0 } = await API.getBalance(address);
 
     return {
-      address,
-      balance,
+      confirmed: balance,
+      unconfirmed: 0,
+      total: balance,
     };
   }
 
-  public async signMessage({ message, type }: { message: string; type?: string }): Promise<{ signedMessage: string }> {
+  public async signMessage({ message, type }: { message: string; type?: string }): Promise<string> {
     if (type) {
       throw new Error("bip322simple not support.");
     }
 
     const signature = await this.accountInfo.signMessage(message);
 
-    return {
-      signedMessage: signature,
-    };
+    return signature;
   }
 
   public async requestSignedMessage({
@@ -102,10 +91,13 @@ export class DogecoinService extends BaseService {
     message: string;
     type?: string;
   }): Promise<{ signedMessage: string }> {
-    return await this.signMessage({
+    const signedMessage = await this.signMessage({
       message,
       type,
     });
+    return {
+      signedMessage,
+    };
   }
 
   public async _queryGasInfo(txData: TransactionParams): Promise<QueryGasResponse> {
@@ -187,6 +179,22 @@ export class DogecoinService extends BaseService {
     };
   }
 
+  public async signPsbt({ psbtHex, options }: { psbtHex: string; options?: any }): Promise<string> {
+    const psbtBase64 = base.toBase64(base.fromHex(psbtHex));
+    const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
+
+    if (!signedPsbt) {
+      throw new Error("error psbtHex:" + psbtHex);
+    }
+
+    const signedRawTx = DogecoinUtils.extractPsbtTransaction(signedPsbt, 100000);
+    return signedRawTx;
+  }
+
+  public async signPsbts({ psbtHexs, options }: { psbtHexs: string[]; options?: any }): Promise<string[]> {
+    throw new Error("not implemented");
+  }
+
   public async requestTransaction(txData: DogeTxData): Promise<{ txId: string } | null> {
     //txData = createTx;
     const spendableUtxos = txData?.spendableUtxos;
@@ -213,6 +221,46 @@ export class DogecoinService extends BaseService {
     }
   }
 
+  public async send({
+    toAddress,
+    amount,
+    fee = 0,
+    options,
+  }: {
+    toAddress: string;
+    amount: number; //satoshis
+    fee: number; //satoshis
+    options?: { feeRate: number; memo?: string };
+  }): Promise<string> {
+    if (fee <= 0) {
+      throw new Error("fee is required");
+    }
+    const addresses = await this.accountInfo.getCurrent();
+    const { address } = addresses?.[0] || {};
+    const txData: DogeTxData = {
+      to: toAddress,
+      amount: toBitcoin(amount),
+      fee: toBitcoin(fee || 0),
+      from: address,
+    };
+    const res: any = await this.requestTransaction(txData);
+    return res?.txId || "";
+  }
+
+  public async sendDogecoin({
+    toAddress,
+    amount,
+    options,
+    fee,
+  }: {
+    toAddress: string;
+    amount: number;
+    fee: number;
+    options?: { feeRate: number; memo?: string };
+  }): Promise<string> {
+    return await this.send({ toAddress, amount, options, fee });
+  }
+
   public async getTransactionStatus({ txId }: { txId: string }): Promise<any> {
     const transaction = await API.getTxDetail(txId);
     if (!transaction?.txid) {

package/src/evm/service.ts

@@ -6,26 +6,26 @@ import {
   fromHex,
   hexToBigInt,
   http,
+  isAddressEqual,
   isHex,
   numberToHex,
   parseTransaction,
   parseUnits,
   toHex,
   Transaction,
-  isAddressEqual,
 } from "viem";
 
 import { BaseService } from "../base/service";
 import { getRPCClient } from "./rpc";
 
 import {
-  QueryGasParams,
-  ITypedData,
+  IAccountInfo,
   INetwork,
+  ITypedData,
+  QueryGasParams,
+  QueryGasResponse,
   TomoAppInfo,
-  IAccountInfo,
   TransactionParams,
-  QueryGasResponse,
 } from "../types";
 import { createErc20TxData, getAllTypeChainIds, isEvmChain } from "./utils";