@tomo-inc/chains-service 0.0.7 → 0.0.9

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { ChainTypes, TomoStage } from '@tomo-inc/wallet-utils';
-import { Transaction } from 'viem';
+import * as axios from 'axios';
 import { AxiosInstance } from 'axios';
+import { Transaction as Transaction$1 } from 'viem';
+import { Psbt } from 'bitcoinjs-lib';
 
 declare enum AccountType {
     EOA = "EOA",
@@ -16,9 +18,9 @@ interface ChainAddress {
 interface IAccount {
     readonly id: string;
     readonly userId?: string | number;
-    readonly name: string;
+    readonly name?: string;
     readonly type: AccountType;
-    readonly lastUsedTime: number;
+    readonly lastUsedTime?: number;
     readonly sortIndex?: number;
     readonly addresses: Record<ChainTypes, ChainAddress[]>;
     readonly mnemonic: string | null;
@@ -30,11 +32,12 @@ interface IAccount {
     readonly externalId?: string | number;
     readonly totalAssets?: string;
 }
-interface IaccountInfo {
+interface IAccountInfo {
     getCurrent: () => Promise<any[]>;
     signMessage: (message: string) => Promise<string>;
     signTypedData: (message: any) => Promise<string>;
     signTransaction: (transaction: any) => Promise<string>;
+    decryptedMessage?: (message: string) => Promise<any>;
 }
 
 interface QueryGasParams {
@@ -128,7 +131,7 @@ interface ITypedData {
     domain: any;
     message: any;
 }
-type TransactionParams = Omit<any, "rpcUrl">;
+type TransactionParams$1 = Omit<any, "rpcUrl">;
 
 declare enum TxTypes {
     swap = 1,
@@ -178,9 +181,9 @@ interface TransactionsResponse {
 interface TomoAppInfo {
     tomoStage: TomoStage;
     tomoClientId: string;
-    apiKey: string;
-    apiSecret: string;
-    salt: string;
+    apiKey?: string;
+    apiSecret?: string;
+    salt?: string;
     jwtToken?: string;
 }
 type TokenInfo = any;
@@ -330,20 +333,14 @@ declare class TokenAPIs extends BasePublicService {
     private constructor();
     static getInstance(apiBase: IPublicApiBaseConfig, tomoAppInfo: TomoAppInfo): TokenAPIs;
     getTokenInfo(params: GetTokenInfoParams): Promise<RemoteResponse<RemoteTokenInfo>>;
-    getTokenRisk(params: {
-        chainIndex: number;
-        tokenAddress: string;
-    }): Promise<RemoteResponse<any>>;
+    getTokenRisk(params: GetTokenInfoParams): Promise<RemoteResponse<any>>;
     addCustomToken(params: AddCustomTokenParams): Promise<RemoteResponse<any>>;
     deleteCustomToken(params: DeleteCustomTokenParams): Promise<RemoteResponse<any>>;
     addMultiToken(params: AddCustomTokenParams): Promise<RemoteResponse<any>>;
     removeMultiToken(params: DeleteCustomTokenParams): Promise<RemoteResponse<any>>;
     syncCustomToken(params: SyncCustomTokenParams): Promise<RemoteResponse<any>>;
     getTokenBalance(params: GetTokenBalanceParams): Promise<RemoteResponse<GetTokenBalanceResponse>>;
-    getTokenDetail(params: {
-        chainIndex: number;
-        tokenAddress: string;
-    }): Promise<RemoteResponse<any>>;
+    getTokenDetail(params: GetTokenInfoParams): Promise<RemoteResponse<any>>;
     queryRemoteTokens(params: {
         keyword: string;
         chainIndex?: number;
@@ -353,23 +350,13 @@ declare class TokenAPIs extends BasePublicService {
 declare class Tokens {
     tokenAPIs: TokenAPIs;
     constructor(tokenService: TokenAPIs);
-    searchTokens({ chainIndex, query }: {
+    searchTokens({ chainIndex, keyword }: {
         chainIndex?: number;
-        query?: string;
+        keyword: string;
     }): Promise<TokenInfo[]>;
-    getTokenInfo({ address, chainIndex }: {
-        address: string;
-        chainIndex: number;
-    }): Promise<TokenInfo>;
-    getTokenRiskInfo(_params: {
-        chainIndex: number;
-        tokenAddress: string;
-    }): Promise<any>;
-    getTokenDetail(_params: {
-        chainName: string;
-        chainIndex: number;
-        tokenAddress: string;
-    }): Promise<any>;
+    getTokenInfo({ address, chainIndex }: GetTokenInfoParams): Promise<TokenInfo>;
+    getTokenRiskInfo(_params: GetTokenInfoParams): Promise<any>;
+    getTokenDetail(_params: GetTokenInfoParams): Promise<any>;
 }
 
 declare class TransactionAPIs extends BasePublicService {
@@ -407,19 +394,179 @@ declare class Transactions {
 declare class BaseService {
     isDappConnected: boolean;
     approveParams: any;
-    accountInfo: any;
+    accountInfo: IAccountInfo;
     networks: Networks;
     tokens: Tokens;
     transactions: Transactions;
-    constructor(tomoAppInfo: TomoAppInfo, accountInfo?: any);
+    constructor(tomoAppInfo: TomoAppInfo, accountInfo?: IAccountInfo);
     setApproveParams(params: any): Promise<void>;
 }
 
+type DogeSpendableUtxos = {
+    txid: string;
+    vout: number;
+    outputValue: number;
+    script: string;
+    tx?: {
+        txid: string;
+        vout: number;
+    };
+};
+interface TransactionParams {
+    accountId?: string;
+    from: string;
+    to: string;
+    fee?: string;
+    amount: number;
+    decimals?: number;
+    chainId?: number | string;
+    tokenAddress?: string;
+}
+interface DogeTxData {
+    amountMismatch?: boolean;
+    amount: number;
+    fee: number;
+    to: string;
+    from: string;
+    senderAddress?: string;
+    sender?: string;
+    fromAddress?: string;
+    spendableUtxos?: DogeSpendableUtxos[];
+}
+
+declare const mydoge: axios.AxiosInstance;
+declare function getBalance(address?: string): Promise<any>;
+type Transaction = {
+    blockHash: string;
+    blockHeight: number;
+    blockTime: number;
+    confirmations: number;
+    fees: string;
+    hex: string;
+    size: number;
+    txid: string;
+    value: string;
+    valueIn: string;
+    version: number;
+    vin: {
+        addresses: string[];
+        hex: string;
+        isAddress: boolean;
+        n: number;
+        sequence: number;
+        txid: string;
+        value: string;
+    }[];
+    vout: {
+        addresses: string[];
+        value: string;
+        n: number;
+        hex: string;
+        isAddress: boolean;
+    }[];
+};
+declare function getTxDetail(txId: string): Promise<Transaction>;
+declare function getInscriptionsUtxos(address: string): Promise<any[]>;
+declare function getSpendableUtxos(address: string): Promise<any[]>;
+declare function getUnSpentUtxos(address: string): Promise<any>;
+declare function getInscriptionsUtxo(address: string, tx: any): Promise<any>;
+declare function sendTransaction({ signed, senderAddress }: any): Promise<any>;
+declare function estimateSmartFee({ senderAddress }: {
+    senderAddress: string;
+}): Promise<{
+    feePerKB: number;
+}>;
+declare function onCreateTransaction({ data, sendResponse }: {
+    data: any;
+    sendResponse: any;
+}): Promise<void>;
+type TransactionResponse = {
+    transactions: Transaction[];
+    txIds: string[];
+    totalPages: number;
+    page: number;
+};
+declare function getTransactions(address: string, config?: {
+    pageSize: number;
+    pageNumber: number;
+}): Promise<TransactionResponse>;
+declare const getDogeFeeByBlock: (address?: string, n?: number) => Promise<number>;
+declare const sendDogeTx: (rawTx: string) => Promise<any>;
+
+type API_Transaction = Transaction;
+type API_TransactionResponse = TransactionResponse;
+declare const API_estimateSmartFee: typeof estimateSmartFee;
+declare const API_getBalance: typeof getBalance;
+declare const API_getDogeFeeByBlock: typeof getDogeFeeByBlock;
+declare const API_getInscriptionsUtxo: typeof getInscriptionsUtxo;
+declare const API_getInscriptionsUtxos: typeof getInscriptionsUtxos;
+declare const API_getSpendableUtxos: typeof getSpendableUtxos;
+declare const API_getTransactions: typeof getTransactions;
+declare const API_getTxDetail: typeof getTxDetail;
+declare const API_getUnSpentUtxos: typeof getUnSpentUtxos;
+declare const API_mydoge: typeof mydoge;
+declare const API_onCreateTransaction: typeof onCreateTransaction;
+declare const API_sendDogeTx: typeof sendDogeTx;
+declare const API_sendTransaction: typeof sendTransaction;
+declare namespace API {
+  export { type API_Transaction as Transaction, type API_TransactionResponse as TransactionResponse, API_estimateSmartFee as estimateSmartFee, API_getBalance as getBalance, API_getDogeFeeByBlock as getDogeFeeByBlock, API_getInscriptionsUtxo as getInscriptionsUtxo, API_getInscriptionsUtxos as getInscriptionsUtxos, API_getSpendableUtxos as getSpendableUtxos, API_getTransactions as getTransactions, API_getTxDetail as getTxDetail, API_getUnSpentUtxos as getUnSpentUtxos, API_mydoge as mydoge, API_onCreateTransaction as onCreateTransaction, API_sendDogeTx as sendDogeTx, API_sendTransaction as sendTransaction };
+}
+
+declare class DogecoinService extends BaseService {
+    private static instance;
+    chainType: ChainTypes | "";
+    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;
+    }>;
+    getAccounts(): Promise<string[]>;
+    getConnectionStatus(): Promise<{
+        connected: boolean;
+        address: string;
+        selectedWalletAddress: string;
+    }>;
+    getBalance(): Promise<{
+        address: string;
+        balance: number;
+    }>;
+    signMessage({ message, type }: {
+        message: string;
+        type?: string;
+    }): Promise<{
+        signedMessage: string;
+    }>;
+    requestSignedMessage({ message, type, }: {
+        message: string;
+        type?: string;
+    }): Promise<{
+        signedMessage: string;
+    }>;
+    _queryGasInfo(txData: TransactionParams): Promise<QueryGasResponse>;
+    requestPsbt({ rawTx, signOnly, }: {
+        rawTx: string;
+        signOnly?: boolean;
+    }): Promise<{
+        signedRawTx: string;
+        txId?: string;
+    } | null>;
+    requestTransaction(txData: DogeTxData): Promise<{
+        txId: string;
+    } | null>;
+    getTransactionStatus({ txId }: {
+        txId: string;
+    }): Promise<any>;
+}
+
 declare class EvmService extends BaseService {
     private static instance;
     chainType: ChainTypes | "";
-    constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo);
-    static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo): EvmService;
+    constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): EvmService;
     eth_requestAccounts(): Promise<string[]>;
     eth_accounts(): Promise<string[]>;
     eth_chainId(): Promise<`0x${string}`>;
@@ -429,25 +576,27 @@ declare class EvmService extends BaseService {
     personal_sign([message, address]: [`0x${string}`, `0x${string}`]): Promise<`0x${string}`>;
     eth_signTypedData_v4([address, typedData]: [`0x${string}`, ITypedData]): Promise<`0x${string}`>;
     eth_getBalance([address, type]: [`0x${string}`, "latest"]): Promise<string>;
-    _queryGasInfo(txData: TransactionParams): Promise<QueryGasResponse>;
-    eth_estimateGas(txs: Transaction[]): Promise<`0x${string}`>;
+    _queryGasInfo(txData: TransactionParams$1): Promise<QueryGasResponse>;
     private createPublicClient;
+    eth_estimateGas(txs: Transaction$1[]): Promise<`0x${string}`>;
     eth_getTransactionCount([address, type]: [`0x${string}`, "latest" | "pending"]): Promise<number>;
     eth_signTransaction(txParams: {
-        type?: number;
+        type?: "eip1559" | "legacy";
         from: `0x${string}`;
         to: `0x${string}`;
         value: `0x${string}`;
         data?: `0x${string}`;
         chainId: `0x${string}`;
         nonce: `0x${string}`;
-        gasLimit: `0x${string}`;
+        gasLimit?: `0x${string}`;
+        gas?: `0x${string}`;
+        gasPrice?: `0x${string}`;
         maxFeePerGas?: `0x${string}`;
         maxPriorityFeePerGas?: `0x${string}`;
         accessList?: any[];
-    }[]): Promise<Transaction>;
+    }[]): Promise<Transaction$1>;
     eth_sendRawTransaction([serializedTransaction]: [`0x${string}`], rpcUrl?: `https://${string}`): Promise<`0x${string}`>;
-    getTransaction(hash: `0x${string}`): Promise<Transaction>;
+    getTransaction(hash: `0x${string}`): Promise<Transaction$1>;
 }
 
 interface SolanaRentInfo {
@@ -464,9 +613,9 @@ declare class SolanaService extends BaseService {
     chainType: ChainTypes | "";
     rpcUrl: string;
     private connection;
-    constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo);
-    static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo): SolanaService;
-    getCurrentWalletAccount(): Promise<any>;
+    constructor(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo);
+    static getInstance(chainType: ChainTypes, accountInfo: IAccountInfo, tomoAppInfo: TomoAppInfo): SolanaService;
+    getCurrentWalletAccount(): Promise<any[]>;
     getAccount(): Promise<{
         publicKey: string;
         address: string;
@@ -486,7 +635,7 @@ declare class SolanaService extends BaseService {
         method: string;
         params: any;
     }): Promise<any>;
-    _queryGasInfo(txData: TransactionParams): Promise<QueryGasResponse>;
+    _queryGasInfo(txData: TransactionParams$1): Promise<QueryGasResponse>;
     sendSignedTx(signedTx: string): Promise<string>;
     signTransaction({ rawTransaction }: {
         rawTransaction: string;
@@ -516,9 +665,107 @@ declare class TomoWallet extends BaseService {
     getTransactions({ tokenAddress, chainId, typeList, pageLimit, cursor, }: TransactionsParams): Promise<TransactionsResponse>;
 }
 
+declare function toSatoshi(bitcion: number | string): number;
+declare function toBitcoin(satoshis: number | string): number;
+declare function addUsedUtxos(newUsedUtxos: object): void;
+declare function getUsedUtxos(): any;
+declare function createPsbt({ from, to, amount, fee, spendableUtxos, }: {
+    from: string;
+    to: string;
+    amount: number;
+    fee: number;
+    spendableUtxos: DogeSpendableUtxos[];
+}): Promise<{
+    psbtBase64: string;
+    usingUtxos: any;
+}>;
+declare function decodePsbt(psbt: string, type?: string): Psbt;
+declare class TransactionParser {
+    rawTx: string;
+    constructor(rawTx: string);
+    hexToText(hex: string): string;
+    extractOPReturnData(): any;
+    parseScript(): {
+        version: string;
+        inputCount: number;
+        inputs: {
+            txid: string;
+            vout: string;
+            scriptData: any;
+        }[];
+        opReturnData: any;
+    };
+    parseInputs(): {
+        txid: string;
+        vout: string;
+        scriptData: any;
+    }[];
+}
+
+/**
+ * UTXO Transaction type definition
+ * Replaces the utxoTx type from @okxweb3/coin-bitcoin
+ */
+interface utxoTx {
+    address: string;
+    inputs: Array<{
+        txId: string;
+        vOut: number;
+        amount: number;
+        nonWitnessUtxo?: string;
+        address?: string;
+    }>;
+    outputs: Array<{
+        address: string;
+        amount: number;
+    }>;
+}
+declare class DogecoinAddress {
+    static network: {
+        messagePrefix: string;
+        bech32: string;
+        bip44: number;
+        bip32: {
+            public: number;
+            private: number;
+        };
+        pubKeyHash: number;
+        scriptHash: number;
+        wif: number;
+    };
+    static generatePath(addressIndex: number): string;
+    static verifyAddress(address: string): boolean;
+}
+declare class DogecoinUtils {
+    /**
+     * Build the PSBT from the transaction
+     * @param tx utxoTx
+     * @param _maximumFeeRate number (optional, currently unused)
+     * @returns base64
+     */
+    static buildPsbtToBase64(tx: utxoTx, _maximumFeeRate?: number): string;
+    /**
+     * Extract the transaction from the signed PSBT
+     * @param signedPsbt base64
+     * @param _maximumFeeRate number (optional, currently unused)
+     * @returns transaction hex
+     */
+    static extractPsbtTransaction(signedPsbt: string, _maximumFeeRate?: number): string;
+    /**
+     * Convert raw transaction hex to PSBT base64
+     * This method converts an unsigned raw transaction to PSBT format.
+     * Note: The rawTx should be an unsigned transaction, and the nonWitnessUtxo
+     * for each input will need to be fetched separately from the blockchain.
+     * @param rawTx hex string of the raw transaction
+     * @returns base64 string of the PSBT
+     */
+    static rawTxToPsbtBase64(rawTx: string): Promise<string>;
+}
+
 declare const ChainTypeServices: {
     evm: typeof EvmService;
     sol: typeof SolanaService;
+    doge: typeof DogecoinService;
 };
 
-export { AccountType, type ChainAddress, ChainTypeServices, EvmService, type IAccount, SolanaService, type TomoAppInfo, TomoWallet, type TransactionItem, type TransactionsParams, type TransactionsResponse, TxTypes };
+export { AccountType, type ChainAddress, ChainTypeServices, API as DogecoinAPI, DogecoinAddress, DogecoinService, DogecoinUtils, EvmService, type IAccount, type IAccountInfo, SolanaService, type TomoAppInfo, TomoWallet, type TransactionItem, TransactionParser, type TransactionsParams, type TransactionsResponse, TxTypes, addUsedUtxos, createPsbt, decodePsbt, getUsedUtxos, toBitcoin, toSatoshi, type utxoTx };