@cryptorubic/web3 0.15.0-alpha-stellar.0 → 1.0.0-alpha-rub-1103.0

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinAdapterSigner = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const tx_status_1 = require("../../models/web3-public-models/tx-status");
+const waitFor_1 = require("../../utils/waitFor");
+class BitcoinAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    constructor(httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+    }
+    write(args) {
+        throw new Error('Not implemented');
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.BITCOIN);
+    }
+    async sendTransaction(params) {
+        if (this.isPsbtConfig(params.txOptions)) {
+            return this.sendPsbtTransaction(params.txOptions);
+        }
+        else {
+            return this.transfer(params.txOptions);
+        }
+    }
+    async transfer(txConfig) {
+        const hashPromise = new Promise((resolve, reject) => {
+            this.wallet.request({
+                method: 'transfer',
+                params: [
+                    {
+                        feeRate: 10,
+                        from: this.walletAddress,
+                        recipient: txConfig.depositAddress,
+                        amount: {
+                            amount: txConfig.value,
+                            decimals: 8
+                        },
+                        ...(txConfig.memo && { memo: txConfig.memo })
+                    }
+                ]
+            }, (error, txHash) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    const hash = txHash;
+                    txConfig?.onTransactionHash?.(hash);
+                    resolve(hash);
+                }
+            });
+        });
+        try {
+            const srcTxHash = await hashPromise;
+            if (typeof srcTxHash === 'string') {
+                const statusData = await this.getSrcStatusRecursive(srcTxHash);
+                return statusData.hash;
+            }
+            throw new Error();
+        }
+        catch {
+            throw new Error('Failed to transfer funds');
+        }
+    }
+    async sendPsbtTransaction(txConfig) {
+        const hashPromise = new Promise((resolve, reject) => {
+            this.wallet.request({
+                method: 'sign_psbt',
+                params: [
+                    {
+                        psbt: txConfig.psbt,
+                        signInputs: {
+                            [this.walletAddress]: txConfig.signInputs
+                        },
+                        allowedSignHash: 1,
+                        broadcast: true
+                    }
+                ]
+            }, (error, txHash) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    const txData = txHash;
+                    txConfig.onTransactionHash?.(txData.result.txId);
+                    resolve(txData.result.txId);
+                }
+            });
+        });
+        try {
+            const srcTxHash = await hashPromise;
+            if (typeof srcTxHash === 'string') {
+                const statusData = await this.getSrcStatusRecursive(srcTxHash);
+                return statusData.hash;
+            }
+            throw new Error();
+        }
+        catch {
+            throw new Error('Failed to sign psbt transaction');
+        }
+    }
+    async getSrcStatusRecursive(srcTxHash) {
+        const srcTxStatus = await this.getSrcTxStatus(srcTxHash);
+        if (srcTxStatus === tx_status_1.TX_STATUS.FAIL || srcTxStatus === tx_status_1.TX_STATUS.SUCCESS) {
+            return {
+                status: srcTxStatus,
+                hash: srcTxHash
+            };
+        }
+        await (0, waitFor_1.waitFor)(300000);
+        return this.getSrcStatusRecursive(srcTxHash);
+    }
+    isPsbtConfig(txConfig) {
+        return 'psbt' in txConfig;
+    }
+    async getTransactionStatus(txHash) {
+        const url = `https://api.blockcypher.com/v1/btc/main/txs/${txHash}`;
+        const { confirmations } = await this.httpClient.get(url);
+        return confirmations > 0 ? tx_status_1.TX_STATUS.SUCCESS : tx_status_1.TX_STATUS.PENDING;
+    }
+    async getSrcTxStatus(srcTxHash) {
+        try {
+            const status = await this.getTransactionStatus(srcTxHash);
+            return status;
+        }
+        catch {
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+    }
+}
+exports.BitcoinAdapterSigner = BitcoinAdapterSigner;

package/src/lib/adapter/adapters/adapter-evm/constants/proxy-hash-errors.d.ts

@@ -0,0 +1,4 @@
+export declare const proxyHashErrors: {
+    text: string;
+    hash: string;
+}[];