@sodax/wallet-sdk-core 1.3.1-beta-rc1 → 1.3.1-beta-rc2

package/dist/index.cjs

@@ -11,6 +11,13 @@ var sdkTs = require('@injectivelabs/sdk-ts');
 var splToken = require('@solana/spl-token');
 var web3_js = require('@solana/web3.js');
 var stellarSdk = require('@stellar/stellar-sdk');
+var bitcoin = require('bitcoinjs-lib');
+var ecc = require('@bitcoinerlab/secp256k1');
+var ecpair = require('ecpair');
+var secp256k1 = require('secp256k1');
+var bip322 = require('bip322-js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -31,6 +38,10 @@ function _interopNamespace(e) {
 }
 
 var IconSdkRaw__namespace = /*#__PURE__*/_interopNamespace(IconSdkRaw);
+var bitcoin__namespace = /*#__PURE__*/_interopNamespace(bitcoin);
+var ecc__namespace = /*#__PURE__*/_interopNamespace(ecc);
+var secp256k1__default = /*#__PURE__*/_interopDefault(secp256k1);
+var bip322__namespace = /*#__PURE__*/_interopNamespace(bip322);
 
 // src/wallet-providers/EvmWalletProvider.ts
 
@@ -51,6 +62,7 @@ var HYPEREVM_MAINNET_CHAIN_ID = "hyper";
 var LIGHTLINK_MAINNET_CHAIN_ID = "lightlink";
 var NEAR_MAINNET_CHAIN_ID = "near";
 var ETHEREUM_MAINNET_CHAIN_ID = "ethereum";
+var BITCOIN_MAINNET_CHAIN_ID = "bitcoin";
 var REDBELLY_MAINNET_CHAIN_ID = "redbelly";
 var KAIA_MAINNET_CHAIN_ID = "0x2019.kaia";
 var baseChainInfo = {
@@ -150,6 +162,12 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 1
   },
+  [BITCOIN_MAINNET_CHAIN_ID]: {
+    name: "Bitcoin",
+    id: BITCOIN_MAINNET_CHAIN_ID,
+    type: "BITCOIN",
+    chainId: "bitcoin"
+  },
   [REDBELLY_MAINNET_CHAIN_ID]: {
     name: "Redbelly",
     id: REDBELLY_MAINNET_CHAIN_ID,
@@ -1028,6 +1046,42 @@ var spokeChainConfig = {
     rpcUrl: "https://injective-rpc.publicnode.com:443",
     walletAddress: ""
   },
+  [BITCOIN_MAINNET_CHAIN_ID]: {
+    addresses: {
+      assetManager: "bc1p4z9555xw0266vhq2x5un4zdmm9dt9zyet32fs7wa7u5ckdxusd9qsw4xfx"
+    },
+    chain: baseChainInfo[BITCOIN_MAINNET_CHAIN_ID],
+    bnUSD: "no",
+    nativeToken: "BTC",
+    supportedTokens: {
+      BTC: {
+        symbol: "BTC",
+        name: "Bitcoin",
+        decimals: 8,
+        address: "0:0",
+        xChainId: BITCOIN_MAINNET_CHAIN_ID
+      },
+      bnUSD: {
+        symbol: "bnUSD",
+        name: "bnUSD",
+        decimals: 18,
+        address: "0:0",
+        xChainId: BITCOIN_MAINNET_CHAIN_ID
+      },
+      BUSD: {
+        symbol: "BUSD",
+        name: "BUSDSTABLECOIN",
+        decimals: 6,
+        address: "897442:43",
+        xChainId: BITCOIN_MAINNET_CHAIN_ID
+      }
+    },
+    radfiApiUrl: "https://staging.api.radfi.co/api",
+    radfiApiKey: "",
+    radfiUmsUrl: "https://staging.ums.radfi.co/api",
+    network: "MAINNET",
+    rpcUrl: "https://mempool.space/api"
+  },
   [STELLAR_MAINNET_CHAIN_ID]: {
     addresses: {
       connection: "CDFQDDPUPAM3XPGORHDOEFRNLMKOH3N3X6XTXNLSXJQXIU3RVCM3OPEP",
@@ -1957,8 +2011,7 @@ var spokeChainConfig = {
     [spokeChainConfig[REDBELLY_MAINNET_CHAIN_ID].supportedTokens.rPOL.address]: {
       vault: SodaTokens.sodaPOL.address
     }
-  }
-});
+  }});
 var moneyMarketConfig = {
   [SONIC_MAINNET_CHAIN_ID]: {
     lendingPool: "0x553434896D39F867761859D0FE7189d2Af70514E",
@@ -1994,6 +2047,17 @@ var InjectiveExecuteResponse = class _InjectiveExecuteResponse {
   }
 };
 
+// ../types/dist/btc/index.js
+function detectBitcoinAddressType(address) {
+  if (address.startsWith("bc1p") || address.startsWith("tb1p"))
+    return "P2TR";
+  if (address.startsWith("bc1") || address.startsWith("tb1"))
+    return "P2WPKH";
+  if (address.startsWith("1") || address.startsWith("m") || address.startsWith("n"))
+    return "P2PKH";
+  throw new Error(`Unknown Bitcoin address type: ${address}`);
+}
+
 // src/wallet-providers/EvmWalletProvider.ts
 var hyper = /* @__PURE__ */ viem.defineChain({
   id: 999,
@@ -2721,6 +2785,161 @@ var StellarWalletProvider = class {
     );
   }
 };
+bitcoin__namespace.initEccLib(ecc__namespace);
+var ECPair = ecpair.ECPairFactory(ecc__namespace);
+var BitcoinWalletError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BitcoinWalletError";
+  }
+};
+function isPkConfig(config) {
+  return config.type === "PRIVATE_KEY";
+}
+function isPkWallet(wallet) {
+  return wallet.type === "PRIVATE_KEY";
+}
+var NETWORKS = {
+  TESTNET: bitcoin__namespace.networks.testnet,
+  MAINNET: bitcoin__namespace.networks.bitcoin
+};
+var BitcoinWalletProvider = class {
+  wallet;
+  network;
+  constructor(config) {
+    this.network = NETWORKS[config.network];
+    if (isPkConfig(config)) {
+      const keyHex = config.privateKey.startsWith("0x") ? config.privateKey.slice(2) : config.privateKey;
+      const keyPair = ECPair.fromPrivateKey(Buffer.from(keyHex, "hex"), {
+        network: this.network
+      });
+      this.wallet = {
+        type: "PRIVATE_KEY",
+        keyPair,
+        addressType: config.addressType ?? "P2WPKH"
+      };
+      return;
+    }
+    this.wallet = {
+      type: "BROWSER_EXTENSION",
+      walletsKit: config.walletsKit
+    };
+  }
+  async getWalletAddress() {
+    if (isPkWallet(this.wallet)) {
+      const payment = this.getPayment(
+        this.wallet.keyPair,
+        this.wallet.addressType
+        // optional if you already pass type
+      );
+      if (!payment.address) {
+        throw new BitcoinWalletError("Failed to derive address");
+      }
+      return payment.address;
+    }
+    const accounts = await this.wallet.walletsKit.getAccounts();
+    const address = accounts?.[0];
+    if (!address) {
+      throw new BitcoinWalletError("No wallet accounts found");
+    }
+    return address;
+  }
+  async getPublicKey() {
+    if (isPkWallet(this.wallet)) {
+      if (this.wallet.addressType === "P2TR") {
+        return this.wallet.keyPair.publicKey.slice(1, 33).toString("hex");
+      }
+      return this.wallet.keyPair.publicKey.toString("hex");
+    }
+    return this.wallet.walletsKit.getPublicKey();
+  }
+  async getAddressType(address) {
+    return detectBitcoinAddressType(address);
+  }
+  /**
+   * Sign PSBT and return fully signed transaction hex
+   */
+  async signTransaction(psbtBase64, finalize = true) {
+    if (isPkWallet(this.wallet)) {
+      const psbt2 = bitcoin__namespace.Psbt.fromBase64(psbtBase64, { network: this.network });
+      if (this.wallet.addressType === "P2TR" && finalize) {
+        const xOnlyPubkey = this.wallet.keyPair.publicKey.slice(1, 33);
+        const tweakedKey = this.wallet.keyPair.tweak(bitcoin__namespace.crypto.taggedHash("TapTweak", xOnlyPubkey));
+        psbt2.signAllInputs(tweakedKey);
+      } else {
+        psbt2.signAllInputs(this.wallet.keyPair);
+      }
+      if (!finalize) {
+        return psbt2.toBase64();
+      }
+      psbt2.finalizeAllInputs();
+      return psbt2.extractTransaction().toHex();
+    }
+    const { psbtHex: signedPsbt } = await this.wallet.walletsKit.signPsbt(psbtBase64);
+    if (!finalize) {
+      return signedPsbt;
+    }
+    const psbt = bitcoin__namespace.Psbt.fromHex(signedPsbt, { network: this.network });
+    return psbt.extractTransaction().toHex();
+  }
+  /**
+   * Sign arbitrary message using ECDSA
+   * Used for withdrawals
+   */
+  async signEcdsaMessage(message) {
+    if (isPkWallet(this.wallet)) {
+      const privateKey = this.wallet.keyPair.privateKey;
+      if (!privateKey) {
+        throw new BitcoinWalletError("Private key not available");
+      }
+      const hash = Buffer.from(viem.keccak256(Buffer.from(message)).slice(2), "hex");
+      const { signature, recid } = secp256k1__default.default.ecdsaSign(hash, Uint8Array.from(privateKey));
+      return Buffer.concat([Buffer.from(signature), Buffer.from([recid])]).toString("hex");
+    }
+    return this.wallet.walletsKit.signEcdsaMessage(message);
+  }
+  async signBip322Message(message) {
+    if (isPkWallet(this.wallet)) {
+      const privateKey = this.wallet.keyPair.privateKey;
+      if (!privateKey) {
+        throw new BitcoinWalletError("Private key not available");
+      }
+      const signature = bip322__namespace.Signer.sign(this.wallet.keyPair.toWIF(), await this.getWalletAddress(), message);
+      return signature;
+    }
+    return this.wallet.walletsKit.signBip322Message(message);
+  }
+  getPayment(keyPair, addressType) {
+    switch (addressType) {
+      case "P2PKH":
+        return bitcoin__namespace.payments.p2pkh({
+          pubkey: keyPair.publicKey,
+          network: this.network
+        });
+      case "P2WPKH":
+        return bitcoin__namespace.payments.p2wpkh({
+          pubkey: keyPair.publicKey,
+          network: this.network
+        });
+      case "P2TR":
+        return bitcoin__namespace.payments.p2tr({
+          internalPubkey: keyPair.publicKey.slice(1, 33),
+          network: this.network
+        });
+      default:
+        throw new BitcoinWalletError(`Unsupported address type: ${addressType}`);
+    }
+  }
+  async sendBitcoin(toAddress, satoshis) {
+    if (isPkWallet(this.wallet)) {
+      throw new BitcoinWalletError("sendBitcoin not implemented for PRIVATE_KEY wallet");
+    }
+    if (!this.wallet.walletsKit.sendBitcoin) {
+      throw new BitcoinWalletError("sendBitcoin not supported by this browser extension");
+    }
+    return this.wallet.walletsKit.sendBitcoin(toAddress, Number(satoshis));
+  }
+};
 
 // ../../node_modules/.pnpm/near-api-js@7.2.0/node_modules/near-api-js/lib/crypto/constants.js
 var KeyType;
@@ -5988,7 +6207,7 @@ var Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
   Fp: Fpk1,
   endo: secp256k1_ENDO
 });
-var secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, sha256);
+var secp256k12 = /* @__PURE__ */ ecdsa(Pointk1, sha256);
 
 // ../../node_modules/.pnpm/near-api-js@7.2.0/node_modules/near-api-js/lib/crypto/public_key.js
 function key_type_to_str(keyType) {
@@ -6114,7 +6333,7 @@ var PublicKey2 = class _PublicKey extends Enum {
       case KeyType.ED25519:
         return ed25519.verify(signature, message, data);
       case KeyType.SECP256K1:
-        return secp256k1.verify(signature.subarray(0, 64), message, new Uint8Array([4, ...data]), {
+        return secp256k12.verify(signature.subarray(0, 64), message, new Uint8Array([4, ...data]), {
           prehash: false
         });
       default:
@@ -6213,7 +6432,7 @@ var KeyPairSecp256k1 = class _KeyPairSecp256k1 extends KeyPairBase {
     super();
     const decoded = baseDecode(extendedSecretKey);
     const secretKey = new Uint8Array(decoded.slice(0, KeySize.SECRET_KEY));
-    const withHeader = secp256k1.getPublicKey(new Uint8Array(secretKey), false);
+    const withHeader = secp256k12.getPublicKey(new Uint8Array(secretKey), false);
     const data = withHeader.subarray(1);
     this.publicKey = new PublicKey2({
       keyType: KeyType.SECP256K1,
@@ -6234,13 +6453,13 @@ var KeyPairSecp256k1 = class _KeyPairSecp256k1 extends KeyPairBase {
    */
   static fromRandom() {
     const secretKey = crypto.getRandomValues(new Uint8Array(KeySize.SECRET_KEY));
-    const withHeader = secp256k1.getPublicKey(secretKey, false);
+    const withHeader = secp256k12.getPublicKey(secretKey, false);
     const publicKey = withHeader.subarray(1);
     const extendedSecretKey = new Uint8Array([...secretKey, ...publicKey]);
     return new _KeyPairSecp256k1(baseEncode(extendedSecretKey));
   }
   sign(message) {
-    const raw = secp256k1.sign(message, baseDecode(this.secretKey), { prehash: false, format: "recovered" });
+    const raw = secp256k12.sign(message, baseDecode(this.secretKey), { prehash: false, format: "recovered" });
     const signature = new Uint8Array(65);
     signature.set(raw.subarray(1), 0);
     signature[64] = raw[0];
@@ -9380,7 +9599,7 @@ function serializeMessage(payload) {
 }
 
 // ../../node_modules/.pnpm/near-api-js@7.2.0/node_modules/near-api-js/lib/signers/signer.js
-var Signer = class {
+var Signer2 = class {
   /**
    * Signs given message according to NEP-413 requirements
    * @see https://github.com/near/NEPs/blob/master/neps/nep-0413.md
@@ -9445,7 +9664,7 @@ var Signer = class {
 };
 
 // ../../node_modules/.pnpm/near-api-js@7.2.0/node_modules/near-api-js/lib/signers/key_pair_signer.js
-var KeyPairSigner = class _KeyPairSigner extends Signer {
+var KeyPairSigner = class _KeyPairSigner extends Signer2 {
   constructor(key) {
     super();
     this.key = key;
@@ -10350,6 +10569,8 @@ var NearWalletProvider = class {
 */
 
 exports.BigNumberToBigInt = BigNumberToBigInt;
+exports.BitcoinWalletError = BitcoinWalletError;
+exports.BitcoinWalletProvider = BitcoinWalletProvider;
 exports.EvmWalletProvider = EvmWalletProvider;
 exports.IconWalletProvider = IconWalletProvider;
 exports.InjectiveWalletProvider = InjectiveWalletProvider;