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

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@cryptorubic/web3",
-  "version": "0.5.2-alpha-teleswap.1",
+  "version": "0.5.2-alpha-teleswap.3",
   "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.3",
     "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.3",
     "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,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({
@@ -44,8 +83,9 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
                     reject(error);
                 }
                 else {
-                    options?.onTransactionHash?.(txHash);
-                    resolve(txHash);
+                    const hash = txHash;
+                    options?.onTransactionHash?.(hash);
+                    resolve(hash);
                 }
             });
         });
@@ -61,5 +101,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;
     }>;

package/src/lib/adapter/blockchain-adapter-factory.service.d.ts

@@ -7,10 +7,8 @@ import { TonAdapter } from './adapters/ton-adapter';
 import { TonAdapterConfig } from './adapters/models/ton-adapter-config';
 import { EvmAdapter } from './adapters/evm-adapter';
 import { BitcoinAdapter } from './adapters/bitcoin-adapter';
-import { TeleswapSDK } from '@teleportdao/teleswap-sdk';
 export declare class BlockchainAdapterFactoryService {
     private readonly rpcList;
-    readonly teleSwapSdk: TeleswapSDK;
     private readonly createLogger?;
     private readonly httpClient?;
     private readonly tonParams?;
@@ -26,5 +24,4 @@ export declare class BlockchainAdapterFactoryService {
     private createStorage;
     private createAdapter;
     connectWallet(walletProvider: WalletProvider): void;
-    private static createTeleSwapSdkInstance;
 }

package/src/lib/adapter/blockchain-adapter-factory.service.js

@@ -9,11 +9,9 @@ const core_1 = require("@cryptorubic/core");
 const ton_adapter_1 = require("./adapters/ton-adapter");
 const evm_adapter_1 = require("./adapters/evm-adapter");
 const bitcoin_adapter_1 = require("./adapters/bitcoin-adapter");
-const teleswap_sdk_1 = require("@teleportdao/teleswap-sdk");
 class BlockchainAdapterFactoryService {
-    constructor(rpcList, teleSwapSdk, createLogger, httpClient, tonParams) {
+    constructor(rpcList, createLogger, httpClient, tonParams) {
         this.rpcList = rpcList;
-        this.teleSwapSdk = teleSwapSdk;
         this.createLogger = createLogger;
         this.httpClient = httpClient;
         this.tonParams = tonParams;
@@ -27,8 +25,7 @@ class BlockchainAdapterFactoryService {
         // @TODO Add default logger
         const loggerFn = createLogger || undefined;
         const resolvedHttpClient = httpClient ?? (await Promise.resolve().then(() => require('axios')));
-        const teleSwapSdk = await BlockchainAdapterFactoryService.createTeleSwapSdkInstance();
-        return new this(rpcList, teleSwapSdk, createLogger, resolvedHttpClient, tonParams);
+        return new this(rpcList, createLogger, resolvedHttpClient, tonParams);
     }
     getAdapter(blockchain) {
         const adapter = this.adapterStore?.[blockchain];
@@ -132,10 +129,5 @@ class BlockchainAdapterFactoryService {
             store.walletAddress = walletProvider[core_1.CHAIN_TYPE.BITCOIN].address;
         }
     }
-    static async createTeleSwapSdkInstance() {
-        const teleSwapSdk = new teleswap_sdk_1.TeleswapSDK();
-        await teleSwapSdk.initNetworksConnection();
-        return teleSwapSdk;
-    }
 }
 exports.BlockchainAdapterFactoryService = BlockchainAdapterFactoryService;