ln-sync v6.4.0

LN Sync

Methods for synchronizing metadata about Lightning Network nodes, channels, and payments.

Methods

acceptsChannelOpen

Confirm that a peer will accept a channel open

{
  capacity: <Channel Capacity Tokens Number>
  [cooperative_close_address]: <Restrict Coop Close To Address String>
  [give_tokens]: <Tokens to Gift To Partner Number> // Defaults to zero
  [is_private]: <Channel is Private Bool> // Defaults to false
  lnd: <Authenticated LND API Object>
  [min_htlc_mtokens]: <Minimum HTLC Millitokens String>
  [partner_csv_delay]: <Peer Output CSV Delay Number>
  partner_public_key: <Public Key Hex String>
}

@returns via cbk or Promise
{
  is_accepted: <Channel Proposal Is Accepted Bool>
}

askForFeeRate

Ask to get a chain fee rate

{
  ask: <Inquirer Ask Function>
  lnd: <Authenticated LND API Object>
}

@returns via cbk or Promise
{
  tokens_per_vbyte: <Chain Fee Tokens Per VByte Number>
}

assembleUnsignedPsbt

Assemble an unsigned PSBT with funding from multiple parties

{
  capacity: <Channel Capacity Tokens Number>
  proposed: [{
    [change]: <Change Output Hex String>
    [funding]: [<Funding Output Hex String>]
    utxos: [{
      [non_witness_utxo]: <Spending Transaction Hex String>
      transaction_id: <Transaction Id Hex String>
      transaction_vout: <Transaction Output Index Number>
      witness_utxo: {
        script_pub: <Witness Output Script Hex String>
        tokens: <Tokens Number>
      }
    }]
  }]
  rate: <Fee Rate Number>
}

@returns via cbk or Promise
{
  psbt: <Unsigned Funding Transaction PSBT Hex String>
}

broadcastTransaction

Broadcast a chain transaction until it gets confirmed in a block

{
  [description]: <Transaction Description String>
  lnd: <Authenticated LND API Object>
  logger: <Winston Logger Object>
  transaction: <Transaction String>
}

@returns via cbk or Promise
{
  transaction_confirmed_in_block: <Block Height Number>
}

connectPeer

Connect a peer

{
  id: <Node Public Key Hex String>
  lnd: <Authenticated LND API Object>
  [sockets]: [<Host Network Address And Optional Port String>]
}

@returns via cbk or Promise

findConfirmedOutput

Find a confirmed on-chain output

{
  lnd: <Authenticated LND API Object>
  [min_confirmations]: <Minimum Confirmations Count Number>
  output_script: <Chain Output Script Hex String>
  start_height: <Start Chain Height Number>
  timeout_ms: <Timeout Milliseconds Number>
  tokens: <Tokens Sent To Script Number>
}

@returns via cbk or Promise
{
  confirmation_height: <Transaction Confirmed At Height Number>
  is_coinbase: <Transaction is Coinbase Transaction Bool>
  transaction_id: <Transaction Id Hex String>
  transaction_vout: <Transaction Output Index Number>
}

findKey

Find a public key given a query

{
  [channels]: [{
    partner_public_key: <Partner Public Key Hex String>
  }]
  lnd: <Authenticated LND API Object>
  [query]: <Query String>
}

@returns via cbk or Promise
{
  [public_key]: <Public Key Hex String>
}

formatTokens

Format tokens for display

{
  is_monochrome: <Avoid Applying Colors Bool>
  tokens: <Tokens Number>
}

@returns
{
  display: <Display Formatted Tokens String>
}

getAllInvoices

Get all invoices

{
  [confirmed_after]: <Confirmed At or After ISO 8601 Date String>
  [created_after]: <Confirmed At or After ISO 8601 Date String>
  lnd: <Authenticated LND API Object>
}

@returns via cbk or Promise
{
  invoices: [{
    [chain_address]: <Fallback Chain Address String>
    cltv_delta: <Final CLTV Delta Number>
    [confirmed_at]: <Settled at ISO 8601 Date String>
    created_at: <ISO 8601 Date String>
    description: <Description String>
    [description_hash]: <Description Hash Hex String>
    expires_at: <ISO 8601 Date String>
    features: [{
      bit: <BOLT 09 Feature Bit Number>
      is_known: <Feature is Known Bool>
      is_required: <Feature Support is Required To Pay Bool>
      type: <Feature Type String>
    }]
    id: <Payment Hash String>
    [is_canceled]: <Invoice is Canceled Bool>
    is_confirmed: <Invoice is Confirmed Bool>
    [is_held]: <HTLC is Held Bool>
    is_private: <Invoice is Private Bool>
    [is_push]: <Invoice is Push Payment Bool>
    payments: [{
      [confirmed_at]: <Payment Settled At ISO 8601 Date String>
      created_at: <Payment Held Since ISO 860 Date String>
      created_height: <Payment Held Since Block Height Number>
      in_channel: <Incoming Payment Through Channel Id String>
      is_canceled: <Payment is Canceled Bool>
      is_confirmed: <Payment is Confirmed Bool>
      is_held: <Payment is Held Bool>
      messages: [{
        type: <Message Type Number String>
        value: <Raw Value Hex String>
      }]
      mtokens: <Incoming Payment Millitokens String>
      [pending_index]: <Pending Payment Channel HTLC Index Number>
      tokens: <Payment Tokens Number>
      [total_mtokens]: <Total Millitokens String>
    }]
    received: <Received Tokens Number>
    received_mtokens: <Received Millitokens String>
    [request]: <Bolt 11 Invoice String>
    secret: <Secret Preimage Hex String>
    tokens: <Tokens Number>
  }]
}

getFundedTransaction

Get a funded transaction

{
  ask: <Inquirer Ask Function>
  [chain_fee_tokens_per_vbyte]: <Internal Funding Uses Tokens/Vbyte Number>
  [is_external]: <Transaction Uses External Funds Bool>
  lnd: Authenticated LND API Object>
  logger: <Winston Logger Object>
  outputs: [{
    address: <Chain Address String>
    tokens: <Tokens To Send To Output Number>
  }]
}

@returns via cbk or Promise
{
  id: <Transaction Id Hex String>
  [inputs]: [{
    [lock_expires_at]: <UTXO Lock Expires At ISO 8601 Date String>
    [lock_id]: <UTXO Lock Id Hex String>
    transaction_id: <Transaction Hex Id String>
    transaction_vout: <Transaction Output Index Number>
  }]
  [psbt]: <Transaction As Finalized PSBT Hex String>
  transaction: <Raw Transaction Hex String>
}

getLiquidity

Get the channel available liquidity

A request function is required when min_node_score is specified

{
  [is_outbound]: <Return Outbound Liquidity Bool>
  [is_top]: <Return Top Liquidity Bool>
  lnd: <Authenticated LND API Object>
  [min_node_score]: <Minimum Node Score Number>
  [max_fee_rate]: <Max Inbound Fee Rate Parts Per Million Number>
  [request]: <Request Function>
  [with]: [<Liquidity With Specific Node Public Key Hex String>]
}

@returns via cbk
{
  tokens: [<Liquidity Tokens Number>]
}

getNetwork

Get network name for lnd

{
  lnd: <Authenticated LND API Object>
}

@returns via cbk or Promise
{
  [bitcoinjs]: <Bitcoin JS Network Name String>
  network: <Network Name String>
}

getNodeAlias

Get the alias of a node, ignoring errors

{
  id: <Node Identity Public Key Hex String>
  lnd: <Authenticated LND API Object>
}

@returns via cbk or Promise
{
  alias: <Node Alias String>
  id: <Node Identity Public Key Hex String>
}

getNodeFunds

Get a detailed balance that categorizes balance of tokens on the node

{
  [is_confirmed]: <Only Consider Confirmed Transactions Bool>
  lnd: <Authenticated LND API Object>
}

@returns via cbk or Promise
{
  [closing_balance]: <Total Coins Closing Tokens Number>
  [conflicted_pending]: <Conflicted Transaction Tokens Number>
  [invalid_pending]: <Invalid Pending Tokens Tokens Number>
  [offchain_balance]: <Channel Tokens Balance Tokens Number>
  [offchain_pending]: <Pending Channel Tokens Balance Tokens Number>
  [onchain_confirmed]: <Confirmed On Chain Balance Tokens Number>
  [onchain_pending]: <Pending Chain Tokens Balance Tokens Number>
  [onchain_vbytes]: <UTXO Footprint Virtual Bytes Number>
  [utxos_count]: <Total UTXOs Count Number>
}

getMaxFundAmount

Find the max amount that can be used for funding outputs given inputs

{
  addresses: [<Send to Address String>]
  fee_tokens_per_vbyte: <Funding Fee Tokens Per VByte Number>
  inputs: [{
    tokens: <Input Tokens Number>
    transaction_id: <UTXO Transaction Id Hex String>
    transaction_vout: <UTXO Transaction Output Index Number>
  }]
  lnd: <Authenticated LND API Object>
}

@returns via cbk or Promise
{
  fee_tokens_per_vbyte: <Effective Final Fee Tokens Per VByte Number>
  max_tokens: <Maximum Spendable Tokens Number>
}

getPayments

Get payments

{
  [after]: <Get Only Payments Create At Or After ISO 8601 Date String>
  lnd: <Authenticated LND API Object>
}

@returns via cbk or Promise
{
  payments: [{
    attempts: [{
      [failure]: {
        code: <Error Type Code Number>
        [details]: {
          [channel]: <Standard Format Channel Id String>
          [height]: <Error Associated Block Height Number>
          [index]: <Failed Hop Index Number>
          [mtokens]: <Error Millitokens String>
          [policy]: {
            base_fee_mtokens: <Base Fee Millitokens String>
            cltv_delta: <Locktime Delta Number>
            fee_rate: <Fees Charged in Millitokens Per Million Number>
            [is_disabled]: <Channel is Disabled Bool>
            max_htlc_mtokens: <Maximum HLTC Millitokens Value String>
            min_htlc_mtokens: <Minimum HTLC Millitokens Value String>
            updated_at: <Updated At ISO 8601 Date String>
          }
          [timeout_height]: <Error CLTV Timeout Height Number>
          [update]: {
            chain: <Chain Id Hex String>
            channel_flags: <Channel Flags Number>
            extra_opaque_data: <Extra Opaque Data Hex String>
            message_flags: <Message Flags Number>
            signature: <Channel Update Signature Hex String>
          }
        }
        message: <Error Message String>
      }
      [index]: <Payment Add Index Number>
      is_confirmed: <Payment Attempt Succeeded Bool>
      is_failed: <Payment Attempt Failed Bool>
      is_pending: <Payment Attempt is Waiting For Resolution Bool>
      route: {
        fee: <Route Fee Tokens Number>
        fee_mtokens: <Route Fee Millitokens String>
        hops: [{
          channel: <Standard Format Channel Id String>
          channel_capacity: <Channel Capacity Tokens Number>
          fee: <Fee Number>
          fee_mtokens: <Fee Millitokens String>
          forward: <Forward Tokens Number>
          forward_mtokens: <Forward Millitokens String>
          [public_key]: <Forward Edge Public Key Hex String>
          [timeout]: <Timeout Block Height Number>
        }]
        mtokens: <Total Fee-Inclusive Millitokens String>
        [payment]: <Payment Identifier Hex String>
        timeout: <Timeout Block Height Number>
        tokens: <Total Fee-Inclusive Tokens Number>
        [total_mtokens]: <Total Millitokens String>
      }
    }]
    created_at: <Payment at ISO-8601 Date String>
    destination: <Destination Node Public Key Hex String>
    fee: <Paid Routing Fee Rounded Down Tokens Number>
    fee_mtokens: <Paid Routing Fee in Millitokens String>
    hops: [<First Route Hop Public Key Hex String>]
    id: <Payment Preimage Hash String>
    [index]: <Payment Add Index Number>
    is_confirmed: <Payment is Confirmed Bool>
    is_outgoing: <Transaction Is Outgoing Bool>
    mtokens: <Millitokens Sent to Destination String>
    [request]: <BOLT 11 Payment Request String>
    safe_fee: <Payment Forwarding Fee Rounded Up Tokens Number>
    safe_tokens: <Payment Tokens Rounded Up Number>
    secret: <Payment Preimage Hex String>
    tokens: <Rounded Down Tokens Sent to Destination Number>
  }]
}

getPeerLiquidity

Get the rundown on liquidity with a specific peer

{
  lnd: <Authenticated LND API Object>
  public_key: <Peer Public Key Hex String>
  [settled]: <Known Settled Payment Id String>
}

@returns via cbk or Promise
{
  alias: <Alias String>
  inbound: <Inbound Liquidity Tokens Number>
  inbound_pending: <Pending Inbound Liquidity Tokens Number>
  outbound: <Outbound Liquidity Tokens Number>
  outbound_pending: <Pending Outbound Liquidity Tokens Number>
}

getRebalancePayments

Get payments that were rebalances

{
  after: <Rebalance Payments After ISO 8601 Date String>
  lnds: [<Authenticated LND API Object>]
}

@returns via cbk or Promise
{
  payments: [{
    attempts: [{
      [failure]: {
        code: <Error Type Code Number>
        [details]: {
          [channel]: <Standard Format Channel Id String>
          [height]: <Error Associated Block Height Number>
          [index]: <Failed Hop Index Number>
          [mtokens]: <Error Millitokens String>
          [policy]: {
            base_fee_mtokens: <Base Fee Millitokens String>
            cltv_delta: <Locktime Delta Number>
            fee_rate: <Fees Charged in Millitokens Per Million Number>
            [is_disabled]: <Channel is Disabled Bool>
            max_htlc_mtokens: <Maximum HLTC Millitokens Value String>
            min_htlc_mtokens: <Minimum HTLC Millitokens Value String>
            updated_at: <Updated At ISO 8601 Date String>
          }
          [timeout_height]: <Error CLTV Timeout Height Number>
          [update]: {
            chain: <Chain Id Hex String>
            channel_flags: <Channel Flags Number>
            extra_opaque_data: <Extra Opaque Data Hex String>
            message_flags: <Message Flags Number>
            signature: <Channel Update Signature Hex String>
          }
        }
        message: <Error Message String>
      }
      [index]: <Payment Add Index Number>
      [confirmed_at]: <Payment Confirmed At ISO 8601 Date String>
      is_confirmed: <Payment Attempt Succeeded Bool>
      is_failed: <Payment Attempt Failed Bool>
      is_pending: <Payment Attempt is Waiting For Resolution Bool>
      route: {
        fee: <Route Fee Tokens Number>
        fee_mtokens: <Route Fee Millitokens String>
        hops: [{
          channel: <Standard Format Channel Id String>
          channel_capacity: <Channel Capacity Tokens Number>
          fee: <Fee Number>
          fee_mtokens: <Fee Millitokens String>
          forward: <Forward Tokens Number>
          forward_mtokens: <Forward Millitokens String>
          [public_key]: <Forward Edge Public Key Hex String>
          [timeout]: <Timeout Block Height Number>
        }]
        mtokens: <Total Fee-Inclusive Millitokens String>
        [payment]: <Payment Identifier Hex String>
        timeout: <Timeout Block Height Number>
        tokens: <Total Fee-Inclusive Tokens Number>
        [total_mtokens]: <Total Millitokens String>
      }
    }]
    confirmed_at: <Payment Confirmed At ISO 8601 Date String>
    created_at: <Payment at ISO-8601 Date String>
    destination: <Destination Node Public Key Hex String>
    fee: <Paid Routing Fee Rounded Down Tokens Number>
    fee_mtokens: <Paid Routing Fee in Millitokens String>
    hops: [<First Route Hop Public Key Hex String>]
    id: <Payment Preimage Hash String>
    [index]: <Payment Add Index Number>
    is_confirmed: <Payment is Confirmed Bool>
    is_outgoing: <Transaction Is Outgoing Bool>
    mtokens: <Millitokens Sent to Destination String>
    [request]: <BOLT 11 Payment Request String>
    safe_fee: <Payment Forwarding Fee Rounded Up Tokens Number>
    safe_tokens: <Payment Tokens Rounded Up Number>
    secret: <Payment Preimage Hex String>
    tokens: <Rounded Down Tokens Sent to Destination Number>
  }]
}

getScoredNodes

Get scored nodes

{
  network: <Network Name String>
  request: <Request Function>
}

@returns via cbk or Promise
{
  nodes: [{
    public_key: <Public Key Hex String>
    score: <Forwarding Quality Score Out Of One Hundred Million Number>
  }]
}

getTransactionRecord

Get LND internal record associated with a transaction id

{
  [chain_transactions]: [{
    [block_id]: <Block Hash String>
    [confirmation_count]: <Confirmation Count Number>
    [confirmation_height]: <Confirmation Block Height Number>
    created_at: <Created ISO 8601 Date String>
    [description]: <Transaction Label String>
    [fee]: <Fees Paid Tokens Number>
    id: <Transaction Id String>
    is_confirmed: <Is Confirmed Bool>
    is_outgoing: <Transaction Outbound Bool>
    output_addresses: [<Address String>]
    tokens: <Tokens Including Fee Number>
    [transaction]: <Raw Transaction Hex String>
  }]
  [channels]: [{
    capacity: <Capacity Tokens Numberr>
    id: <Standard Format Short Channel Id Hex String>
    partner_public_key: <Peer Public Key Hex String>
    transaction_id: <Channel Transaction Id Hex String>
  }]
  [closed_channels]: [{
    capacity: <Closed Channel Capacity Tokens Number>
    [close_balance_spent_by]: <Channel Balance Output Spent By Tx Id String>
    [close_balance_vout]: <Channel Balance Close Tx Output Index Number>
    [close_confirm_height]: <Channel Close Confirmation Height Number>
    close_payments: [{
      is_outgoing: <Payment Is Outgoing Bool>
      is_paid: <Payment Is Claimed With Preimage Bool>
      is_pending: <Payment Resolution Is Pending Bool>
      is_refunded: <Payment Timed Out And Went Back To Payer Bool>
      [spent_by]: <Close Transaction Spent By Transaction Id Hex String>
      tokens: <Associated Tokens Number>
      transaction_id: <Transaction Id Hex String>
      transaction_vout: <Transaction Output Index Number>
    }]
    [close_transaction_id]: <Closing Transaction Id Hex String>
    final_local_balance: <Channel Close Final Local Balance Tokens Number>
    final_time_locked_balance: <Closed Channel Timelocked Tokens Number>
    [id]: <Closed Standard Format Channel Id String>
    is_breach_close: <Is Breach Close Bool>
    is_cooperative_close: <Is Cooperative Close Bool>
    is_funding_cancel: <Is Funding Cancelled Close Bool>
    is_local_force_close: <Is Local Force Close Bool>
    [is_partner_closed]: <Channel Was Closed By Channel Peer Bool>
    [is_partner_initiated]: <Channel Was Initiated By Channel Peer Bool>
    is_remote_force_close: <Is Remote Force Close Bool>
    partner_public_key: <Partner Public Key Hex String>
    transaction_id: <Channel Funding Transaction Id Hex String>
    transaction_vout: <Channel Funding Output Index Number>
  }]
  id: <Transaction Id Hex String>
  lnd: <Authenticated LND API Object>
  [pending_channels]: [{
    [close_transaction_id]: <Channel Closing Transaction Id String>
    is_active: <Channel Is Active Bool>
    is_closing: <Channel Is Closing Bool>
    is_opening: <Channel Is Opening Bool>
    is_partner_initiated: <Channel Partner Initiated Channel Bool>
    local_balance: <Channel Local Tokens Balance Number>
    local_reserve: <Channel Local Reserved Tokens Number>
    partner_public_key: <Channel Peer Public Key String>
    [pending_balance]: <Tokens Pending Recovery Number>
    [pending_payments]: [{
      is_incoming: <Payment Is Incoming Bool>
      timelock_height: <Payment Timelocked Until Height Number>
      tokens: <Payment Tokens Number>
      transaction_id: <Payment Transaction Id String>
      transaction_vout: <Payment Transaction Vout Number>
    }]
    received: <Tokens Received Number>
    [recovered_tokens]: <Tokens Recovered From Close Number>
    remote_balance: <Remote Tokens Balance Number>
    remote_reserve: <Channel Remote Reserved Tokens Number>
    sent: <Send Tokens Number>
    [timelock_expiration]: <Pending Tokens Block Height Timelock Number>
    [transaction_fee]: <Funding Transaction Fee Tokens Number>
    transaction_id: <Channel Funding Transaction Id String>
    transaction_vout: <Channel Funding Transaction Vout Number>
    [transaction_weight]: <Funding Transaction Weight Number>
  }]
}

@returns via cbk or Promise
{
  [chain_fee]: <Paid Transaction Fee Tokens Number>
  [received]: <Received Tokens Number>
  related_channels: [{
    action: <Channel Action String>
    [balance]: <Channel Balance Tokens Number>
    [capacity]: <Channel Capacity Value Number>
    [channel]: <Channel Standard Format Id String>
    [close_tx]: <Channel Closing Transaction Id Hex String>
    [open_tx]: <Channel Opening Transaction id Hex String>
    [timelock]: <Channel Funds Timelocked Until Height Number>
    with: <Channel Peer Public Key Hex String>
  }]
  [sent]: <Sent Tokens Number>
  [sent_to]: [<Sent to Address String>]
  [tx]: <Transaction Id Hex String>
}

getTransitRefund

Make a refund transaction for transit funds

{
  funded_tokens: <Tokens Sent to Transit Address Number>
  lnd: <Authenticated LND API Object>
  network: <Network Name String>
  refund_address: <Refund Coins to On Chain Address String>
  transit_address: <Transit On Chain Bech32 Address String>
  transit_key_index: <Transit Key Index Number>
  transit_public_key: <Transit Public Key Hex String>
  transaction_id: <Transaction Id Hex String>
  transaction_vout: <Transaction Output Index Number>
}

@returns via cbk or Promise
{
  refund: <Fully Signed Refund Transaction Hex String>
}

reserveTransitFunds

Get on-chain funding and a refund

{
  ask: <Ask Function>
  lnd: <Authenticated LND API Object>
  logger: <Winston Logger Object>
  [rate]: <Chain Fee Rate Tokens Per VByte Number>
  tokens: <Fund Tokens Number>
}

@returns via cbk or Promise
{
  address: <Transit Address String>
  id: <Transaction Id Hex String>
  index: <Transit Public Key Index Number>
  [inputs]: [{
    [lock_expires_at]: <UTXO Lock Expires At ISO 8601 Date String>
    [lock_id]: <UTXO Lock Id Hex String>
    transaction_id: <Transaction Hex Id String>
    transaction_vout: <Transaction Output Index Number>
  }]
  key: <Transit Key Public Key Hex String>
  output: <Transit Output Script Hex String>
  [psbt]: <Transaction As Finalized PSBT Hex String>
  refund: <Refund Transaction Hex String>
  script: <Transit Signing Witness Script Hex String>
  transaction: <Raw Transaction Hex String>
  vout: <Funds Reserved At Output Index Number>
}

signAndFundPsbt

Partially sign and fund a PSBT and create a conflicting transaction

Only P2TR and P2WPKH inputs are supported

To allow for funding a channel, a dummy "finalized" PSBT is returned

{
  lnd: <Authenticated Signing LND API Object>
  psbt: <Base Funding With Bare Inputs PSBT Hex String>
  utxos: [{
    bip32_derivations: [{
      fingerprint: <Public Key Fingerprint Hex String>
      [leaf_hashes]: <Taproot Leaf Hash Hex String>
      path: <BIP 32 Child / Hardened Child / Index Derivation Path String>
      public_key: <Public Key Hex String>
    }]
    [non_witness_utxo]: <UTXO Spending Transaction Hex String>
    transaction_id: <Unspent Transaction Id Hex String>
    transaction_vout: <Unspent Transaction Output Index Number>
    witness_utxo: {
      script_pub: <UTXO Output Script Hex String>
      tokens: <UTXO Tokens Value Number>
    }
  }]
}

@returns via cbk or Promise
{
  conflict: <Conflict Transaction Hex String>
  funding: <Funding Dummy PSBT Hex String>
  psbt: <Partially Signed PSBT Hex String>
}

updateChannelFee

Update the fee for an individual channel

{
  [base_fee_mtokens]: <Base Fee Millitokens String>
  [cltv_delta]: <CLTV Delta to Use Number>
  fee_rate: <Fee Rate Number>
  from: <Local Node Public Key Hex String>
  [inbound_rate_discount]: <Source Based PPM Fee Rate Discount Number>
  lnd: <Authenticated LND API Object>
  [max_htlc_mtokens]: <Maximum HTLC Millitokens to Forward String>
  [min_htlc_mtokens]: <Minimum HTLC Millitokens to Forward String>
  transaction_id: <Funding Transaction Id Hex String>
  transaction_vout: <Funding Transaction Output Index Number>
}

@returns via cbk or Promise

waitForConnectedPeer

Wait for a peer to connect

{
  id: <Node Identity Public Key Hex String>
  lnd: <Authenticated LND API Object>
  [timeout]: <Timeout Milliseconds Number>
}

@returns via cbk or Promise

waitForPendingOpen

Wait for an incoming pending open channel matching specific criteria

{
  [capacity]: <Channel Capacity Tokens Number>
  interval: <Check Time Milliseconds Number>
  lnd: <Authenticated LND API Object>
  local_balance: <Starting Local Balance Number>
  partner_public_key: <Peer Public Key Hex String>
  times: <Total Check Times Number>
  transaction_id: <Transaction Id Hex String>
  transaction_vout: <Transaction Output Index Number>
}

@returns via cbk or Promise
{
  transaction_id: <Transaction Id Hex String>
  transaction_vout: <Transaction Output Index Number>
}