@sip-protocol/sdk 0.6.0 → 0.6.2

package/src/wallet/bitcoin/types.ts

@@ -174,11 +174,333 @@ export interface UnisatAPI {
 }
 
 /**
- * Global window interface for Unisat
+ * Xverse wallet API interface
+ *
+ * Official API: https://docs.xverse.app/sats-connect
+ */
+export interface XverseAPI {
+  /**
+   * Request wallet connection
+   */
+  request(
+    method: 'getAccounts' | 'getAddresses',
+    params?: unknown
+  ): Promise<{
+    result: {
+      addresses: Array<{
+        address: string
+        publicKey: string
+        purpose: 'payment' | 'ordinals' | 'stacks'
+        addressType: 'p2tr' | 'p2wpkh' | 'p2sh-p2wpkh' | 'stacks'
+      }>
+    }
+  }>
+
+  /**
+   * Sign a PSBT
+   */
+  request(
+    method: 'signPsbt',
+    params: {
+      psbt: string // base64 encoded PSBT
+      signInputs: Record<string, number[]>
+      broadcast?: boolean
+    }
+  ): Promise<{
+    result: {
+      psbt: string // base64 encoded signed PSBT
+      txid?: string // if broadcast: true
+    }
+  }>
+
+  /**
+   * Sign a message
+   */
+  request(
+    method: 'signMessage',
+    params: {
+      address: string
+      message: string
+      protocol?: 'ECDSA' | 'BIP322'
+    }
+  ): Promise<{
+    result: {
+      signature: string
+      messageHash: string
+      address: string
+    }
+  }>
+
+  /**
+   * Send BTC
+   */
+  request(
+    method: 'sendTransfer',
+    params: {
+      recipients: Array<{ address: string; amount: number }>
+    }
+  ): Promise<{
+    result: { txid: string }
+  }>
+}
+
+/**
+ * Leather wallet API interface
+ *
+ * Official API: https://leather.gitbook.io/developers/bitcoin/connect
+ */
+export interface LeatherAPI {
+  /**
+   * Request wallet connection and get addresses
+   */
+  request(
+    method: 'getAddresses'
+  ): Promise<{
+    result: {
+      addresses: Array<{
+        symbol: 'BTC' | 'STX'
+        type?: 'p2wpkh' | 'p2tr'
+        address: string
+        publicKey: string
+        derivationPath?: string
+      }>
+    }
+  }>
+
+  /**
+   * Sign a PSBT
+   */
+  request(
+    method: 'signPsbt',
+    params: {
+      hex: string // hex encoded PSBT
+      account?: number
+      allowedSighash?: number[]
+      signAtIndex?: number | number[]
+      broadcast?: boolean
+    }
+  ): Promise<{
+    result: {
+      hex: string // hex encoded signed PSBT
+      txid?: string // if broadcast: true
+    }
+  }>
+
+  /**
+   * Sign a message
+   */
+  request(
+    method: 'signMessage',
+    params: {
+      message: string
+      paymentType?: 'p2wpkh' | 'p2tr'
+      account?: number
+    }
+  ): Promise<{
+    result: {
+      signature: string
+      address: string
+      message: string
+    }
+  }>
+
+  /**
+   * Send BTC
+   */
+  request(
+    method: 'sendTransfer',
+    params: {
+      recipients: Array<{ address: string; amount: string }>
+      account?: number
+    }
+  ): Promise<{
+    result: { txid: string }
+  }>
+}
+
+/**
+ * Global window interface for Bitcoin wallets
  */
 declare global {
   interface Window {
     unisat?: UnisatAPI
+    XverseProviders?: {
+      BitcoinProvider?: XverseAPI
+    }
+    LeatherProvider?: LeatherAPI
+    btc?: LeatherAPI // Alternative Leather injection
+    okxwallet?: {
+      bitcoin?: UnisatAPI // OKX uses same API as Unisat
+    }
+  }
+}
+
+/**
+ * Wrapper to adapt Xverse API to UnisatAPI interface
+ */
+export function createXverseWrapper(xverse: XverseAPI): UnisatAPI {
+  let cachedAddress: string | undefined
+  let cachedPublicKey: string | undefined
+
+  return {
+    async requestAccounts(): Promise<string[]> {
+      const response = await xverse.request('getAddresses')
+      const btcAddresses = response.result.addresses.filter(
+        (a) => a.purpose === 'payment' || a.purpose === 'ordinals'
+      )
+      if (btcAddresses.length > 0) {
+        // Prefer Taproot (ordinals) address
+        const taprootAddr = btcAddresses.find((a) => a.addressType === 'p2tr')
+        const primaryAddr = taprootAddr || btcAddresses[0]
+        cachedAddress = primaryAddr.address
+        cachedPublicKey = primaryAddr.publicKey
+      }
+      return btcAddresses.map((a) => a.address)
+    },
+
+    async getAccounts(): Promise<string[]> {
+      if (cachedAddress) return [cachedAddress]
+      return this.requestAccounts()
+    },
+
+    async getPublicKey(): Promise<string> {
+      if (cachedPublicKey) return cachedPublicKey
+      await this.requestAccounts()
+      return cachedPublicKey || ''
+    },
+
+    async getBalance(): Promise<{ confirmed: number; unconfirmed: number; total: number }> {
+      // Xverse doesn't expose balance directly, return 0s
+      // Balance should be fetched from external API
+      return { confirmed: 0, unconfirmed: 0, total: 0 }
+    },
+
+    async signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string> {
+      // Convert hex to base64 for Xverse
+      const psbtBase64 = Buffer.from(psbtHex, 'hex').toString('base64')
+      const signInputs: Record<string, number[]> = {}
+
+      if (options?.toSignInputs && cachedAddress) {
+        signInputs[cachedAddress] = options.toSignInputs.map((i) => i.index)
+      } else if (cachedAddress) {
+        // Sign all inputs by default
+        signInputs[cachedAddress] = [0]
+      }
+
+      const response = await xverse.request('signPsbt', {
+        psbt: psbtBase64,
+        signInputs,
+        broadcast: false,
+      })
+
+      // Convert back to hex
+      return Buffer.from(response.result.psbt, 'base64').toString('hex')
+    },
+
+    async signMessage(message: string, type?: 'ecdsa' | 'bip322-simple'): Promise<string> {
+      if (!cachedAddress) {
+        await this.requestAccounts()
+      }
+      const response = await xverse.request('signMessage', {
+        address: cachedAddress!,
+        message,
+        protocol: type === 'bip322-simple' ? 'BIP322' : 'ECDSA',
+      })
+      return response.result.signature
+    },
+
+    async pushTx(_rawTx: string): Promise<string> {
+      // Xverse requires using signPsbt with broadcast: true
+      throw new Error('Use signPsbt with broadcast: true for Xverse')
+    },
+
+    async getNetwork(): Promise<BitcoinNetwork> {
+      // Xverse doesn't expose network, assume mainnet
+      return 'livenet'
+    },
+
+    async switchNetwork(_network: BitcoinNetwork): Promise<void> {
+      throw new Error('Network switching not supported by Xverse')
+    },
+
+    async getChain(): Promise<{ enum: string; name: string }> {
+      return { enum: 'BITCOIN_MAINNET', name: 'Bitcoin Mainnet' }
+    },
+  }
+}
+
+/**
+ * Wrapper to adapt Leather API to UnisatAPI interface
+ */
+export function createLeatherWrapper(leather: LeatherAPI): UnisatAPI {
+  let cachedAddress: string | undefined
+  let cachedPublicKey: string | undefined
+
+  return {
+    async requestAccounts(): Promise<string[]> {
+      const response = await leather.request('getAddresses')
+      const btcAddresses = response.result.addresses.filter((a) => a.symbol === 'BTC')
+      if (btcAddresses.length > 0) {
+        // Prefer Taproot address
+        const taprootAddr = btcAddresses.find((a) => a.type === 'p2tr')
+        const primaryAddr = taprootAddr || btcAddresses[0]
+        cachedAddress = primaryAddr.address
+        cachedPublicKey = primaryAddr.publicKey
+      }
+      return btcAddresses.map((a) => a.address)
+    },
+
+    async getAccounts(): Promise<string[]> {
+      if (cachedAddress) return [cachedAddress]
+      return this.requestAccounts()
+    },
+
+    async getPublicKey(): Promise<string> {
+      if (cachedPublicKey) return cachedPublicKey
+      await this.requestAccounts()
+      return cachedPublicKey || ''
+    },
+
+    async getBalance(): Promise<{ confirmed: number; unconfirmed: number; total: number }> {
+      // Leather doesn't expose balance directly
+      return { confirmed: 0, unconfirmed: 0, total: 0 }
+    },
+
+    async signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string> {
+      const signAtIndex = options?.toSignInputs?.map((i) => i.index)
+
+      const response = await leather.request('signPsbt', {
+        hex: psbtHex,
+        signAtIndex,
+        broadcast: false,
+      })
+
+      return response.result.hex
+    },
+
+    async signMessage(message: string, type?: 'ecdsa' | 'bip322-simple'): Promise<string> {
+      const response = await leather.request('signMessage', {
+        message,
+        paymentType: 'p2tr',
+      })
+      return response.result.signature
+    },
+
+    async pushTx(_rawTx: string): Promise<string> {
+      throw new Error('Use signPsbt with broadcast: true for Leather')
+    },
+
+    async getNetwork(): Promise<BitcoinNetwork> {
+      return 'livenet'
+    },
+
+    async switchNetwork(_network: BitcoinNetwork): Promise<void> {
+      throw new Error('Network switching not supported by Leather')
+    },
+
+    async getChain(): Promise<{ enum: string; name: string }> {
+      return { enum: 'BITCOIN_MAINNET', name: 'Bitcoin Mainnet' }
+    },
   }
 }
 
@@ -195,11 +517,15 @@ export function getBitcoinProvider(wallet: BitcoinWalletName): UnisatAPI | undef
       return window.unisat
     case 'okx':
       // OKX wallet has bitcoin namespace
-      return (window as any).okxwallet?.bitcoin
-    case 'xverse':
-    case 'leather':
-      // TODO: Add Xverse and Leather support
-      return undefined
+      return window.okxwallet?.bitcoin
+    case 'xverse': {
+      const xverse = window.XverseProviders?.BitcoinProvider
+      return xverse ? createXverseWrapper(xverse) : undefined
+    }
+    case 'leather': {
+      const leather = window.LeatherProvider || window.btc
+      return leather ? createLeatherWrapper(leather) : undefined
+    }
     default:
       return undefined
   }
@@ -219,18 +545,17 @@ export function detectBitcoinWallets(): BitcoinWalletName[] {
     wallets.push('unisat')
   }
 
-  if ((window as any).okxwallet?.bitcoin) {
+  if (window.okxwallet?.bitcoin) {
     wallets.push('okx')
   }
 
-  // TODO: Add detection for Xverse and Leather
-  // if ((window as any).XverseProviders?.BitcoinProvider) {
-  //   wallets.push('xverse')
-  // }
-  //
-  // if ((window as any).LeatherProvider) {
-  //   wallets.push('leather')
-  // }
+  if (window.XverseProviders?.BitcoinProvider) {
+    wallets.push('xverse')
+  }
+
+  if (window.LeatherProvider || window.btc) {
+    wallets.push('leather')
+  }
 
   return wallets
 }

package/src/wallet/cosmos/mock.ts

@@ -28,6 +28,8 @@ import type {
   CosmosAlgo,
   StdSignature,
   PubKey,
+  OfflineSigner,
+  OfflineAminoSigner,
 } from './types'
 import {
   cosmosPublicKeyToHex,
@@ -477,7 +479,7 @@ export function createMockCosmosProvider(
     bech32Address: address,
   }
 
-  return {
+  const mockKeplr: Keplr = {
     async enable() {
       if (config.shouldFailConnect) {
         throw new Error('Request rejected by user')
@@ -554,26 +556,26 @@ export function createMockCosmosProvider(
       return true
     },
 
-    async getOfflineSignerAuto(_chainId: string) {
+    async getOfflineSignerAuto(_chainId: string): Promise<OfflineSigner> {
       return {
-        async getAccounts(): Promise<readonly CosmosAccountData[]> {
+        getAccounts: async (): Promise<readonly CosmosAccountData[]> => {
           return [{ address, algo, pubkey: mockPubKey }]
         },
-        async signDirect(signerAddress: string, signDoc: DirectSignDoc): Promise<DirectSignResponse> {
-          return this.signDirect(chainId, signerAddress, signDoc)
+        signDirect: async (signerAddress: string, signDoc: DirectSignDoc): Promise<DirectSignResponse> => {
+          return mockKeplr.signDirect(chainId, signerAddress, signDoc)
         },
-      } as any
+      }
     },
 
-    async getOfflineSignerOnlyAmino(_chainId: string) {
+    async getOfflineSignerOnlyAmino(_chainId: string): Promise<OfflineAminoSigner> {
       return {
-        async getAccounts(): Promise<readonly CosmosAccountData[]> {
+        getAccounts: async (): Promise<readonly CosmosAccountData[]> => {
           return [{ address, algo, pubkey: mockPubKey }]
         },
-        async signAmino(signerAddress: string, signDoc: StdSignDoc): Promise<AminoSignResponse> {
-          return this.signAmino(chainId, signerAddress, signDoc)
+        signAmino: async (signerAddress: string, signDoc: StdSignDoc): Promise<AminoSignResponse> => {
+          return mockKeplr.signAmino(chainId, signerAddress, signDoc)
         },
-      } as any
+      }
     },
 
     async getOfflineSigner(chainId: string) {
@@ -583,7 +585,9 @@ export function createMockCosmosProvider(
     async experimentalSuggestChain() {
       // No-op for mock
     },
-  } as Keplr
+  }
+
+  return mockKeplr
 }
 
 /**

package/src/wallet/hardware/ledger.ts

@@ -28,6 +28,7 @@
  * - @ledgerhq/hw-app-solana (for Solana)
  */
 
+import { RLP } from '@ethereumjs/rlp'
 import type {
   ChainId,
   HexString,
@@ -498,20 +499,89 @@ export class LedgerWalletAdapter extends BaseWalletAdapter {
 
   /**
    * Build raw Ethereum transaction for Ledger signing
+   *
+   * @throws {HardwareWalletError} Always throws - RLP encoding not yet implemented
+   *
+   * @remarks
+   * Proper Ethereum transaction signing requires RLP (Recursive Length Prefix)
+   * encoding. This is a non-trivial implementation that requires either:
+   *
+   * 1. Adding @ethereumjs/rlp dependency
+   * 2. Adding @ethersproject/transactions dependency
+   * 3. Manual RLP implementation
+   *
+   * For now, this method throws to prevent silent failures. To enable
+   * Ledger transaction signing, implement proper RLP encoding.
+   *
+   * @see https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
    */
   private buildRawEthereumTx(tx: HardwareEthereumTx): string {
-    // Simplified - actual implementation would use RLP encoding
-    // This is a placeholder for the structure
-    const fields = [
-      tx.nonce,
-      tx.gasPrice ?? tx.maxFeePerGas ?? '0x0',
-      tx.gasLimit,
-      tx.to,
-      tx.value,
-      tx.data ?? '0x',
-    ]
-
-    return fields.join('').replace(/0x/g, '')
+    // Helper to convert hex string to bytes, handling empty values
+    const hexToBytes = (hex: HexString | undefined): Uint8Array => {
+      if (!hex || hex === '0x' || hex === '0x0' || hex === '0x00') {
+        return new Uint8Array(0)
+      }
+      // Remove 0x prefix and pad to even length
+      let cleanHex = hex.slice(2)
+      if (cleanHex.length % 2 !== 0) {
+        cleanHex = '0' + cleanHex
+      }
+      const bytes = new Uint8Array(cleanHex.length / 2)
+      for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(cleanHex.slice(i * 2, i * 2 + 2), 16)
+      }
+      return bytes
+    }
+
+    // Determine if EIP-1559 transaction (type 2)
+    const isEIP1559 = tx.maxFeePerGas !== undefined && tx.maxPriorityFeePerGas !== undefined
+
+    if (isEIP1559) {
+      // EIP-1559 transaction (type 2):
+      // 0x02 || RLP([chainId, nonce, maxPriorityFeePerGas, maxFeePerGas,
+      //              gasLimit, to, value, data, accessList])
+      const txData = [
+        hexToBytes(`0x${tx.chainId.toString(16)}`),  // chainId
+        hexToBytes(tx.nonce),                         // nonce
+        hexToBytes(tx.maxPriorityFeePerGas),          // maxPriorityFeePerGas
+        hexToBytes(tx.maxFeePerGas),                  // maxFeePerGas
+        hexToBytes(tx.gasLimit),                      // gasLimit
+        hexToBytes(tx.to as HexString),               // to
+        hexToBytes(tx.value),                         // value
+        hexToBytes(tx.data),                          // data
+        [],                                           // accessList (empty)
+      ]
+      const encoded = RLP.encode(txData)
+      // Prepend type byte (0x02)
+      const result = new Uint8Array(1 + encoded.length)
+      result[0] = 0x02
+      result.set(encoded, 1)
+      return '0x' + Buffer.from(result).toString('hex')
+    } else {
+      // Legacy transaction (type 0):
+      // RLP([nonce, gasPrice, gasLimit, to, value, data, v, r, s])
+      // For signing, we use chain ID for v and empty r, s (EIP-155)
+      if (!tx.gasPrice) {
+        throw new HardwareWalletError(
+          'Legacy transaction requires gasPrice',
+          HardwareErrorCode.INVALID_PARAMS,
+          'ledger'
+        )
+      }
+      const txData = [
+        hexToBytes(tx.nonce),                         // nonce
+        hexToBytes(tx.gasPrice),                      // gasPrice
+        hexToBytes(tx.gasLimit),                      // gasLimit
+        hexToBytes(tx.to as HexString),               // to
+        hexToBytes(tx.value),                         // value
+        hexToBytes(tx.data),                          // data
+        hexToBytes(`0x${tx.chainId.toString(16)}`),   // v (chainId for EIP-155)
+        new Uint8Array(0),                            // r (empty for unsigned)
+        new Uint8Array(0),                            // s (empty for unsigned)
+      ]
+      const encoded = RLP.encode(txData)
+      return '0x' + Buffer.from(encoded).toString('hex')
+    }
   }
 
   /**

package/src/wallet/hardware/types.ts

@@ -254,6 +254,8 @@ export const HardwareErrorCode = {
   UNSUPPORTED: 'HARDWARE_UNSUPPORTED',
   /** Invalid derivation path */
   INVALID_PATH: 'HARDWARE_INVALID_PATH',
+  /** Invalid parameters provided */
+  INVALID_PARAMS: 'HARDWARE_INVALID_PARAMS',
 } as const
 
 export type HardwareErrorCodeType = typeof HardwareErrorCode[keyof typeof HardwareErrorCode]

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 RECTOR Labs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.