tapchannelrpc

type AddInvoiceRequest struct {

	// The asset ID to use for the invoice.
	AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	// The asset amount to receive.
	AssetAmount uint64 `protobuf:"varint,2,opt,name=asset_amount,json=assetAmount,proto3" json:"asset_amount,omitempty"`
	// The node identity public key of the peer to ask for a quote for receiving
	// assets and converting them from satoshis. This must be specified if
	// there are multiple channels with the given asset ID.
	PeerPubkey []byte `protobuf:"bytes,3,opt,name=peer_pubkey,json=peerPubkey,proto3" json:"peer_pubkey,omitempty"`
	// The full lnd invoice request to send. All fields (except for the value
	// and the route hints) behave the same way as they do for lnd's
	// lnrpc.AddInvoice RPC method (see the API docs at
	// https://lightning.engineering/api-docs/api/lnd/lightning/add-invoice
	// for more details). The value/value_msat fields will be overwritten by the
	// satoshi (or milli-satoshi) equivalent of the asset amount, after
	// negotiating a quote with a peer that supports the given asset ID.
	InvoiceRequest *lnrpc.Invoice `protobuf:"bytes,4,opt,name=invoice_request,json=invoiceRequest,proto3" json:"invoice_request,omitempty"`
	// If set, then this will make the invoice created a hodl invoice, which
	// won't be settled automatically. Instead, users will need to use the
	// invoicesrpc.SettleInvoice call to manually settle the invoice.
	HodlInvoice *HodlInvoice `protobuf:"bytes,5,opt,name=hodl_invoice,json=hodlInvoice,proto3" json:"hodl_invoice,omitempty"`
	// contains filtered or unexported fields
}

type AddInvoiceResponse struct {

	// The quote for the purchase of assets that was accepted by the peer.
	AcceptedBuyQuote *rfqrpc.PeerAcceptedBuyQuote `protobuf:"bytes,1,opt,name=accepted_buy_quote,json=acceptedBuyQuote,proto3" json:"accepted_buy_quote,omitempty"`
	// The result of the invoice creation.
	InvoiceResult *lnrpc.AddInvoiceResponse `protobuf:"bytes,2,opt,name=invoice_result,json=invoiceResult,proto3" json:"invoice_result,omitempty"`
	// contains filtered or unexported fields
}

type AssetPayReq struct {

	// The asset ID that will be used to resolve the invoice's satoshi amount.
	AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	// The normal LN invoice that whose amount will be mapped to units of the
	// asset ID.
	PayReqString string `protobuf:"bytes,2,opt,name=pay_req_string,json=payReqString,proto3" json:"pay_req_string,omitempty"`
	// contains filtered or unexported fields
}

type AssetPayReqResponse struct {

	// The invoice amount, expressed in asset units.
	AssetAmount uint64 `protobuf:"varint,1,opt,name=asset_amount,json=assetAmount,proto3" json:"asset_amount,omitempty"`
	// The decimal display corresponding to the asset_id.
	DecimalDisplay *taprpc.DecimalDisplay `protobuf:"bytes,2,opt,name=decimal_display,json=decimalDisplay,proto3" json:"decimal_display,omitempty"`
	// The group the asset ID belong to, if applicable.
	AssetGroup *taprpc.AssetGroup `protobuf:"bytes,3,opt,name=asset_group,json=assetGroup,proto3" json:"asset_group,omitempty"`
	// Genesis information for the asset ID which includes the meta hash, and
	// asset ID.
	GenesisInfo *taprpc.GenesisInfo `protobuf:"bytes,4,opt,name=genesis_info,json=genesisInfo,proto3" json:"genesis_info,omitempty"`
	// The normal decoded payment request.
	PayReq *lnrpc.PayReq `protobuf:"bytes,5,opt,name=pay_req,json=payReq,proto3" json:"pay_req,omitempty"`
	// contains filtered or unexported fields
}

type EncodeCustomRecordsRequest struct {

	// Types that are assignable to Input:
	//
	//	*EncodeCustomRecordsRequest_RouterSendPayment
	Input isEncodeCustomRecordsRequest_Input `protobuf_oneof:"input"`
	// contains filtered or unexported fields
}

type EncodeCustomRecordsRequest_RouterSendPayment struct {
	RouterSendPayment *RouterSendPaymentData `protobuf:"bytes,1,opt,name=router_send_payment,json=routerSendPayment,proto3,oneof"`
}

type EncodeCustomRecordsResponse struct {

	// The encoded custom records in TLV format.
	CustomRecords map[uint64][]byte `` /* 189-byte string literal not displayed */
	// contains filtered or unexported fields
}

type FundChannelRequest struct {

	// The asset amount to fund the channel with. The BTC amount is fixed and
	// cannot be customized (for now).
	AssetAmount uint64 `protobuf:"varint,1,opt,name=asset_amount,json=assetAmount,proto3" json:"asset_amount,omitempty"`
	// The asset ID to use for the channel funding.
	AssetId []byte `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	// The public key of the peer to open the channel with. Must already be
	// connected to this peer.
	PeerPubkey []byte `protobuf:"bytes,3,opt,name=peer_pubkey,json=peerPubkey,proto3" json:"peer_pubkey,omitempty"`
	// The channel funding fee rate in sat/vByte.
	FeeRateSatPerVbyte uint32 `protobuf:"varint,4,opt,name=fee_rate_sat_per_vbyte,json=feeRateSatPerVbyte,proto3" json:"fee_rate_sat_per_vbyte,omitempty"`
	// The number of satoshis to give the remote side as part of the initial
	// commitment state. This is equivalent to first opening a channel and then
	// sending the remote party funds, but all done in one step. Therefore, this
	// is equivalent to a donation to the remote party, unless they reimburse
	// the funds in another way (outside the protocol).
	PushSat int64 `protobuf:"varint,5,opt,name=push_sat,json=pushSat,proto3" json:"push_sat,omitempty"`
	// contains filtered or unexported fields
}

type FundChannelResponse struct {

	// The channel funding transaction ID.
	Txid string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`
	// The index of the channel funding output in the funding transaction.
	OutputIndex int32 `protobuf:"varint,2,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"`
	// contains filtered or unexported fields
}

type HodlInvoice struct {
	PaymentHash []byte `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"`
	// contains filtered or unexported fields
}

type RouterSendPaymentData struct {

	// The string encoded asset ID to amount mapping. Instructs the router to
	// use these assets in the given amounts for the payment. Can be empty for
	// a payment of an invoice, if the RFQ ID is set instead.
	AssetAmounts map[string]uint64 `` /* 186-byte string literal not displayed */
	// The RFQ ID to use for the payment. Can be empty for a direct keysend
	// payment that doesn't involve any conversion (and thus no RFQ).
	RfqId []byte `protobuf:"bytes,2,opt,name=rfq_id,json=rfqId,proto3" json:"rfq_id,omitempty"`
	// contains filtered or unexported fields
}

type SendPaymentRequest struct {

	// The asset ID to use for the payment. This must be set for both invoice
	// and keysend payments, unless RFQ negotiation was already done beforehand
	// and payment_request.first_hop_custom_records already contains valid RFQ
	// data.
	AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	// The asset amount to send in a keysend payment. This amount is ignored for
	// invoice payments as the asset amount is negotiated through RFQ with the
	// peer, depending on the invoice amount. This can also be left unset if RFQ
	// negotiation was already done beforehand and
	// payment_request.first_hop_custom_records already contains valid RFQ data.
	AssetAmount uint64 `protobuf:"varint,2,opt,name=asset_amount,json=assetAmount,proto3" json:"asset_amount,omitempty"`
	// The node identity public key of the peer to ask for a quote for sending
	// out the assets and converting them to satoshis. This must be specified if
	// there are multiple channels with the given asset ID.
	PeerPubkey []byte `protobuf:"bytes,3,opt,name=peer_pubkey,json=peerPubkey,proto3" json:"peer_pubkey,omitempty"`
	// The full lnd payment request to send. All fields behave the same way as
	// they do for lnd's routerrpc.SendPaymentV2 RPC method (see the API docs
	// at https://lightning.engineering/api-docs/api/lnd/router/send-payment-v2
	// for more details).
	// To send a keysend payment, the payment_request.dest_custom_records must
	// contain a valid keysend record (key 5482373484 and a 32-byte preimage
	// that corresponds to the payment hash).
	PaymentRequest *routerrpc.SendPaymentRequest `protobuf:"bytes,4,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"`
	// The rfq id to use for this payment. If the user sets this value then the
	// payment will immediately be dispatched, skipping the rfq negotiation
	// phase, and using the following rfq id instead.
	RfqId []byte `protobuf:"bytes,5,opt,name=rfq_id,json=rfqId,proto3" json:"rfq_id,omitempty"`
	// If a small invoice should be paid that is below the amount that always
	// needs to be sent out to carry a single asset unit, then by default the
	// payment is rejected. If this flag is set, then the payment will be
	// allowed to proceed, even if it is uneconomical, meaning that more sats
	// are sent out to the network than the invoice amount plus routing fees
	// require to be paid.
	AllowOverpay bool `protobuf:"varint,6,opt,name=allow_overpay,json=allowOverpay,proto3" json:"allow_overpay,omitempty"`
	// contains filtered or unexported fields
}

type SendPaymentResponse struct {

	// Types that are assignable to Result:
	//
	//	*SendPaymentResponse_AcceptedSellOrder
	//	*SendPaymentResponse_PaymentResult
	Result isSendPaymentResponse_Result `protobuf_oneof:"result"`
	// contains filtered or unexported fields
}

type SendPaymentResponse_AcceptedSellOrder struct {
	// In case channel assets need to be swapped to another asset, an asset
	// sell order is negotiated with the channel peer. The result will be
	// the first message in the response stream. If no swap is needed, the
	// payment results will be streamed directly.
	AcceptedSellOrder *rfqrpc.PeerAcceptedSellQuote `protobuf:"bytes,1,opt,name=accepted_sell_order,json=acceptedSellOrder,proto3,oneof"`
}

type SendPaymentResponse_PaymentResult struct {
	// The payment result of a single payment attempt. Multiple attempts may
	// be returned per payment request until either the payment succeeds or
	// the payment times out.
	PaymentResult *lnrpc.Payment `protobuf:"bytes,2,opt,name=payment_result,json=paymentResult,proto3,oneof"`
}

type TaprootAssetChannelsClient interface {
	// FundChannel initiates the channel funding negotiation with a peer for the
	// creation of a channel that contains a specified amount of a given asset.
	FundChannel(ctx context.Context, in *FundChannelRequest, opts ...grpc.CallOption) (*FundChannelResponse, error)
	// EncodeCustomRecords allows RPC users to encode Taproot Asset channel related
	// data into the TLV format that is used in the custom records of the lnd
	// payment or other channel related RPCs. This RPC is completely stateless and
	// does not perform any checks on the data provided, other than pure format
	// validation.
	EncodeCustomRecords(ctx context.Context, in *EncodeCustomRecordsRequest, opts ...grpc.CallOption) (*EncodeCustomRecordsResponse, error)
	// SendPayment is a wrapper around lnd's routerrpc.SendPaymentV2 RPC method
	// with asset specific parameters. It allows RPC users to send asset keysend
	// payments (direct payments) or payments to an invoice with a specified asset
	// amount.
	SendPayment(ctx context.Context, in *SendPaymentRequest, opts ...grpc.CallOption) (TaprootAssetChannels_SendPaymentClient, error)
	// AddInvoice is a wrapper around lnd's lnrpc.AddInvoice method with asset
	// specific parameters. It allows RPC users to create invoices that correspond
	// to the specified asset amount.
	AddInvoice(ctx context.Context, in *AddInvoiceRequest, opts ...grpc.CallOption) (*AddInvoiceResponse, error)
	// DecodeAssetPayReq is similar to lnd's lnrpc.DecodePayReq, but it accepts an
	// asset ID and returns the invoice amount expressed in asset units along side
	// the normal information.
	DecodeAssetPayReq(ctx context.Context, in *AssetPayReq, opts ...grpc.CallOption) (*AssetPayReqResponse, error)
}

type TaprootAssetChannelsServer interface {
	// FundChannel initiates the channel funding negotiation with a peer for the
	// creation of a channel that contains a specified amount of a given asset.
	FundChannel(context.Context, *FundChannelRequest) (*FundChannelResponse, error)
	// EncodeCustomRecords allows RPC users to encode Taproot Asset channel related
	// data into the TLV format that is used in the custom records of the lnd
	// payment or other channel related RPCs. This RPC is completely stateless and
	// does not perform any checks on the data provided, other than pure format
	// validation.
	EncodeCustomRecords(context.Context, *EncodeCustomRecordsRequest) (*EncodeCustomRecordsResponse, error)
	// SendPayment is a wrapper around lnd's routerrpc.SendPaymentV2 RPC method
	// with asset specific parameters. It allows RPC users to send asset keysend
	// payments (direct payments) or payments to an invoice with a specified asset
	// amount.
	SendPayment(*SendPaymentRequest, TaprootAssetChannels_SendPaymentServer) error
	// AddInvoice is a wrapper around lnd's lnrpc.AddInvoice method with asset
	// specific parameters. It allows RPC users to create invoices that correspond
	// to the specified asset amount.
	AddInvoice(context.Context, *AddInvoiceRequest) (*AddInvoiceResponse, error)
	// DecodeAssetPayReq is similar to lnd's lnrpc.DecodePayReq, but it accepts an
	// asset ID and returns the invoice amount expressed in asset units along side
	// the normal information.
	DecodeAssetPayReq(context.Context, *AssetPayReq) (*AssetPayReqResponse, error)
	// contains filtered or unexported methods
}

type TaprootAssetChannels_SendPaymentClient interface {
	Recv() (*SendPaymentResponse, error)
	grpc.ClientStream
}

type TaprootAssetChannels_SendPaymentServer interface {
	Send(*SendPaymentResponse) error
	grpc.ServerStream
}

type UnimplementedTaprootAssetChannelsServer struct {
}

type UnsafeTaprootAssetChannelsServer interface {
	// contains filtered or unexported methods
}