@cryptorubic/web3 0.5.2-alpha-teleswap.1 → 0.5.2-alpha-teleswap.2

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@cryptorubic/web3",
-  "version": "0.5.2-alpha-teleswap.1",
+  "version": "0.5.2-alpha-teleswap.2",
   "dependencies": {
     "tslib": "^2.3.0",
     "bignumber.js": "9.1.2",
-    "@cryptorubic/core": "0.5.2-alpha-teleswap.1",
+    "@cryptorubic/core": "0.5.2-alpha-teleswap.2",
     "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.5.2-alpha-teleswap.1",
+    "@cryptorubic/tron-types": "0.5.2-alpha-teleswap.2",
     "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,8 +7,11 @@ 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>;
     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 callForTokensInfo(tokenAddresses) {
         return [core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.BITCOIN]];
     }
@@ -23,6 +49,20 @@ 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: {
+                //@ts-ignore
+                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({
@@ -34,18 +74,19 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
                         recipient,
                         amount: {
                             amount,
-                            decimals: 8
+                            decimals: 8,
                         },
-                        ...(memo && { memo })
-                    }
-                ]
+                        ...(memo && { memo }),
+                    },
+                ],
             }, (error, txHash) => {
                 if (error) {
                     reject(error);
                 }
                 else {
-                    options?.onTransactionHash?.(txHash);
-                    resolve(txHash);
+                    const hash = txHash;
+                    options?.onTransactionHash?.(hash);
+                    resolve(hash);
                 }
             });
         });
@@ -61,5 +102,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/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;
     }>;