@cryptorubic/web3 0.7.5-alpha.rpc-error.1 → 0.7.6

package/package.json

@@ -1,17 +1,17 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "0.7.5-alpha.rpc-error.1",
+    "version": "0.7.6",
     "dependencies": {
         "tslib": "^2.3.0",
         "bignumber.js": "9.1.2",
-        "@cryptorubic/core": "0.7.5-alpha.rpc-error.1",
+        "@cryptorubic/core": "0.7.6",
         "viem": "^2.19.1",
         "web3-utils": "^4.3.1",
         "@ton/ton": "^15.1.0",
         "@solana/web3.js": "1.95.3",
         "@solflare-wallet/utl-sdk": "^1.4.0",
         "@ethersproject/bignumber": "^5.7.0",
-        "@cryptorubic/tron-types": "0.7.5-alpha.rpc-error.1",
+        "@cryptorubic/tron-types": "0.7.6",
         "bitcoin-address-validation": "^2.2.3",
         "axios": "0.27.2",
         "crc-32": "^1.2.2",

package/src/lib/adapter/adapters/bitcoin-adapter.d.ts

@@ -7,9 +7,12 @@ export declare class BitcoinAdapter extends AbstractAdapter<BtcWallet, BtcWallet
     private readonly httpClient;
     constructor(httpClient: HttpClient, logger?: ICustomLogger);
     getBalance(userAddress: string): Promise<BigNumber>;
+    getPublicKey(userAddress: string): Promise<string | null>;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
     read<T>(args: unknown): Promise<T>;
     write(args: unknown): Promise<string>;
+    getPublicKeyFromWallet(): Promise<string>;
     transfer(recipient: string, amount: string, fromAddress: string, memo?: string, options?: BasicTransactionOptions): Promise<string>;
+    sendPsbtTransaction(psbt: string, userAddress: string, inputIndexes: number[], options?: BasicTransactionOptions): Promise<string>;
 }

package/src/lib/adapter/adapters/bitcoin-adapter.js

@@ -14,6 +14,32 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
         const response = await this.httpClient.get(url);
         return new bignumber_js_1.default(response.final_balance);
     }
+    async getPublicKey(userAddress) {
+        try {
+            const url = `https://api.blockcypher.com/v1/btc/main/addrs/${userAddress}/full`;
+            const response = await this.httpClient.get(url);
+            const txs = response.txs;
+            let publicKey = null;
+            for (const txData of txs) {
+                const userInputData = txData.inputs.find((inputData) => {
+                    const isInputFromUserAddress = inputData.addresses.includes(userAddress);
+                    const publicKey = inputData.witness?.[1];
+                    return isInputFromUserAddress && publicKey;
+                });
+                if (userInputData) {
+                    publicKey = userInputData.witness[1];
+                    break;
+                }
+            }
+            if (!publicKey) {
+                throw new Error();
+            }
+            return publicKey;
+        }
+        catch {
+            return null;
+        }
+    }
     async checkEnoughBalance(token, walletAddress) {
         const balance = await this.getBalance(walletAddress);
         return balance.gte(token.tokenAmount);
@@ -27,6 +53,19 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
     write(args) {
         throw new Error('Not implemented');
     }
+    async getPublicKeyFromWallet() {
+        const res = await this.wallet.request({
+            method: 'request_accounts_and_keys',
+            params: {
+                purposes: ['payment']
+            }
+        }, () => { });
+        if (res.error) {
+            console.error(res.error);
+            throw res.error;
+        }
+        return res.result[0].publicKey;
+    }
     async transfer(recipient, amount, fromAddress, memo, options) {
         const hashPromise = new Promise((resolve, reject) => {
             this.wallet.request({
@@ -48,8 +87,9 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
                     reject(error);
                 }
                 else {
-                    options?.onTransactionHash?.(txHash);
-                    resolve(txHash);
+                    const hash = txHash;
+                    options?.onTransactionHash?.(hash);
+                    resolve(hash);
                 }
             });
         });
@@ -65,5 +105,39 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
             throw new Error('Failed to transfer funds');
         }
     }
+    async sendPsbtTransaction(psbt, userAddress, inputIndexes, options) {
+        const hashPromise = new Promise((resolve, reject) => {
+            this.wallet.request({
+                method: 'sign_psbt',
+                params: {
+                    psbt,
+                    signInputs: {
+                        [userAddress]: inputIndexes
+                    },
+                    allowedSignHash: 1,
+                    broadcast: true
+                }
+            }, (error, txHash) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    const txData = txHash;
+                    options?.onTransactionHash?.(txData.result.txId);
+                    resolve(txData.result.txId);
+                }
+            });
+        });
+        try {
+            const hash = await hashPromise;
+            if (typeof hash === 'string') {
+                return hash;
+            }
+            throw new Error();
+        }
+        catch {
+            throw new Error('Failed to sign psbt transaction');
+        }
+    }
 }
 exports.BitcoinAdapter = BitcoinAdapter;

package/src/lib/adapter/adapters/evm-adapter.js

@@ -163,9 +163,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             return ['decimals', 'symbol', 'name'].map((method) => ({ ...contract, functionName: method }));
         });
         const results = contracts.length
-            ? (await this.multicallByContract({
-                contracts
-            }, false))
+            ? (await this.multicallByContract({ contracts }, false))
             : [];
         const tokens = [];
         for (let i = 0; i < results.length; i += 3) {

package/src/lib/adapter/adapters/models/bitcoin-user-address-info.d.ts

@@ -0,0 +1,53 @@
+export interface BitcoinTxInput {
+    prev_hash: string;
+    output_index: number;
+    output_value: number;
+    sequence: number;
+    addresses: string[];
+    script_type: string;
+    age?: number;
+    witness: string[];
+}
+export interface BitcoinTxOutput {
+    value: number;
+    script: string;
+    addresses: string[];
+    script_type: string;
+    spent_by?: string;
+}
+export interface BitcoinTxInfo {
+    block_hash?: string;
+    block_height: number;
+    block_index: number;
+    hash: string;
+    addresses: string[];
+    total: number;
+    fees: number;
+    size: number;
+    vsize: number;
+    preference: string;
+    relayed_by: string;
+    confirmed?: string;
+    received: string;
+    ver: number;
+    double_spend: boolean;
+    vin_sz: number;
+    vout_sz: number;
+    confirmations?: number;
+    confidence?: number;
+    inputs: BitcoinTxInput[];
+    outputs: BitcoinTxOutput[];
+    opt_in_rbf?: boolean;
+}
+export interface BitcoinUserAddressInfo {
+    address: string;
+    total_received: number;
+    total_sent: number;
+    balance: number;
+    unconfirmed_balance: number;
+    final_balance: number;
+    n_tx: number;
+    unconfirmed_n_tx: number;
+    final_n_tx: number;
+    txs: BitcoinTxInfo[];
+}

package/src/lib/adapter/adapters/models/bitcoin-user-address-info.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/adapter/adapters/models/btc-wallet-provider.d.ts

@@ -2,8 +2,8 @@ export interface BtcWallet {
     on: (event: string, callback: (...args: unknown[]) => void) => unknown;
     request<T>(args: {
         method: string;
-        params: unknown[];
-    }, fn: (error: Error, txHash: string) => unknown): Promise<{
+        params: unknown[] | {};
+    }, fn: (error: Error, txHash: string | {}) => unknown): Promise<{
         error: null | Error;
         result: T;
     }>;