Common Patterns

interface FeeOption {
  low?: {}           // Use low fee rate
  medium?: {}        // Use medium fee rate
  high?: {}          // Use high fee rate
  custom?: {         // Use custom fee rate
    feeRate: FeeRate
  }
}

// Low fee
const feeOption = { low: {} }

// Medium fee (recommended default)
const feeOption = { medium: {} }

// High fee
const feeOption = { high: {} }

// Custom fee (advanced)
const feeOption = {
  custom: {
    feeRate: {
      priorityFeePerUnit: { value: '1000000000' },  // 1 Gwei
      maxFeePerUnit: { value: '2000000000' }       // 2 Gwei
    }
  }
}

// The grpcWebClient automatically converts string to FeeOption
await hydraGrpcClient.openChannel(
  network,
  nodeId,
  assetAmounts,
  'medium'  // Automatically converted to { medium: {} }
)

interface FeeRate {
  maxFeePerUnit: U256String       // Maximum fee per gas/weight unit
  priorityFeePerUnit: U256String  // Priority fee per gas/weight unit
}

interface U256String {
  value: string  // String representation of uint256
}

const feeRate = {
  priorityFeePerUnit: { value: '1000000000' },    // 1 Gwei tip
  maxFeePerUnit: { value: '10000000000' }       // 10 Gwei max
}

// Low priority
const lowFee = {
  priorityFeePerUnit: { value: '100000000' },     // 0.1 Gwei
  maxFeePerUnit: { value: '1000000000' }        // 1 Gwei
}

// Medium priority (recommended)
const mediumFee = {
  priorityFeePerUnit: { value: '1000000000' },    // 1 Gwei
  maxFeePerUnit: { value: '10000000000' }       // 10 Gwei
}

// High priority
const highFee = {
  priorityFeePerUnit: { value: '2000000000' },    // 2 Gwei
  maxFeePerUnit: { value: '50000000000' }       // 50 Gwei
}

interface FeeEstimate {
  low: ChainFee
  medium: ChainFee
  high: ChainFee
}

interface ChainFee {
  baseFeePerUnit: U256String       // Current base fee on the network
  feeRate: FeeRate                 // The fee rate (max + priority)
  effectiveFeePerUnit: U256String  // Effective fee per gas/weight unit
}

const resp = await blockchain.getFeeEstimates(req, {})
const fe = resp.getFeeEstimate()
console.log('Medium fee rate:', fe?.getMedium()?.getFeeRate()?.toObject())
console.log('Effective:', fe?.getMedium()?.getEffectiveFeePerUnit()?.getValue())

interface DecimalString {
  value: string  // e.g., '1.5', '0.001', '0.00000001'
}

// FeeRate uses U256String — base-unit values
const feeRate = {
  maxFeePerUnit:      { value: '50' },   // 50 sat/vbyte (Bitcoin)
                                          //  OR 50 wei/gas (EVM, but you'd usually use much larger)
  priorityFeePerUnit: { value: '5' },
}

// Amount uses DecimalString — human-readable
const amount = {
  exact: { amount: { value: '0.001' } },  // 0.001 BTC = 100,000 sats
}

interface Amount {
  exact?: {          // Send exact amount
    amount: DecimalString
  }
  all?: {}           // Send all available balance
}

// Send exact amount
const amount = {
  exact: {
    amount: { value: '1.5' }
  }
}

// Send all available
const amount = {
  all: {}
}

interface WithdrawAmount {
  selfWithdrawal: Amount          // Amount to withdraw to your wallet
  counterpartyWithdrawal: Amount  // Amount to withdraw to the counterparty's wallet
}

const withdrawAmount = {
  selfWithdrawal: {
    exact: { amount: { value: '0.5' } }
  },
  counterpartyWithdrawal: {
    exact: { amount: { value: '0.0' } }
  }
}

interface DepositAmount {
  all?: {}                    // Deposit the entire available balance
  exact?: {                   // Deposit a specific amount (single-funded)
    amount: DecimalString
  }
  dualFunded?: {              // Explicit balance distribution
    local: DecimalString        // Channel balance assigned to you
    remote: DecimalString       // Channel balance assigned to the counterparty
    selfDeposit: DecimalString  // What actually leaves your wallet
  }
}

// Common fee-payment fields, present on all three Lease requests:
interface LeaseFeePayment {
  paymentNetwork: Network
  paymentAssetId: string

  // exactly one of:
  onchainFeePayment?:
    | { utxo: { refundAddress: string } }
    | { account: { senderAddress: string; refundAddress?: string } }
  offchainFeePayment?: {}
  dualFundFeePayment?: {}              // channel liquidity requests only
  sponsoredDepositFeePayment?: {}      // channel liquidity requests only
  sponsoredWithdrawalFeePayment?: {}   // release requests only

  quoteId?: string                     // from the matching Estimate*Fee call
}

interface RequestChannelLiquidityRequest extends LeaseFeePayment {
  network: Network
  operation: ChannelLiquidityRequestOperation  // open / deposit / deposit_any / open_or_deposit
  leaseDurationSeconds?: number  // required when any asset has server_amount > 0
  clientRequestId?: string       // your name for the request, 1 to 64 characters
}

const network = { protocol: 1, id: '0a03cf40' }                              // Bitcoin Signet
const BTC = '0x0000000000000000000000000000000000000000000000000000000000000000'

const req = {
  network,
  operation: {
    open: {
      assetLiquidity: {
        // Keyed by ASSET ID, never by ticker.
        [BTC]: {
          serverAmount: { value: '0.1' },            // the service provides 0.1 BTC
          clientAmount: { value: '0' },
        },
      },
    },
  },
  leaseDurationSeconds: 30 * 24 * 60 * 60,         // required: serverAmount > 0
  paymentNetwork: network,
  paymentAssetId: BTC,
  offchainFeePayment: {},
  clientRequestId: 'lease-btc-0001',               // persist it; a retry reuses it
}

// Price it first, then bill at that price.
const { fee, quoteId } = await liquidity.estimateRequestChannelLiquidityFee(req, {})
// Open liquidity.SubscribeLiquidityRequests BEFORE this call to follow the request.
// On a retry, send this same object again: a fresh quoteId would make it a different request.
const { request } = await liquidity.submitChannelLiquidityRequest({ ...req, quoteId }, {})
// request.feeSettled: the fee is settled. The request is done once it is final.

interface LiquidityRequest {
  paymentUuid: string                  // the service's id: its fee payment's payment_uuid
  clientRequestId?: string
  network: Network
  operation: FeePaymentOperation       // what was committed: provision / release / leaseExtension
  rail: FeePaymentRail                 // ONCHAIN / OFFCHAIN / DUAL_FUND / SPONSORED_DEPOSIT / SPONSORED_WITHDRAWAL
  paymentNetwork: Network
  paymentAssetId: string
  fee: DecimalString                   // what the service bills, in paymentAssetId
  feeDeadline?: Timestamp              // absent on DUAL_FUND
  feeSettlement?: LiquidityFeeTransfer // absent until settled, and on the rails the service broadcasts
  createdAt: Timestamp
  updatedAt: Timestamp

  // exactly one of — completed, failed, unresolved and expired are final:
  awaitingFee?: {}
  feeSettled?: {}                      // what Submit* answers with, normally
  feeSettlementFailed?: { reason: string }   // not final: the fee may still arrive
  completed?: {                        // at most one arm; none when the report was missed
    channelLiquidity?: { channelId: string; txid: string }
    channelRelease?: { channelId: string; txid: string }
    channelLeaseExtension?: { channelId: string; assetId: string; leaseExpiry: Timestamp }
  }
  failed?: { reason?: string; refund?: LiquidityFeeRefund }   // reason: absent when the report was missed
  unresolved?: { reason?: string }     // the outcome is unknown: read the channel
  expired?: {}                         // nothing was billed
}

type LiquidityFeeTransfer =            // how a fee, or its refund, moved
  | { onchain: { txid: string } }
  | { offchain: { paymentId: string } }

interface LiquidityFeeRefund {         // goes back the way the fee came
  amount: DecimalString                // on chain, the transaction carries this less its estimated cost
  transfer: LiquidityFeeTransfer
}

interface ChannelReleaseOperation {
  // exactly one:
  withdraw?: {
    channelId: string
    // asset_id → per-side amounts; at least one side per asset.
    assetAmounts: Record<string, { serverAmount?: Amount; clientAmount?: Amount }>
  }
  cooperativeClose?: {
    channelId: string
    assetIds: string[]   // empty closes EVERY asset channel
  }
}

interface RequestChannelReleaseRequest extends LeaseFeePayment {
  network: Network
  operation: ChannelReleaseOperation
  // dualFundFeePayment / sponsoredDepositFeePayment are NOT valid here;
  // sponsoredWithdrawalFeePayment is valid ONLY here
  clientRequestId?: string   // your name for the request, 1 to 64 characters
}

// Answers { request: LiquidityRequest }; completed, its arm is channelRelease.
const { request } = await liquidity.submitChannelReleaseRequest(releaseReq, {})

interface RequestChannelLeaseExtensionRequest extends LeaseFeePayment {
  network: Network
  channelId: string
  assetId: string
  leaseExtensionSeconds: number   // delta — added to the current expiry
  // only onchain / offchain fee payment are valid here
  clientRequestId?: string        // your name for the request, 1 to 64 characters
}

// Answers { request: LiquidityRequest }; completed, its arm is channelLeaseExtension.
const { request } = await liquidity.submitChannelLeaseExtensionRequest(extensionReq, {})

interface OrderbookCurrency {
  protocol: Protocol     // BITCOIN or EVM
  networkId: string      // Network ID
  assetId: string       // Asset ID
}

const baseCurrency = {
  protocol: Protocol.PROTOCOL_EVM,
  networkId: '11155111',  // Ethereum Sepolia
  assetId: '<asset_id>',  // Token contract for ERC-20s, or asset.GetNativeAsset().id for native ETH
}

const quoteCurrency = {
  protocol: Protocol.PROTOCOL_BITCOIN,
  networkId: '0a03cf40',  // Bitcoin Signet
  assetId: '<asset_id>',  // Use asset.GetNativeAsset({ network: signet }).id for native BTC
}

// Initialize market
await orderbook.initMarket({ base: baseCurrency, quote: quoteCurrency }, {})

interface SwapAmount {
  from?: { amount: DecimalString }  // Specify input amount
  to?: { amount: DecimalString }    // Specify output amount
}

// Swap exactly 1.0 ETH for BTC
const swapAmount = {
  from: { amount: { value: '1.0' } }
}

// Get exactly 0.1 BTC for ETH
const swapAmount = {
  to: { amount: { value: '0.1' } }
}

enum ChannelStatus {
  INACTIVE = 0,
  ACTIVE = 1,
  UPDATING = 2,
  CLOSED = 3,
  CLOSED_REDEEMABLE = 4
}

interface AssetChannelStatus {
  cooperativelyOpening?: {}
  opening?: {}
  cooperativelyUpdating?: {}
  updating?: {}
  cooperativelyClosing?: {}
  closing?: { closedAtBlock: string }
  forceClosing?: {
    forceClosedAtBlock?: string
    disputer: Disputer
    disputeDeadline?: Deadline
  }
  closedRedeemable?: {}
  closed?: { forceClosed: boolean }  // forceClosed added 2026-05-03
  inactive?: {}
  activeSending?: {}
  activeReceiving?: {}
  active?: {}
  recovering?: {}
}
// closed.forceClosed: false = cooperative close (on lithium the channel
// slot can be reused for further deposits); true = unilateral/disputed
// close (slot is permanently dead — open a new channel).

await hydraGrpcClient.depositChannel(network, channelId, amounts, 'medium')
// This might work with helper, but raw gRPC call needs object

const request = {
  network,
  channelId,
  assetAmounts,
  feeOption: { medium: {} }  // Proper FeeOption structure
}

const feeRate = { value: '10' }  // Incorrect structure

const feeRate = {
  priorityFeePerUnit: { value: '1000000000' },
  maxFeePerUnit: { value: '2000000000' }
}

const amount = 1.5  // Numbers lose precision

const amount = { value: '1.5' }  // Always use string

const sendAmount = { amount: '1.5' }  // Missing exact/all wrapper

const amount = {
  exact: {
    amount: { value: '1.5' }
  }
}

// Converts string fee rate to FeeOption
private convertFeeRateToFeeOption(feeRate: string): FeeOption {
  switch (feeRate) {
    case 'low': return { low: {} }
    case 'medium': return { medium: {} }
    case 'high': return { high: {} }
    default: return { medium: {} }
  }
}

// Automatically transforms asset amounts
// From: { assetId: { exact: { amount: '1.0' } } }
// To:   { assetId: { exact: { amount: { value: '1.0' } } } }

feeRate: { value: '10' }   // ❌ FeeRate isn't a DecimalString

feeRate: {
  maxFeePerUnit:      { value: '50' },   // ✅ U256String
  priorityFeePerUnit: { value: '5' },    // ✅ U256String
}

await this.grpcCall(
  'hydra_app.NodeService',
  'OpenChannel',
  request,
  (req) => new Uint8Array()  // ❌ Placeholder encoder
)

import { OpenChannelRequest, OpenChannelResponse } from '@/proto/node'

await this.grpcCall<OpenChannelRequest, OpenChannelResponse>(
  'hydra_app.NodeService',
  'OpenChannel',
  request,
  OpenChannelRequest.encode  // ✅ Proper protobuf encoder
)

// Check balance before operation
const balances = await hydraGrpcClient.getBalances(network)
const ethBalance = balances.balances.find(b => b.assetId === '0x0000...')

if (parseFloat(ethBalance.onchain?.usable?.value || '0') < parseFloat(amountNeeded)) {
  console.error('Insufficient onchain balance')
  // Show error to user or request deposit
}

// Connect to peer first
await hydraGrpcClient.connectToPeer(network, peerUrl)

// Wait a moment for connection to establish
await new Promise(resolve => setTimeout(resolve, 1000))

// Then open channel
await hydraGrpcClient.openChannel(network, nodeId, assetAmounts, 'medium')

// Generated from the .proto files in /proto

/** Network identifier */
interface Network {
  protocol: Protocol      // PROTOCOL_BITCOIN = 1, PROTOCOL_EVM = 2
  id: string              // Magic bytes (hex) for Bitcoin, decimal chain ID for EVM
}

enum Protocol {
  PROTOCOL_UNSPECIFIED = 0,
  PROTOCOL_BITCOIN = 1,
  PROTOCOL_EVM = 2,
}

/** Decimal string — human-readable, NOT base units */
interface DecimalString {
  value: string  // e.g., '1.5', '0.001' — always in whole-asset units
}

/** 256-bit unsigned integer as string */
interface U256String {
  value: string  // e.g., '1000000000' for 1 Gwei
}

/** Fee option for channel operations (oneof type) */
interface FeeOption {
  low?: {}
  medium?: {}
  high?: {}
  custom?: {
    feeRate: FeeRate
  }
}

/** Fee rate (per gas/weight unit) */
interface FeeRate {
  maxFeePerUnit: U256String       // Max fee per gas/weight unit
  priorityFeePerUnit: U256String  // Priority fee per gas/weight unit
}

/** Single ChainFee inside a FeeEstimate */
interface ChainFee {
  baseFeePerUnit: U256String       // Current network base fee
  feeRate: FeeRate                 // Suggested rate
  effectiveFeePerUnit: U256String  // Effective fee per unit
}

/** Result of blockchain.GetFeeEstimates */
interface FeeEstimate {
  low: ChainFee
  medium: ChainFee
  high: ChainFee
}

/** Amount to send (oneof type) — used by SendTransaction, OpenChannel, etc. */
interface Amount {
  exact?: {
    amount: DecimalString
  }
  all?: {}
}

/** Withdrawal amounts (both sides withdraw in the same tx) */
interface WithdrawAmount {
  selfWithdrawal: Amount
  counterpartyWithdrawal: Amount
}

/** Asset amounts map — used by OpenChannel, DepositChannel, etc. */
type AssetAmounts = {
  [assetId: string]: Amount
}

/** Withdrawal amounts map */
type WithdrawAssetAmounts = {
  [assetId: string]: WithdrawAmount
}

/** Used by orderbook and swap RPCs (separate from Network) */
interface OrderbookCurrency {
  protocol: Protocol
  networkId: string  // Same shape as Network.id
  assetId: string
}

// Log the encoded request before sending
const request = OpenChannelRequest.create({
  network,
  peerUrl: nodeId,
  assetAmounts,
  feeOption: { medium: {} }
})

console.log('Request:', JSON.stringify(request, null, 2))

// Verify encoding works
const encoded = OpenChannelRequest.encode(request).finish()
console.log('Encoded length:', encoded.length)

// Decode to verify
const decoded = OpenChannelRequest.decode(encoded)
console.log('Decoded:', JSON.stringify(decoded, null, 2))

try {
  const response = await hydraGrpcClient.getBalances(network)

  console.log('Response structure:', {
    hasBalances: Array.isArray(response.balances),
    balanceCount: response.balances?.length,
    firstBalance: response.balances?.[0],
    fields: Object.keys(response)
  })
} catch (error: any) {
  console.error('Error details:', {
    message: error.message,
    code: error.code,
    details: error.details,
    stack: error.stack
  })
}

// DON'T use parseFloat for comparisons
const amount1 = '0.1'
const amount2 = '0.2'
const sum = parseFloat(amount1) + parseFloat(amount2)  // ❌ 0.30000000000000004

// DO use string operations or BigInt for precision
import Big from 'big.js'  // or use a decimal library

const amount1 = new Big('0.1')
const amount2 = new Big('0.2')
const sum = amount1.plus(amount2).toString()  // ✅ '0.3'

async function openChannelSafely(
  network: Network,
  nodeId: string,
  assetAmounts: AssetAmounts,
  feeRate: 'low' | 'medium' | 'high'
) {
  try {
    // 1. Check balance
    const balances = await hydraGrpcClient.getBalances(network)
    for (const [assetId, amount] of Object.entries(assetAmounts)) {
      const balance = balances.balances.find(b => b.assetId === assetId)
      const available = parseFloat(balance?.onchain?.usable?.value || '0')
      const needed = parseFloat(amount.exact?.amount?.value || '0')

      if (available < needed) {
        throw new Error(`Insufficient ${assetId}: have ${available}, need ${needed}`)
      }
    }

    // 2. Connect to peer if not connected
    try {
      await hydraGrpcClient.connectToPeer(network, nodeId)
      await new Promise(resolve => setTimeout(resolve, 1000))
    } catch (err: any) {
      if (!err.message.includes('already connected')) {
        throw err
      }
    }

    // 3. Open channel
    const response = await hydraGrpcClient.openChannel(
      network,
      nodeId,
      assetAmounts,
      feeRate
    )

    console.log('✅ Channel opened:', response.channelId)
    return response
  } catch (error: any) {
    console.error('❌ Failed to open channel:', error.message)
    throw error
  }
}

async function provisionLiquidity(
  liquidity: LiquidityServiceClient,
  network: { protocol: number; id: string },
  assetId: string,
  serverAmount: string,
  leaseDays: number,
  clientRequestId: string,   // your name for this request: persist it, and reuse it on a retry
) {
  // 1. Build the request — same shape for estimate and submit
  const liqReq = new RequestChannelLiquidityRequest()
  liqReq.setNetwork(network)

  const open = new ChannelLiquidityRequestOperation.Open()
  const al = new AssetLiquidity()
  al.setServerAmount({ value: serverAmount })
  al.setClientAmount({ value: '0' })
  open.getAssetLiquidityMap().set(assetId, al)

  const op = new ChannelLiquidityRequestOperation()
  op.setOpen(open)
  liqReq.setOperation(op)
  liqReq.setLeaseDurationSeconds(leaseDays * 24 * 60 * 60)
  liqReq.setPaymentNetwork(network)
  liqReq.setPaymentAssetId(assetId)
  liqReq.setOffchainFeePayment(new OffchainFeePayment())
  liqReq.setClientRequestId(clientRequestId)

  // 2. Estimate first
  const est = await liquidity.estimateRequestChannelLiquidityFee(liqReq, {})
  console.log(`Service fee: ${est.getFee()?.getValue()} ${assetId}`)

  // 3. (Optional) confirm with operator / threshold check
  if (parseFloat(est.getFee()?.getValue() ?? '0') > 0.001) {
    throw new Error('fee exceeds threshold')
  }

  // 4. Subscribe, then submit, then follow the request until it is final
  const requests = await openRequests(liquidity, network)
  try {
    const submitted = (await liquidity.submitChannelLiquidityRequest(liqReq, {})).getRequest()!
    const final = await requests.waitFinal(submitted)
    if (!final.hasCompleted()) {
      throw new Error(`request ${final.getPaymentUuid()} ended without completing`)
    }
    const result = final.getCompleted()!.getChannelLiquidity()   // absent if the report was missed
    return {
      channelId: result?.getChannelId(),
      txid: result?.getTxid(),
    }
  } finally {
    requests.close()
  }
}