import { BufferReader , BufferWriter } from "@node-lightning/bufio" ; import { BitField , Script , Value } from "@node-lightning/core" ; import { OpenChannelFlags } from "../flags/OpenChannelFlags" ; import { MessageType } from "../MessageType" ; import { readTlvs } from "../serialize/readTlvs" ; import { IWireMessage } from "./IWireMessage" ; /**
 * OpenChannelMessage represents the open_channel message defined in
 * BOLT #2 of the Lightning Specification. This message is used to
 * initiate a channel with a connected peer. The channel initiator acts
 * as the funding node for the channel and specifies the amount and
 * parameters to be used in the channel. The remote peer can accept the
 * channel using the accept_channel message.
 */ export class OpenChannelMessage implements IWireMessage { public static type = MessageType . OpenChannel ; param buf public static deserialize ( buf ) { const instance = new OpenChannelMessage ( ) ; const reader = new BufferReader ( buf ) ; reader . readUInt16BE ( ) ; instance . chainHash = reader . readBytes ( 32 ) ; instance . temporaryChannelId = reader . readBytes ( 32 ) ; instance . fundingSatoshis = Value . fromSats ( reader . readUInt64BE ( ) ) ; instance . pushMsat = Value . fromMilliSats ( reader . readUInt64BE ( ) ) ; instance . dustLimitSatoshis = Value . fromSats ( reader . readUInt64BE ( ) ) ; instance . maxHtlcValueInFlightMsat = Value . fromMilliSats ( reader . readUInt64BE ( ) ) ; instance . channelReserveSatoshis = Value . fromSats ( reader . readUInt64BE ( ) ) ; instance . htlcMinimumMsat = Value . fromMilliSats ( reader . readUInt64BE ( ) ) ; instance . feeRatePerKw = Value . fromSats ( reader . readUInt32BE ( ) ) ; instance . toSelfDelay = reader . readUInt16BE ( ) ; instance . maxAcceptedHtlcs = reader . readUInt16BE ( ) ; instance . fundingPubKey = reader . readBytes ( 33 ) ; instance . revocationBasePoint = reader . readBytes ( 33 ) ; instance . paymentBasePoint = reader . readBytes ( 33 ) ; instance . delayedPaymentBasePoint = reader . readBytes ( 33 ) ; instance . htlcBasePoint = reader . readBytes ( 33 ) ; instance . firstPerCommitmentPoint = reader . readBytes ( 33 ) ; instance . channelFlags = new BitField < OpenChannelFlags > ( BigInt ( reader . readUInt8 ( ) ) ) ; readTlvs ( reader , ( type , valueReader ) => { switch ( type ) { case BigInt ( 0 ) : { instance . upfrontShutdownScript = valueReader . readBytes ( ) ; return true ; } default : return false ; } } ) ; return instance ; } /**
     * The type for open_channel message. open_channel = 32
     */ public type = OpenChannelMessage . type ; /**
     * The chain_hash used to identifier the chain that the channel
     * should be opened on. Typically this value is the hash of the
     * genesis block in internal byte order.
     */ public chainHash : Buffer ; /**
     * A unique and temporary identifier used during the channel creation
     * process. This value is a placeholder for the channel_id that is
     * created from the funding transaction that can be used after the
     * funding_created message creates this transaction and the
     * counterparty uses the channel_id in the funding_signed message.
     */ public temporaryChannelId : Buffer ; /**
     * This value is the total value of the channel. It is value in
     * satoshis that will be locked into the 2-2 multisig output of the
     * funding transaction. This value must be less than 2^24 satoshis
     * unless option_large_channel is negotiated by both peers during
     * initialization.
     */ public fundingSatoshis : Value ; /**
     * This is the value in millisatoshi that is unconditionally pushed
     * to the counterparty of the channel. This value must be less than
     * 1000 * funding_satoshis. This value will be applied to the value
     * of the remote nodes commitment transaction output in the initial
     * commitment transaction.
     */ public pushMsat : Value ; /**
     * Indicates the value in satoshis under which outputs should not
     * be created for this node's commitment transaction or HTLC
     * transactions. This setting indicates the reality that small
     * transaction outputs are considered non-standard by the network and
     * will not be propagated.
     */ public dustLimitSatoshis : Value ; /**
     * Indicates the minimum amount that the counterparty is supposed to
     * keep as direct payment. This value must be equal or greater than
     * dust_limit_satoshis and SHOULD be 1% of the total value of the
     * channel. This value ensures that there is always value at stake
     * for a node to lose if it broadcasts an outdated commitment
     * transaction. Initially this value may not be met but as a channel
     * is used and the value is met, the reserve must be maintained.
     */ public channelReserveSatoshis : Value ; /**
     * Indicates the transaction fee in satoshis per 1000-weight that
     * will be used for the commitment transaction and HTLC transactions.
     * This value is set by the funding node and can be adjusted using
     * the update_fee message. This value should be set to a value that
     * the funding node believes will result in the immediate inclusion
     * of the commitment transaction in a block.
     */ public feeRatePerKw : Value ; /**
     * Indicates the number of blocks the remote node must use to delay
     * retrieval of its to_local outputs. This value is used as input
     * to OP_CSV to create a relative timelock on RSMCs used in the
     * to_local output of the commitment transaction and the HTLC
     * transaction outputs. This allows us to use a penalty transaction
     * is there is a breach.
     */ public toSelfDelay : number ; /**
     * The minimum value in millisatoshi of an HTLC that we are willing
     * to accept.
     */ public htlcMinimumMsat : Value ; /**
     * The maximum value in millisatoshi of outstanding HTLCs we will
     * allow. This value allows us to limit our overall exposure to
     * HTLCs.
     */ public maxHtlcValueInFlightMsat : Value ; /**
     * The maximum number of outstanding HTLCs that we will allow. This
     * limits our exposure to a finite amount of HTLCs. This value must
     * be less than 483 as more than this will cause issues with the
     * commitment_signed message.
     */ public maxAcceptedHtlcs : number ; /**
     * The public key used in the 2-of-2 multisig script of the funding
     * transaction output. This value must a  33-byte compressed SEC
     * encoded public key for secp256k1.
     */ public fundingPubKey : Buffer ; /**
     * The revocation basepoint is used to derive a blinded
     * per-commitment revocation public key. Revocation public keys
     * are used in a remote node's version of the commitment
     * transactions and HTLC transactions and allow us the ability to
     * sweep funds if they broadcast a prior state transaction.
     */ public revocationBasePoint : Buffer ; /**
     * The payment basepoint is used to derive a per-commitment payment
     * public key.
     */ public paymentBasePoint : Buffer ; /**
     * The delayed payment basepoint is used to derive a per-commitment
     * payment public key that is sequence delayed. It is used in
     * in our local commitment transaction as well as the outputs of
     * HTLC transactions.
     */ public delayedPaymentBasePoint : Buffer ; /**
     * The HTLC basepoint is used to derive a per-commitment
     * public key used in HTLC outputs of the commitment transaction.
     */ public htlcBasePoint : Buffer ; /**
     * This is the first per-commitment point to be used for the first
     * commitment transaction. This point will be used by the remote
     * node to construct the public keys used when constructing and
     * signing our version of the commitment transaction. This point
     * will eventually be revoked and a we will send a new
     * commitment point.
     */ public firstPerCommitmentPoint : Buffer ; /**
     * Flags are used to indicate channel features. Currently only the
     * least-significant bit is defined which enables public
     * announcement of the channel once the channel becomes live.
     */ public channelFlags : BitField < OpenChannelFlags > ; /**
     * Gets or sets whether the channel will be publicly announced once
     * the channel becomes live.
     */ public get announceChannel ( ) : boolean { return this . channelFlags . isSet ( OpenChannelFlags . AnnounceChannel ) ; } public set announceChannel ( val ) { if ( val ) { this . channelFlags . set ( OpenChannelFlags . AnnounceChannel ) ; } else { this . channelFlags . unset ( OpenChannelFlags . AnnounceChannel ) ; } } /**
     * When option_upfront_shutdown_script is negotiated during init
     * message exchange, this property will commit to using the provided
     * scriptPubKey during a mutual close. This value will be used
     * instead of the scriptPubKey provided during shutdown which
     * ensures that this scriptPubKey is used on close even if our node
     * is compromised.
     */ public upfrontShutdownScript : Buffer ; /**
     * Constructs a new OpenChannelMessage instance
     */ constructor ( ) { this . channelFlags = new BitField < OpenChannelFlags > ( ) ; } /**
     * Serializes the open_channel message into a Buffer
     */ public serialize ( ) { const writer = new BufferWriter ( ) ; writer . writeUInt16BE ( this . type ) ; writer . writeBytes ( this . chainHash ) ; writer . writeBytes ( this . temporaryChannelId ) ; writer . writeUInt64BE ( this . fundingSatoshis . sats ) ; writer . writeUInt64BE ( this . pushMsat . msats ) ; writer . writeUInt64BE ( this . dustLimitSatoshis . sats ) ; writer . writeUInt64BE ( this . maxHtlcValueInFlightMsat . msats ) ; writer . writeUInt64BE ( this . channelReserveSatoshis . sats ) ; writer . writeUInt64BE ( this . htlcMinimumMsat . msats ) ; writer . writeUInt32BE ( Number ( this . feeRatePerKw . sats ) ) ; writer . writeUInt16BE ( this . toSelfDelay ) ; writer . writeUInt16BE ( this . maxAcceptedHtlcs ) ; writer . writeBytes ( this . fundingPubKey ) ; writer . writeBytes ( this . revocationBasePoint ) ; writer . writeBytes ( this . paymentBasePoint ) ; writer . writeBytes ( this . delayedPaymentBasePoint ) ; writer . writeBytes ( this . htlcBasePoint ) ; writer . writeBytes ( this . firstPerCommitmentPoint ) ; writer . writeUInt8 ( this . announceChannel ? 0x01 : 0x00 ) ; if ( this . upfrontShutdownScript ) { writer . writeBigSize ( 0 ) ; writer . writeBigSize ( this . upfrontShutdownScript . length ) ; writer . writeBytes ( this . upfrontShutdownScript ) ; } return writer . toBuffer ( ) ; } }