@tomo-inc/chains-service 0.0.8 → 0.0.10

package/dist/index.d.cts

@@ -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",
@@ -400,6 +402,186 @@ declare class BaseService {
     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<string[]>;
+    getAccounts(): Promise<string[]>;
+    getConnectionStatus(): Promise<{
+        connected: boolean;
+        address: string;
+        selectedWalletAddress: string;
+    }>;
+    getBalance(): Promise<{
+        confirmed: number;
+        unconfirmed: number;
+        total: number;
+    }>;
+    signMessage({ message, type }: {
+        message: string;
+        type?: string;
+    }): Promise<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>;
+    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>;
+}
+
 declare class EvmService extends BaseService {
     private static instance;
     chainType: ChainTypes | "";
@@ -416,7 +598,7 @@ declare class EvmService extends BaseService {
     eth_getBalance([address, type]: [`0x${string}`, "latest"]): Promise<string>;
     _queryGasInfo(txData: TransactionParams$1): Promise<QueryGasResponse>;
     private createPublicClient;
-    eth_estimateGas(txs: Transaction[]): Promise<`0x${string}`>;
+    eth_estimateGas(txs: Transaction$1[]): Promise<`0x${string}`>;
     eth_getTransactionCount([address, type]: [`0x${string}`, "latest" | "pending"]): Promise<number>;
     eth_signTransaction(txParams: {
         type?: "eip1559" | "legacy";
@@ -432,9 +614,9 @@ declare class EvmService extends BaseService {
         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 {
@@ -492,101 +674,112 @@ declare class SolanaService extends BaseService {
     private checkTokenAccount;
 }
 
-type DogeSpendableUtxos = {
-    txid: string;
-    vout: number;
-    outputValue: number;
-    script: string;
-    tx?: {
-        txid: string;
-        vout: number;
-    };
-};
-interface TransactionParams {
-    accountId?: string;
+declare class TomoWallet extends BaseService {
+    private static instance;
+    private walletId;
+    constructor(walletId: string, tomoAppInfo: TomoAppInfo);
+    getInstance(walletId: string, tomoAppInfo: TomoAppInfo): TomoWallet;
+    supportedChains(chainType?: ChainTypes | ""): Promise<INetwork[]>;
+    getChainInfo(chainType: ChainTypes, chainId: string): Promise<INetwork>;
+    isChainSupported(chainType: ChainTypes, chainId: string): Promise<boolean>;
+    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;
-    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[];
+    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;
+    }[];
 }
 
-declare class DogecoinService extends BaseService {
-    private static instance;
-    chainType: ChainTypes | "";
-    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;
+/**
+ * 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;
     }>;
-    getBalance(): Promise<{
+    outputs: Array<{
         address: string;
-        balance: number;
-    }>;
-    signMessage({ message, type }: {
-        message: string;
-        type?: string;
-    }): Promise<{
-        signedMessage: string;
+        amount: number;
     }>;
-    requestSignedMessage({ message, type, }: {
-        message: string;
-        type?: string;
-    }): Promise<{
-        signedMessage: string;
-    }>;
-    requestDecryptedMessage({ message }: {
-        message: string;
-    }): Promise<{
-        decryptedMessage: 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 TomoWallet extends BaseService {
-    private static instance;
-    private walletId;
-    constructor(walletId: string, tomoAppInfo: TomoAppInfo);
-    getInstance(walletId: string, tomoAppInfo: TomoAppInfo): TomoWallet;
-    supportedChains(chainType?: ChainTypes | ""): Promise<INetwork[]>;
-    getChainInfo(chainType: ChainTypes, chainId: string): Promise<INetwork>;
-    isChainSupported(chainType: ChainTypes, chainId: string): Promise<boolean>;
-    getTransactions({ tokenAddress, chainId, typeList, pageLimit, cursor, }: TransactionsParams): Promise<TransactionsResponse>;
+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: {
@@ -595,4 +788,4 @@ declare const ChainTypeServices: {
     doge: typeof DogecoinService;
 };
 
-export { AccountType, type ChainAddress, ChainTypeServices, DogecoinService, EvmService, type IAccount, type IAccountInfo, 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 };