API リファレンス

interface ITransport {
  open(): Promise<void>
  close(): Promise<void>
  isConnected(): boolean
  exchange(apdu: Uint8Array): Promise<Uint8Array>
  lock(): Promise<void>
  unlock(): Promise<void>
}

interface TransportStatus {
  connected: boolean
  deviceName?: string
  deviceId?: string
}

type TransportEventType = 'connected' | 'disconnected' | 'error'

interface TransportEvent {
  type: TransportEventType
  error?: Error
}

type TransportEventHandler = (event: TransportEvent) => void

interface TransportInfo {
  type: string        // 登録名（例: 'webhid'）
  name: string        // 表示名（例: 'WebHID (USB)'）
  available: boolean  // 利用可能か
}

type TransportFactory = () => Promise<ITransport>

interface BtcMessageSignature {
  v: number       // BIP-137 ヘッダバイト（下表）
  r: string       // R 値 (32 bytes hex)
  s: string       // S 値 (32 bytes hex)
  signature: string // 完全な署名 (V || R || S, 65 bytes) の Base64
}

interface InputSigningPath {
  index: number   // PSBT の入力インデックス
  path: string    // BIP32 パス（例: "84'/1'/0'/0/5"）
}

interface XrpSignatureResult {
  signature: string  // 署名 hex (Ed25519: 64B, secp256k1: DER 可変長)
}

type XrpCurve = 'ed25519' | 'secp256k1'

interface SignatureResult {
  v: number    // リカバリー ID
  r: string    // R 値 (32 bytes hex, 0x プレフィックスなし)
  s: string    // S 値 (32 bytes hex, 0x プレフィックスなし)
}

interface DeviceInfo {
  connected: boolean
  path?: string
  vendorId?: number
  productId?: number
}

interface WcSession {
  topic: string
}

interface IWcSignClient {
  request<T>(params: {
    topic: string
    chainId: string
    request: { method: string; params: unknown }
  }): Promise<T>
}

interface WcTransportOptions {
  client: IWcSignClient
  session: WcSession
  chainId?: string  // デフォルト: "eip155:1"
}

class BitcoinApp {
  static readonly sdkBuildId: string

  constructor(transport: ITransport)

  getAddress(testnet?: boolean): Promise<{ publicKey: string; address: string; chainCode: string }>

  getAddressWithPath(path: string): Promise<{ publicKey: string; address: string; chainCode: string }>

  getAccountXpub(coinType: number): Promise<{ publicKey: string; chainCode: string }>

  getExtendedPubkey(path: string, display?: boolean): Promise<BtcXpub>

  getMasterFingerprint(): Promise<string>  // hash160(master pubkey)[:4], 8-char hex (e.g. "631698e0")

  signMessage(message: string, path: string): Promise<BtcMessageSignature>

  signPsbt(psbt: Uint8Array | string): Promise<Uint8Array>

  signPsbtHex(psbt: string): Promise<string>

  signPsbtWithPaths(psbt: string, inputPaths: InputSigningPath[]): Promise<string>
}

// getExtendedPubkey の APDU データ部を組む（純関数）。path は "m/84'/1'/0'" / "84'/1'/0'" / "m"（根）
function buildExtendedPubkeyRequest(path: string, display?: boolean): Uint8Array

// getExtendedPubkey の応答（base58check の文字列）を解く（純関数）。
// 応答が requestedPath のものか（深さ・最後の段・バージョン）を検めて、食い違えば Error を投げる
function parseExtendedPubkeyResponse(xpub: string, requestedPath: string): BtcXpub

const MAX_EXTENDED_PUBKEY_PATH_LEVELS = 10

type DeviceKind = 'openloop' | 'ledger'

class EthereumApp {
  static readonly sdkBuildId: string

  constructor(transport: ITransport)

  setKind(kind: DeviceKind): void

  getKind(): DeviceKind

  getAddress(path: string): Promise<{ publicKey: string; address: string }>

  getAddressWithChainCode(path: string): Promise<{ publicKey: string; address: string; chainCode: string }>

  signPersonalMessage(path: string, message: string, chainId?: number): Promise<SignatureResult>

  signTransaction(path: string, rawTx: string): Promise<SignatureResult>

  signTypedData(
    path: string, domainSeparatorHash: string, messageHash: string, chainId?: number
  ): Promise<SignatureResult>

  signTypedDataStreaming(path: string, typedData: TypedDataLike, chainId?: number): Promise<SignatureResult>

  signAuthorization(path: string, authorizationRlp: string): Promise<SignatureResult>
}

class XrpApp {
  static readonly sdkBuildId: string

  constructor(transport: ITransport)

  getAddress(path: string, curve?: XrpCurve): Promise<{ publicKey: string; address: string }>

  signTransaction(path: string, txBlob: string, curve?: XrpCurve): Promise<XrpSignatureResult>
}

class SolanaApp {
  static readonly sdkBuildId: string

  constructor(transport: ITransport)

  getAddress(path: string): Promise<{ publicKey: string; address: string }>

  signTransaction(path: string, txBytes: Uint8Array): Promise<string>

  signOffchainMessage(path: string, messageBytes: Uint8Array): Promise<string>
}

class TronApp {
  static readonly sdkBuildId: string

  constructor(transport: ITransport)

  getAddress(path: string): Promise<{ publicKey: string; address: string }>

  getAddressWithChainCode(path: string): Promise<{ publicKey: string; address: string; chainCode: string }>

  signTransaction(path: string, rawDataHex: string): Promise<SignatureResult>

  signMessage(path: string, message: string): Promise<SignatureResult>
}

class OpenloopApp {
  constructor(transport: ITransport)

  /**
   * GET_DEVICE_INFO (F0 A0) を送信し、識別 + 状態 + フィーチャー情報を取得します。
   *
   * 戻り値:
   *   - 古い Openloop ファームウェア (v0.91.13 未満) や対応していない
   *     デバイスは null を返します
   *   - APDU の送受信が失敗した場合（デバイスの拒否・通信エラーを含む）も
   *     null を返します
   *   - 応答が 16 バイト未満、または先頭 2 バイトが "OL" でない場合も null を返します
   *   - 排他の取得 (lock) の失敗は throw します
   */
  getDeviceInfo(): Promise<OpenloopDeviceInfo | null>
}

interface OpenloopDeviceInfo {
  modelId: number              // ハードウェア SKU ID（例: 0x0001 = Openloop V1）
  hwRevision: number           // PCB リビジョン
  mainFwVersion: { major: number; minor: number; patch: number }
  recoveryFwVersion: { major: number; minor: number; patch: number }
  state: number                // 16 bit 状態 bitmask（生値）
  stateBits: OpenloopDeviceState  // state を decode したビュー
  features: number             // 16 bit 機能 bitmask（実装詳細・将来変更あり）
}

interface OpenloopDeviceState {
  walletProvisioned: boolean
  language: number            // 0=英語, 1=日本語, 2-7=予約
  usbEnabled: boolean
  usbVidCompat: boolean       // false=Native (0x303A), true=Compatible (0x2C97)
  bleEnabled: boolean
  blePaired: boolean
  fidoEnabled: boolean
  pivEnabled: boolean
}

import { OpenloopApp, formatOpenloopState } from '@openloop/sdk-core'

const app = new OpenloopApp(transport)
const info = await app.getDeviceInfo()

if (info === null) {
  console.log('GET_DEVICE_INFO not supported (old firmware)')
} else {
  console.log(`Model: 0x${info.modelId.toString(16).padStart(4, '0')}`)
  console.log(`FW: ${info.mainFwVersion.major}.${info.mainFwVersion.minor}.${info.mainFwVersion.patch}`)
  console.log(`State: ${formatOpenloopState(info.stateBits)}`)
  if (!info.stateBits.walletProvisioned) {
    // ウォレット未生成のときの分岐
  }
}

import {
  accountPathOf, deriveAddresses, scanAccount, getFeeRate, selectUtxos,
  fetchPrevTx, buildPsbt, extractRawTx, broadcastTx, BtcError,
  type BtcNetwork, type BtcAccount,
} from '@openloop/sdk-core/bitcoin'

type BtcNetworkId = 'mainnet' | 'testnet3' | 'testnet4'

interface BtcNetwork {
  id: BtcNetworkId
  esplora: string[]       // Esplora 互換の端点。先頭（最良）から順に試す
  feeEndpoints: string[]  // `/v1/fees/recommended` を持つ端点（mempool.space 互換）
  timeoutMs: number       // 1 回の呼び出しの時間切れ（ミリ秒）。SDK は既定値を持たない
}

type BtcScript = 'p2pkh' | 'p2sh-p2wpkh' | 'p2wpkh'   // purpose 44' / 49' / 84'

interface BtcAccount {
  script: BtcScript
  account: number         // アカウント番号（強化の境目 0x80000000 未満）
}

interface BtcXpub {       // デバイスから受けた拡張公開鍵（BitcoinApp.getExtendedPubkey の返り値）
  publicKey: string       // 33 バイトの圧縮公開鍵 (hex)
  chainCode: string       // 32 バイト (hex)
  parentFingerprint: number  // 直前の親の指紋（マスターではない）
  depth: number           // m からの段数
  xpub: string            // シリアライズ済みの文字列（xpub… / tpub…）
}

interface BtcUtxo {
  txid: string
  vout: number
  value: number           // sats
  address: string
  path: string            // "m/84'/1'/0'/0/3" の形
  publicKey: string       // 33 バイトの圧縮公開鍵 (hex)
  confirmed: boolean      // 1 確認未満は false
  blockHeight?: number
}

interface BtcAddressCache {
  get(address: string): { path: string; publicKey: string } | undefined
  set(address: string, entry: { path: string; publicKey: string }): void
  syncToDevice(deviceId: string | null): void
  readonly size: number
  clear(): void
}

type BtcAddressKind = 'p2pkh' | 'p2sh' | 'p2wpkh' | 'p2wsh' | 'p2tr'

interface BtcRecipient { address: string; value: number }   // value は sats

interface BtcSelection {
  inputs: BtcUtxo[]
  fee: number             // 実際に払う手数料（sats）= 入力合計 − 出力合計
  change: number          // お釣り（sats）。0 ならお釣りの出力を作らない
  vbytes: number          // 見積もった大きさ（vB）
}

interface BtcScanResult {
  used: Array<{ address: string; path: string }>   // 使われたことのあるアドレス（受取列・お釣り列の両方）
  utxos: BtcUtxo[]
  nextChange: { index: number; address: string; path: string; publicKey: string }  // お釣りに使う次の未使用アドレス
}

interface BtcPsbtInput extends BtcUtxo {
  prevTxHex?: string      // P2PKH のときだけ必須: 前の取引の生の hex
}

interface BtcChangeOutput {
  address: string
  path: string
  publicKey: string
  value: number
}

interface BtcPsbt {
  psbtHex: string
  paths: Array<{ index: number; path: string }>   // BitcoinApp.signPsbtWithPaths に渡す形
}

interface FetchDeps {     // 試験用に差し替えられる取得の設定
  fetchImpl?: typeof fetch
  retryDelayMs?: number   // 既定 1000
  retryCount?: number     // 既定 3（同じ URL への試行回数）
}

function pathOf(acct: BtcAccount, net: BtcNetworkId, change: 0 | 1, index: number): string

function accountPathOf(acct: BtcAccount, net: BtcNetworkId): string

function deriveAddresses(
  xpub: BtcXpub,
  acct: BtcAccount,
  net: BtcNetworkId,
  change: 0 | 1,
  from: number,
  count: number
): Array<{ address: string; path: string; publicKey: string }>

function validateAddress(address: string, net: BtcNetworkId): { kind: BtcAddressKind }

function scanAccount(
  xpub: BtcXpub,
  acct: BtcAccount,
  net: BtcNetwork,
  opts?: {
    cache?: BtcAddressCache
    gapLimit?: number       // 既定 20（1 以上の整数）
    concurrency?: number    // 既定 4（1 以上の整数）
    knownUsed?: Array<{ chain: 0 | 1; index: number }>  // 呼ぶ側が「使われた」と知っている番号
  } & FetchDeps
): Promise<BtcScanResult>

function addressStats(
  address: string,
  net: BtcNetwork,
  deps?: FetchDeps
): Promise<BtcAddressStats>

interface BtcAddressStats {
  txCount: number   // 取引の数（確定＋未確定）。0 より大きければ「使われた」
  funded: number    // 受け取った額の合計（sats・確定＋未確定）
  spent: number     // 使った額の合計（sats・確定＋未確定）。残高は funded - spent
}

function fetchUtxos(
  addresses: Array<{ address: string; path: string; publicKey: string }>,
  net: BtcNetwork,
  deps?: FetchDeps
): Promise<BtcUtxo[]>

function fetchPrevTx(txid: string, net: BtcNetwork, deps?: FetchDeps): Promise<string>

function getFeeRate(net: BtcNetwork, deps?: FetchDeps): Promise<number>

function selectUtxos(
  utxos: BtcUtxo[],
  opts: {
    to: BtcRecipient[]
    feeRate: number
    script: BtcScript
    net: BtcNetworkId
    excluded?: Iterable<string>   // 使用済みの印 "txid:vout"
    changeAddress?: string        // 省略すると、お釣りは入力と同じ型として数える
  }
): BtcSelection

function buildPsbt(args: {
  script: BtcScript
  net: BtcNetworkId
  inputs: BtcPsbtInput[]
  to: Array<{ address: string; value: number }>
  change?: BtcChangeOutput    // お釣りの出力を作らないときは渡さない
}): BtcPsbt

function extractRawTx(signedPsbtHex: string): { rawTxHex: string; txid: string }

function broadcastTx(
  rawTxHex: string,
  net: BtcNetwork,
  expectedTxid?: string,
  deps?: FetchDeps
): Promise<string>

function createAddressCache(): BtcAddressCache

function findAddressPath(
  address: string,
  xpub: BtcXpub,
  acct: BtcAccount,
  net: BtcNetworkId,
  cache?: BtcAddressCache,
  opts?: { maxIndex?: number; step?: number }   // 既定 200 / 20
): string | null

// 圧縮公開鍵（hex・0x あり/なし）からその型のアドレスを作る
function publicKeyToAddress(publicKey: string, script: BtcScript, net: BtcNetworkId): string

// 取引の大きさ（vB）を見積もる。outputVbytes は OUTPUT_VBYTES の値の配列
function estimateVbytes(numInputs: number, script: BtcScript, outputVbytes: number[]): number

// 宛先のアドレスを scriptPubKey にする（validateAddress と同じ検査をします）
function addressToScriptPubKey(address: string, net: BtcNetworkId): Uint8Array

// witness アドレス（bech32 / bech32m）の組み立てと展開
function encodeSegwitAddress(hrp: string, version: number, program: Uint8Array): string
function decodeSegwitAddress(address: string): { hrp: string; version: number; program: Uint8Array }

// 手数料率（sat/vB）
const MIN_FEE_RATE_SAT_VB = 1
const MAX_FEE_RATE_SAT_VB = 5000

// 手数料の門
const MAX_ABSOLUTE_FEE_SATS = 10_000_000        // 0.1 BTC
const MAX_FEE_FRACTION = 1.0                    // 手数料 / 送金額の上限（100%）
const FEE_FRACTION_MIN_AMOUNT_SATS = 1_000_000  // この額未満の送金には割合の門を当てない

// 組み立て
const DUST_SATS = 546                           // これ未満のお釣りは出力にしない
const MAX_PREV_TX_BYTES = 4096                  // 前の取引の大きさの上限（デバイスの上限）
const RBF_SEQUENCE = 0xfffffffd                 // 全入力の sequence

// 署名済み PSBT の読み戻し
const PSBT_RESPONSE_CHUNK_SIZE = 250            // 1 かたまりのバイト数
const PSBT_MAX_RESPONSE_CHUNKS = 256            // かたまりの数（番号が APDU の P1 の 1 バイト）
const MAX_SIGNED_PSBT_BYTES = 64000             // 250 × 256

// 大きさの見積り（vB）
const INPUT_VBYTES = { 'p2pkh': 148, 'p2sh-p2wpkh': 91, 'p2wpkh': 68 }
const OUTPUT_VBYTES = { p2wpkh: 31, p2tr: 43, p2wsh: 43, p2pkh: 34, p2sh: 32 }
const TX_OVERHEAD_VBYTES = 10.5

// パス
const PURPOSE_OF_SCRIPT = { 'p2pkh': 44, 'p2sh-p2wpkh': 49, 'p2wpkh': 84 }
const COIN_TYPE_OF_NETWORK = { mainnet: 0, testnet3: 1, testnet4: 1 }

// 端点への取得（FetchDeps の既定値）
const API_RETRY_COUNT = 3            // 1 つの URL への試行回数
const API_RETRY_DELAY_MS = 1000      // 試行の間隔（ミリ秒）
const API_PARALLEL_LIMIT = 4         // 同時に走らせる取得の数

type BtcErrorCode =
  | 'bad_argument'              // 引数が不正（パス・index・網と型の組み合わせ・長さ）。呼び出し側の誤り
  | 'invalid_address'           // 宛先として読めない（チェックサム・文字・長さ）
  | 'network_mismatch'          // 読めるが、今の網のアドレスではない
  | 'fetch_failed'              // 端点に訊けなかった（全端点が失敗）
  | 'bad_response'              // 端点の答えが不正（hash が合わない・txid が違うなど）
  | 'prev_tx_too_large'         // 前の取引がデバイスの上限（4,096 B）を超える
  | 'fee_rate_out_of_range'     // 手数料率が範囲外
  | 'insufficient'              // 残高が不足している
  | 'insufficient_unconfirmed'  // 確定待ちを数えれば足りる
  | 'fee_too_high'              // 手数料が絶対額の上限を超える
  | 'fee_exceeds_amount'        // 手数料が送金額を超える
  | 'psbt_too_large'            // 署名済み PSBT が読み戻せる上限（64,000 B）を超えた
  | 'bad_psbt'                  // PSBT として読めない
  | 'broadcast_rejected'        // 放送が受理されなかった

class BtcError extends OpenloopError {
  static readonly sdkBuildId: string
  name: string  // 'BtcError'
  readonly code: BtcErrorCode
  constructor(code: BtcErrorCode, message: string)
}

import { BitcoinApp } from '@openloop/sdk-core'
import {
  accountPathOf, scanAccount, getFeeRate, selectUtxos, buildPsbt,
  extractRawTx, broadcastTx, createAddressCache,
  type BtcNetwork, type BtcAccount,
} from '@openloop/sdk-core/bitcoin'

const net: BtcNetwork = {
  id: 'testnet3',
  esplora: ['https://blockstream.info/testnet/api', 'https://mempool.space/testnet/api'],
  feeEndpoints: ['https://mempool.space/testnet/api'],
  timeoutMs: 15_000,
}
const acct: BtcAccount = { script: 'p2wpkh', account: 0 }
const cache = createAddressCache()

const btc = new BitcoinApp(transport)

// 1. アカウントの拡張公開鍵（"m/84'/1'/0'"）を取得し、デバイスの持ち主をキャッシュに伝える
const xpub = await btc.getExtendedPubkey(accountPathOf(acct, net.id))
cache.syncToDevice(await btc.getMasterFingerprint())

// 2. 走査して UTXO とお釣りの次のアドレスを得る
const { utxos, nextChange } = await scanAccount(xpub, acct, net, { cache })

// 3. 手数料率を取得し、使う UTXO を選ぶ
const feeRate = await getFeeRate(net)
const to = [{ address: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', value: 50_000 }]
const sel = selectUtxos(utxos, { to, feeRate, script: acct.script, net: net.id, changeAddress: nextChange.address })

// 4. PSBT を組み、デバイスで署名し、取り出して放送する
const { psbtHex, paths } = buildPsbt({
  script: acct.script,
  net: net.id,
  inputs: sel.inputs,
  to,
  change: sel.change > 0 ? { ...nextChange, value: sel.change } : undefined,
})
const signedPsbtHex = await btc.signPsbtWithPaths(psbtHex, paths)
const { rawTxHex, txid } = extractRawTx(signedPsbtHex)
await broadcastTx(rawTxHex, net, txid)

import { fetchPrevTx, type BtcPsbtInput } from '@openloop/sdk-core/bitcoin'

const inputs: BtcPsbtInput[] = await Promise.all(
  sel.inputs.map(async (u) => ({ ...u, prevTxHex: await fetchPrevTx(u.txid, net) }))
)

import { BtcError } from '@openloop/sdk-core/bitcoin'

try {
  // …上の流れ…
} catch (e) {
  if (e instanceof BtcError) {
    const code = e.code
    if (code === 'insufficient_unconfirmed') {
      // 「確定を待てば送金できます」と案内する
    }
  }
}

import { verifyPersonalSign } from '@openloop/sdk-core/verify'

const result = await verifyPersonalSign(message, sig, address)
// result: { recovered: string; expected?: string; ok: boolean }

// 戻り値（いずれの関数も）
interface VerifyResult {
  recovered: string   // 復元した署名者（EVM: アドレス）。ed25519 の検証では結果を表す文字列
  expected?: string
  ok: boolean
}

class OpenloopError extends Error {
  name: string  // 'OpenloopError'
}

class ApduError extends OpenloopError {
  name: string  // 'ApduError'
  readonly statusWord: number
  constructor(statusWord: number)
}

type TransportErrorCode =
  | 'not-supported'   // 実行環境がデバイスと話せない
  | 'not-found'       // 一致するデバイスが無い / 選択がキャンセルされた
  | 'not-connected'   // 接続が開いていない
  | 'timeout'         // 応答が時間内に来なかった
  | 'disconnected'    // 使用中に切断された
  | 'io'              // それ以外

class TransportError extends OpenloopError {
  name: string  // 'TransportError'
  readonly code: TransportErrorCode        // v0.6.0 で追加
  stale?: boolean
  busy?: boolean
  noResponse?: boolean
  sent?: number
  awaited?: boolean
  constructor(message: string, code?: TransportErrorCode)  // 既定は 'io'
}

class OpenloopSDK {
  static readonly sdkBuildId: string

  static registerTransport(type: string, config: {
    factory: TransportFactory
    name: string
    isAvailable: () => boolean | Promise<boolean>
  }): void

  static discover(): Promise<TransportInfo[]>

  static connect(opts?: { transport?: string }): Promise<ITransport>

  static getRegisteredTransports(): string[]

  static clearTransports(): void
}

class WcTransport implements ITransport {
  constructor(options: WcTransportOptions)
  open(): Promise<void>
  close(): Promise<void>
  isConnected(): boolean
  lock(): Promise<void>
  unlock(): Promise<void>
  exchange(apdu: Uint8Array): Promise<Uint8Array>
}

const OPENLOOP_VENDOR_ID  = 0x303a   // Espressif VID
const OPENLOOP_PRODUCT_ID = 0x8341   // Openloop PID
const LEDGER_VENDOR_ID    = 0x2c97   // Ledger SAS VID
const LEDGER_PRODUCT_ID   = 0x1011   // Nano S 互換
const LEDGER_USAGE_PAGE   = 0xffa0   // Ledger HID usage page (APDU transport)

const BTC_MAINNET_PATH  = "84'/0'/0'/0/0"
const BTC_TESTNET_PATH  = "84'/1'/0'/0/0"
const DEFAULT_ETH_PATH  = "44'/60'/0'/0/0"
const DEFAULT_XRP_PATH  = "44'/144'/0'/0'/0'"
const DEFAULT_SOL_PATH  = "44'/501'/0'/0'"
const DEFAULT_TRON_PATH = "44'/195'/0'/0/0"

const BLE_SERVICE_UUID      = '13d63400-2c97-0004-0000-4c6564676572'
const BLE_NOTIFY_UUID       = '13d63400-2c97-0004-0001-4c6564676572'
const BLE_WRITE_UUID        = '13d63400-2c97-0004-0002-4c6564676572'
const BLE_DEVICE_NAME_PREFIX = 'Openloop'
const BLE_DEFAULT_MTU       = 155

const WALLETCONNECT_PROJECT_ID = 'b3d610140c2d0d39f50150a030c7c985'

const SUPPORTED_BIP122_CHAINS = [
  'bip122:000000000019d6689c085ae165831e93', // Bitcoin Mainnet
  'bip122:000000000933ea01ad0ee984209779ba', // Bitcoin Testnet3
] as const

const SUPPORTED_EVM_CHAINS = [
  'eip155:1',         // Ethereum Mainnet
  'eip155:11155111',  // Sepolia Testnet
] as const

const SUPPORTED_SOLANA_CHAINS = [
  'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', // Mainnet Beta
  'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',  // Devnet
] as const

const SUPPORTED_TRON_CHAINS = [
  'tron:0x2b6653dc',  // TRON Mainnet
  'tron:0x94a9059e',  // TRON Shasta Testnet
] as const

const SUPPORTED_BIP122_METHODS = [
  'signPsbt', 'getAccountAddresses', 'signMessage', 'sendTransfer',
] as const

const SUPPORTED_EVM_METHODS = [
  'eth_sendTransaction', 'eth_signTransaction', 'eth_sign',
  'personal_sign', 'eth_signTypedData', 'eth_signTypedData_v3',
  'eth_signTypedData_v4', 'wallet_getCapabilities',
] as const

const SUPPORTED_SOLANA_METHODS = [
  'solana_signTransaction', 'solana_signAllTransactions',
  'solana_signAndSendTransaction', 'solana_signMessage',
] as const

const SUPPORTED_TRON_METHODS = [
  'tron_signTransaction', 'tron_signMessage',
] as const

const SUPPORTED_EVENTS = ['chainChanged', 'accountsChanged'] as const

const APDU = {
  // クラスバイト
  CLA_ETHEREUM: 0xe0,
  CLA_OPENLOOP: 0xf0,         // Openloop 独自（chain_id 付き署名・PSBT）
  CLA_V2: 0xe1,               // Ledger Bitcoin v2 プロトコル（拡張公開鍵の取得）

  // 共通 INS（Ethereum / TRON / XRP。BIP44 の coin_type で自動ルーティング）
  INS_GET_PUBLIC_KEY: 0x02,    // アドレス/公開鍵取得
  INS_SIGN_TX: 0x04,           // トランザクション署名
  INS_SIGN_MESSAGE: 0x08,      // personal_sign (EIP-191) / TRON メッセージ
  INS_SIGN_EIP712: 0x0c,       // EIP-712 Typed Data
  INS_EIP712_STRUCT_DEF: 0x1a, // EIP-712 ストリーミング: 型定義（P2=0x00 構造体名 / 0xFF フィールド）
  INS_EIP712_STRUCT_IMPL: 0x1c, // EIP-712 ストリーミング: 値（P2=0x00 ルート / 0x0F 配列 / 0xFF フィールド）
  INS_SIGN_AUTHORIZATION: 0x34, // EIP-7702

  // Bitcoin 拡張公開鍵（CLA_V2）
  INS_V2_GET_EXTENDED_PUBKEY: 0x00, // 任意のパスの拡張公開鍵取得

  // Bitcoin PSBT（Openloop 独自）
  INS_BTC_SIGN_PSBT: 0x70,          // PSBT 送信
  INS_BTC_GET_SIGNED_PSBT: 0x71,    // 署名済み PSBT 取得
  INS_BTC_GET_WALLET_PUBLIC_KEY: 0x40, // BTC 公開鍵/アドレス取得
  INS_BTC_GET_ACCOUNT_XPUB: 0x72,   // アカウント xpub 取得
  INS_BTC_SIGN_MESSAGE: 0x73,       // BTC メッセージ署名

  // Solana（Ledger Solana 互換）
  INS_SOL_GET_PUBKEY: 0x05,         // Ed25519 公開鍵取得
  INS_SOL_SIGN_MESSAGE: 0x06,       // トランザクション/メッセージ署名
  INS_SOL_SIGN_OFFCHAIN_MSG: 0x07,  // オフチェーンメッセージ署名
} as const

const SDK_BUILD_ID: string   // 例: "@openloop/sdk-core@0.7.0"

// APDU コマンド構築（ISO 7816-4）。データが 255 バイト以下なら Short 形式
// [CLA][INS][P1][P2][Lc][Data...]、256 バイト以上なら Extended 形式
// [CLA][INS][P1][P2][0x00][Lc_HI][Lc_LO][Data...] を自動で選ぶ
function buildApdu(cla: number, ins: number, p1: number, p2: number, data?: Uint8Array): Uint8Array

// BIP32 パスをバッファに変換: [要素数 (1 byte)][各要素 4 byte ビッグエンディアン]。"m/" は省略可、強化は '。要素の検査はしない
function pathToBuffer(path: string): Uint8Array

// BIP32 パスを要素配列に変換（強化は 0x80000000 を加算）。例: "84'/0'/0'/0/0" -> [0x80000054, 0x80000000, 0x80000000, 0, 0]。要素の検査はしない
function pathToElements(path: string): number[]

// Uint8Array の結合
function concat(...arrays: Uint8Array[]): Uint8Array

// hex 文字列を Uint8Array に変換（0x プレフィックスあり/なし対応）。桁数・文字の検査はしない
function hexToBytes(hex: string): Uint8Array

// Uint8Array を hex 文字列に変換（0x プレフィックスなし）
function bytesToHex(bytes: Uint8Array): string

// Base58 エンコード/デコード（検査符号なし）。decode は不正な文字で Error
function base58Encode(bytes: Uint8Array): string
function base58Decode(str: string): Uint8Array

// OpenloopDeviceState を 1 行のログ用文字列に整形
// 例: "wallet=N lang=0 USB(native) ble=off FIDO PIV"
function formatOpenloopState(s: OpenloopDeviceState): string

const BIP32_VERSION_XPUB = 0x0488b21e   // 本番（xpub…）
const BIP32_VERSION_TPUB = 0x043587cf   // 試験網（tpub…）

interface ExtendedPublicKey {
  version: number          // BIP32_VERSION_XPUB か BIP32_VERSION_TPUB
  depth: number
  parentFingerprint: number
  childNumber: number      // この鍵自身の子の番号（強化なら 0x80000000 を含む）
  chainCode: string        // 32 バイト (hex)
  publicKey: string        // 33 バイトの圧縮公開鍵 (hex)
}

// 親の圧縮公開鍵（hex）と chain code（hex）から、非強化の子（index は 0x80000000 未満の整数）を導出する
function deriveChildPublicKey(
  parentPubkey: string, parentChainCode: string, index: number
): { publicKey: string; chainCode: string }

// 直列化された拡張公開鍵を解く。xpub / tpub 以外・曲線上にない点・秘密鍵入りは Error
function decodeExtendedPubkey(serialized: string): ExtendedPublicKey

// base58check（4 バイトの検査符号付き）。decode は検査符号を必ず照合する
function base58CheckDecode(str: string): Uint8Array
function base58CheckEncode(payload: Uint8Array): string

interface TypedDataLike {
  domain: Record<string, unknown>
  types: Record<string, Array<{ name: string; type: string }>>
  primaryType: string
  message: Record<string, unknown>
}

// EIP-712 の内容そのものをデバイスへ順に送信して署名する（EthereumApp.signTypedDataStreaming の実体）
function signTypedDataStreaming(
  transport: ITransport, path: string, td: TypedDataLike, chainId: number
): Promise<SignatureResult>

// ペイロードが EIP-3009（TransferWithAuthorization / ReceiveWithAuthorization）の形か
function isEip3009(td: TypedDataLike): boolean

// メッセージを Solana のオフチェーンメッセージ形式で包む。format を省略すると、
// すべて印字可能な ASCII（0x20〜0x7E）なら 0、そうでなければ 1
function wrapSolanaOffchainMessage(message: Uint8Array, formatOverride?: 0 | 1 | 2): Uint8Array

// data が Solana オフチェーンメッセージの署名ドメインで始まるか
function isSolanaOffchainMessageWrapped(data: Uint8Array): boolean

// 署名ドメイン（16 バイト: 0xFF + "solana offchain"）
const SOLANA_OFFCHAIN_SIGNING_DOMAIN: Uint8Array