Browse Source

loopdb: migrate loop in channel to last hop

A database field was already in place to allow channel selection for
loop in. Unfortunately this field, which contains a short channel id,
isn't easily usable for controlling the loop server payment. Because of
non-strict forwarding, it is only possible to constrain a route to a
specific last hop pubkey.

This commit converts the existing field into a pubkey field.
pull/152/head
Joost Jager 1 year ago
parent
commit
535e964ec9
No known key found for this signature in database GPG Key ID: A61B9D4C393C59C7
12 changed files with 252 additions and 514 deletions
  1. +2
    -2
      client.go
  2. +4
    -3
      interface.go
  3. +7
    -2
      loopd/swapclient_server.go
  4. +13
    -11
      loopdb/loopin.go
  5. +1
    -0
      loopdb/meta.go
  6. +86
    -0
      loopdb/migration_03_last_hop.go
  7. +3
    -2
      loopdb/store_test.go
  8. +1
    -1
      loopin.go
  9. +98
    -100
      looprpc/client.pb.go
  10. +12
    -375
      looprpc/client.pb.gw.go
  11. +3
    -5
      looprpc/client.proto
  12. +22
    -13
      looprpc/client.swagger.json

+ 2
- 2
client.go View File

@ -437,9 +437,9 @@ func (s *Client) waitForInitialized(ctx context.Context) error {
func (s *Client) LoopIn(globalCtx context.Context,
request *LoopInRequest) (*lntypes.Hash, btcutil.Address, error) {
log.Infof("Loop in %v (channel: %v)",
log.Infof("Loop in %v (last hop: %v)",
request.Amount,
request.LoopInChannel,
request.LastHop,
)
if err := s.waitForInitialized(globalCtx); err != nil {

+ 4
- 3
interface.go View File

@ -7,6 +7,7 @@ import (
"github.com/lightninglabs/loop/loopdb"
"github.com/lightninglabs/loop/swap"
"github.com/lightningnetwork/lnd/lntypes"
"github.com/lightningnetwork/lnd/routing/route"
)
// OutRequest contains the required parameters for a loop out swap.
@ -173,9 +174,9 @@ type LoopInRequest struct {
// client htlc tx.
HtlcConfTarget int32
// LoopInChannel optionally specifies the short channel id of the
// channel to loop in.
LoopInChannel *uint64
// LastHop optionally specifies the last hop to use for the loop in
// payment.
LastHop *route.Vertex
// ExternalHtlc specifies whether the htlc is published by an external
// source.

+ 7
- 2
loopd/swapclient_server.go View File

@ -10,6 +10,7 @@ import (
"github.com/lightningnetwork/lnd/lntypes"
"github.com/lightningnetwork/lnd/queue"
"github.com/lightningnetwork/lnd/routing/route"
"github.com/lightninglabs/loop"
"github.com/lightninglabs/loop/lndclient"
@ -387,8 +388,12 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
HtlcConfTarget: defaultConfTarget,
ExternalHtlc: in.ExternalHtlc,
}
if in.LoopInChannel != 0 {
req.LoopInChannel = &in.LoopInChannel
if in.LastHop != nil {
lastHop, err := route.NewVertexFromBytes(in.LastHop)
if err != nil {
return nil, err
}
req.LastHop = &lastHop
}
hash, htlc, err := s.impl.LoopIn(ctx, req)
if err != nil {

+ 13
- 11
loopdb/loopin.go View File

@ -5,6 +5,8 @@ import (
"encoding/binary"
"fmt"
"time"
"github.com/lightningnetwork/lnd/routing/route"
)
// LoopInContract contains the data that is serialized to persistent storage for
@ -16,9 +18,8 @@ type LoopInContract struct {
// client sweep tx.
HtlcConfTarget int32
// LoopInChannel is the channel to charge. If zero, any channel may
// be used.
LoopInChannel *uint64
// LastHop is the last hop to use for the loop in swap (optional).
LastHop *route.Vertex
// ExternalHtlc specifies whether the htlc is published by an external
// source.
@ -96,11 +97,11 @@ func serializeLoopInContract(swap *LoopInContract) (
return nil, err
}
var chargeChannel uint64
if swap.LoopInChannel != nil {
chargeChannel = *swap.LoopInChannel
var lastHop route.Vertex
if swap.LastHop != nil {
lastHop = *swap.LastHop
}
if err := binary.Write(&b, byteOrder, chargeChannel); err != nil {
if err := binary.Write(&b, byteOrder, lastHop[:]); err != nil {
return nil, err
}
@ -167,12 +168,13 @@ func deserializeLoopInContract(value []byte) (*LoopInContract, error) {
return nil, err
}
var loopInChannel uint64
if err := binary.Read(r, byteOrder, &loopInChannel); err != nil {
var lastHop route.Vertex
if err := binary.Read(r, byteOrder, lastHop[:]); err != nil {
return nil, err
}
if loopInChannel != 0 {
contract.LoopInChannel = &loopInChannel
var noLastHop route.Vertex
if lastHop != noLastHop {
contract.LastHop = &lastHop
}
if err := binary.Read(r, byteOrder, &contract.ExternalHtlc); err != nil {

+ 1
- 0
loopdb/meta.go View File

@ -35,6 +35,7 @@ var (
migrations = []migration{
migrateCosts,
migrateSwapPublicationDeadline,
migrateLastHop,
}
latestDBVersion = uint32(len(migrations))

+ 86
- 0
loopdb/migration_03_last_hop.go View File

@ -0,0 +1,86 @@
package loopdb
import (
"bytes"
"errors"
"fmt"
"github.com/btcsuite/btcd/chaincfg"
"github.com/coreos/bbolt"
)
// migrateLastHop migrates the database to v03, replacing the never used loop in
// channel by a last hop pubkey.
func migrateLastHop(tx *bbolt.Tx, chainParams *chaincfg.Params) error {
rootBucket := tx.Bucket(loopInBucketKey)
if rootBucket == nil {
return errors.New("bucket does not exist")
}
return rootBucket.ForEach(func(swapHash, v []byte) error {
// Only go into things that we know are sub-bucket
// keys.
if v != nil {
return nil
}
// From the root bucket, we'll grab the next swap
// bucket for this swap from its swaphash.
swapBucket := rootBucket.Bucket(swapHash)
if swapBucket == nil {
return fmt.Errorf("swap bucket %x not found",
swapHash)
}
// With the main swap bucket obtained, we'll grab the
// raw swap contract bytes.
contractBytes := swapBucket.Get(contractKey)
if contractBytes == nil {
return errors.New("contract not found")
}
const (
// deprecatedLoopInChannelStart is the starting offset
// of the old loop in channel field: 8 (initiation time)
// + 32 (preimage) + 8 (amount requested) + 33 + 33
// (sender and receiver keys) + 4 (cltv expiry) + 8 + 8
// (max miner and swap fee) + 4 (initiation height) + 4
// (conf target) = 142.
deprecatedLoopInChannelStart = 142
// expectedTotalLength is the expect total length of the
// serialized contract. It adds 8 (old loop in channel)
// + 1 (external htlc) = 9 bytes to
// deprecatedLoopInChannelStart.
expectedTotalLength = deprecatedLoopInChannelStart + 9
)
// Sanity check to see if the constants above match the contract
// bytes.
if len(contractBytes) != expectedTotalLength {
return errors.New("invalid serialized contract length")
}
// Copy the unchanged fields into the buffer.
b := &bytes.Buffer{}
_, err := b.Write(contractBytes[:deprecatedLoopInChannelStart])
if err != nil {
return err
}
// We now set the new last hop field to all zeroes to indicate
// that there is no restriction.
var noLastHop [33]byte
if _, err := b.Write(noLastHop[:]); err != nil {
return err
}
// Append the remaining field ExternalHtlc.
_, err = b.Write(contractBytes[deprecatedLoopInChannelStart+8:])
if err != nil {
return err
}
return swapBucket.Put(contractKey, b.Bytes())
})
}

+ 3
- 2
loopdb/store_test.go View File

@ -13,6 +13,7 @@ import (
"github.com/coreos/bbolt"
"github.com/lightninglabs/loop/test"
"github.com/lightningnetwork/lnd/lntypes"
"github.com/lightningnetwork/lnd/routing/route"
)
var (
@ -197,7 +198,7 @@ func TestLoopInStore(t *testing.T) {
// Next, we'll make a new pending swap that we'll insert into the
// database shortly.
loopInChannel := uint64(123)
lastHop := route.Vertex{1, 2, 3}
pendingSwap := LoopInContract{
SwapContract: SwapContract{
@ -215,7 +216,7 @@ func TestLoopInStore(t *testing.T) {
InitiationTime: time.Unix(0, initiationTime.UnixNano()),
},
HtlcConfTarget: 2,
LoopInChannel: &loopInChannel,
LastHop: &lastHop,
ExternalHtlc: true,
}

+ 1
- 1
loopin.go View File

@ -133,7 +133,7 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
contract := loopdb.LoopInContract{
HtlcConfTarget: request.HtlcConfTarget,
LoopInChannel: request.LoopInChannel,
LastHop: request.LastHop,
ExternalHtlc: request.ExternalHtlc,
SwapContract: loopdb.SwapContract{
InitiationHeight: currentHeight,

+ 98
- 100
looprpc/client.pb.go View File

@ -285,11 +285,9 @@ type LoopInRequest struct {
//max_miner_fee is typically taken from the response of the GetQuote call.
MaxMinerFee int64 `protobuf:"varint,3,opt,name=max_miner_fee,json=maxMinerFee,proto3" json:"max_miner_fee,omitempty"`
//*
//The channel to loop in. If zero, the channel to loop in is selected based
//on the lowest routing fee for the swap payment from the server.
//
//Note: NOT YET IMPLEMENTED
LoopInChannel uint64 `protobuf:"varint,4,opt,name=loop_in_channel,json=loopInChannel,proto3" json:"loop_in_channel,omitempty"`
//The last hop to use for the loop in swap. If empty, the last hop is selected
//based on the lowest routing fee for the swap payment from the server.
LastHop []byte `protobuf:"bytes,4,opt,name=last_hop,json=lastHop,proto3" json:"last_hop,omitempty"`
//*
//If external_htlc is true, we expect the htlc to be published by an external
//actor.
@ -345,11 +343,11 @@ func (m *LoopInRequest) GetMaxMinerFee() int64 {
return 0
}
func (m *LoopInRequest) GetLoopInChannel() uint64 {
func (m *LoopInRequest) GetLastHop() []byte {
if m != nil {
return m.LoopInChannel
return m.LastHop
}
return 0
return nil
}
func (m *LoopInRequest) GetExternalHtlc() bool {
@ -1166,98 +1164,98 @@ func init() {
func init() { proto.RegisterFile("client.proto", fileDescriptor_014de31d7ac8c57c) }
var fileDescriptor_014de31d7ac8c57c = []byte{
// 1446 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x4d, 0x6e, 0xdb, 0x46,
0x18, 0x0d, 0x25, 0xda, 0x92, 0x3e, 0x51, 0x14, 0x3d, 0x4e, 0x6c, 0x59, 0x6d, 0x10, 0x87, 0x6d,
0x52, 0xc7, 0x8b, 0xa8, 0x71, 0x76, 0x41, 0x51, 0xc0, 0x91, 0x95, 0x58, 0x86, 0x7f, 0x54, 0x4a,
0x0e, 0x90, 0x6c, 0x98, 0xb1, 0x38, 0xb6, 0x89, 0x8a, 0x1c, 0x86, 0x33, 0x4a, 0x6c, 0x04, 0xd9,
0xf4, 0x00, 0xdd, 0x74, 0xd7, 0x65, 0x6f, 0x50, 0xa0, 0xbb, 0x1e, 0xa3, 0x57, 0xe8, 0x35, 0x0a,
0x14, 0xf3, 0x23, 0x8a, 0xb2, 0xec, 0x2c, 0xb2, 0x33, 0xdf, 0xbc, 0x79, 0xf3, 0xcd, 0x37, 0x6f,
0xde, 0xc8, 0x60, 0x0d, 0x47, 0x21, 0x89, 0xf9, 0xe3, 0x24, 0xa5, 0x9c, 0xa2, 0xd2, 0x88, 0xd2,
0x24, 0x4d, 0x86, 0xcd, 0xaf, 0xcf, 0x28, 0x3d, 0x1b, 0x91, 0x16, 0x4e, 0xc2, 0x16, 0x8e, 0x63,
0xca, 0x31, 0x0f, 0x69, 0xcc, 0x14, 0xcd, 0xfd, 0xbd, 0x08, 0xf6, 0x3e, 0xa5, 0xc9, 0xd1, 0x98,
0x7b, 0xe4, 0xdd, 0x98, 0x30, 0x8e, 0x1c, 0x28, 0xe2, 0x88, 0x37, 0x8c, 0x75, 0x63, 0xa3, 0xe8,
0x89, 0x3f, 0x11, 0x02, 0x33, 0x20, 0x8c, 0x37, 0x0a, 0xeb, 0xc6, 0x46, 0xc5, 0x93, 0x7f, 0xa3,
0x16, 0xdc, 0x8e, 0xf0, 0x85, 0xcf, 0x3e, 0xe0, 0xc4, 0x4f, 0xe9, 0x98, 0x87, 0xf1, 0x99, 0x7f,
0x4a, 0x48, 0xa3, 0x28, 0xa7, 0x2d, 0x45, 0xf8, 0xa2, 0xff, 0x01, 0x27, 0x9e, 0x1a, 0x79, 0x41,
0x08, 0x7a, 0x0a, 0x2b, 0x62, 0x42, 0x92, 0x92, 0x04, 0x5f, 0xce, 0x4c, 0x31, 0xe5, 0x94, 0xe5,
0x08, 0x5f, 0xf4, 0xe4, 0x60, 0x6e, 0xd2, 0x3a, 0x58, 0xd9, 0x2a, 0x82, 0xba, 0x20, 0xa9, 0xa0,
0xd5, 0x05, 0xe3, 0x5b, 0xb0, 0x73, 0xb2, 0xa2, 0xf0, 0x45, 0xc9, 0xb1, 0x32, 0xb9, 0xed, 0x88,
0x23, 0x17, 0x6a, 0x82, 0x15, 0x85, 0x31, 0x49, 0xa5, 0x50, 0x49, 0x92, 0xaa, 0x11, 0xbe, 0x38,
0x10, 0x98, 0x50, 0xda, 0x00, 0x47, 0xf4, 0xcc, 0xa7, 0x63, 0xee, 0x0f, 0xcf, 0x71, 0x1c, 0x93,
0x51, 0xa3, 0xbc, 0x6e, 0x6c, 0x98, 0x9e, 0x3d, 0x52, 0x1d, 0x6a, 0x2b, 0x14, 0x6d, 0xc2, 0x12,
0xfb, 0x40, 0x48, 0xe2, 0x0f, 0x69, 0x7c, 0xea, 0x73, 0x9c, 0x9e, 0x11, 0xde, 0xa8, 0xac, 0x1b,
0x1b, 0x0b, 0x5e, 0x5d, 0x0e, 0xb4, 0x69, 0x7c, 0x3a, 0x90, 0x30, 0x7a, 0x06, 0x6b, 0xb2, 0xfa,
0x64, 0x7c, 0x32, 0x0a, 0x87, 0xb2, 0xf7, 0x7e, 0x40, 0x70, 0x30, 0x0a, 0x63, 0xd2, 0x00, 0x29,
0xbf, 0x2a, 0x08, 0xbd, 0xe9, 0xf8, 0x8e, 0x1e, 0x76, 0xff, 0x32, 0xa0, 0x26, 0x0e, 0xa7, 0x1b,
0xdf, 0x7c, 0x36, 0x57, 0x3b, 0x54, 0x98, 0xeb, 0xd0, 0xdc, 0xde, 0x8b, 0xf3, 0x7b, 0x7f, 0x08,
0x75, 0xb9, 0xf7, 0x30, 0xce, 0xb6, 0x6e, 0xca, 0xda, 0x6a, 0x23, 0xb9, 0xfe, 0x64, 0xe7, 0xdf,
0x40, 0x8d, 0x5c, 0x70, 0x92, 0xc6, 0x78, 0xe4, 0x9f, 0xf3, 0xd1, 0x50, 0x1e, 0x48, 0xd9, 0xb3,
0x26, 0xe0, 0x2e, 0x1f, 0x0d, 0xdd, 0xb7, 0x60, 0xc9, 0xb3, 0x27, 0x2c, 0xa1, 0x31, 0x23, 0x08,
0x41, 0x21, 0x0c, 0x64, 0xcd, 0x95, 0xe7, 0x85, 0x86, 0xe1, 0x15, 0xc2, 0x00, 0xad, 0x41, 0x39,
0x0c, 0xfc, 0x93, 0x4b, 0x4e, 0x98, 0xac, 0xc7, 0xf2, 0x4a, 0x61, 0xf0, 0x5c, 0x7c, 0xa2, 0xfb,
0x60, 0x09, 0x69, 0x1f, 0x07, 0x41, 0x4a, 0x18, 0xd3, 0xae, 0xab, 0x0a, 0x6c, 0x5b, 0x41, 0xae,
0x03, 0xf6, 0x01, 0x8d, 0x43, 0x4e, 0x53, 0xdd, 0x18, 0xf7, 0xbf, 0x02, 0x80, 0x58, 0xb4, 0xcf,
0x31, 0x1f, 0xb3, 0x6b, 0x3d, 0x2c, 0x8a, 0x28, 0xdc, 0x58, 0x44, 0x75, 0xb6, 0x88, 0x07, 0x60,
0xf2, 0xcb, 0x44, 0xf5, 0xca, 0xde, 0x5a, 0x7a, 0xac, 0x6f, 0xd3, 0x63, 0xb1, 0xc6, 0xe0, 0x32,
0x21, 0x9e, 0x1c, 0x46, 0x1b, 0xb0, 0xc0, 0x38, 0xe6, 0xca, 0xc3, 0xf6, 0x16, 0x9a, 0xe1, 0x89,
0x5a, 0x88, 0xa7, 0x08, 0xe8, 0x3b, 0xa8, 0x87, 0x71, 0xc8, 0x43, 0xe5, 0x00, 0x1e, 0x46, 0x13,
0x33, 0xdb, 0x53, 0x78, 0x10, 0x46, 0xca, 0x86, 0x98, 0x71, 0x7f, 0x9c, 0x04, 0x98, 0x13, 0xc5,
0x54, 0x96, 0xb6, 0x05, 0x7e, 0x2c, 0x61, 0xc9, 0xbc, 0xda, 0xa8, 0xd2, 0x5c, 0xa3, 0xd0, 0x3d,
0xa8, 0x0e, 0x29, 0xe3, 0x3e, 0x23, 0xe9, 0x7b, 0x92, 0x4a, 0x3b, 0x17, 0x3d, 0x10, 0x50, 0x5f,
0x22, 0x42, 0x43, 0x12, 0x68, 0x3c, 0x3c, 0xc7, 0x61, 0x2c, 0x5d, 0x5c, 0xf4, 0xe4, 0xa4, 0x23,
0x05, 0x89, 0x33, 0x57, 0x94, 0xd3, 0x53, 0xc5, 0x01, 0x75, 0xc1, 0x24, 0x47, 0x63, 0x2e, 0x02,
0x67, 0x3f, 0x64, 0x5c, 0x6c, 0x9b, 0x4d, 0xce, 0xe4, 0x47, 0x58, 0xca, 0x61, 0xda, 0x0c, 0x8f,
0x60, 0x41, 0x78, 0x95, 0x35, 0x8c, 0xf5, 0xe2, 0x46, 0x75, 0x6b, 0x79, 0xae, 0x63, 0x63, 0xe6,
0x29, 0x86, 0x7b, 0x1f, 0xea, 0x02, 0xec, 0xc6, 0xa7, 0x74, 0xe2, 0x7f, 0x3b, 0xb3, 0x92, 0x25,
0x4e, 0xd0, 0xb5, 0xc1, 0x1a, 0x90, 0x34, 0xca, 0x96, 0xfc, 0x04, 0x35, 0xfd, 0xad, 0x97, 0x7b,
0x08, 0xf5, 0x28, 0x8c, 0xd5, 0xf5, 0xc0, 0x11, 0x1d, 0xc7, 0x5c, 0xb7, 0xbd, 0x16, 0x85, 0xb1,
0x50, 0xdf, 0x96, 0xa0, 0xe4, 0x4d, 0xae, 0x91, 0xe6, 0x2d, 0x6a, 0x9e, 0xba, 0x49, 0x8a, 0xb7,
0x67, 0x96, 0x0d, 0xa7, 0xb0, 0x67, 0x96, 0x0b, 0x4e, 0x71, 0xcf, 0x2c, 0x17, 0x1d, 0x73, 0xcf,
0x2c, 0x9b, 0xce, 0xc2, 0x9e, 0x59, 0x2e, 0x39, 0x65, 0xf7, 0x0f, 0x03, 0xac, 0x9f, 0xc6, 0x94,
0x93, 0x9b, 0xef, 0xab, 0x3c, 0x91, 0x69, 0x6a, 0x14, 0x64, 0x6a, 0xc0, 0x70, 0x1a, 0x18, 0x73,
0x57, 0xac, 0x38, 0x7f, 0xc5, 0x3e, 0x9f, 0x2a, 0xe6, 0xe7, 0x53, 0xe5, 0x4f, 0x03, 0x6a, 0xba,
0x48, 0xdd, 0xa4, 0x35, 0x28, 0x67, 0xf9, 0xa1, 0x4a, 0x2d, 0x31, 0x1d, 0x1e, 0x77, 0x01, 0x72,
0xd1, 0xaa, 0xc2, 0xa5, 0x92, 0x64, 0xb9, 0xfa, 0x15, 0x54, 0xae, 0xe6, 0x4a, 0x39, 0x9a, 0x84,
0x8a, 0x8c, 0x49, 0x51, 0x24, 0xbe, 0x8c, 0x48, 0xcc, 0x7d, 0xf9, 0x86, 0x98, 0xf2, 0xec, 0xea,
0xb2, 0x38, 0x85, 0xef, 0x88, 0x46, 0xdd, 0x05, 0x18, 0x8e, 0xf8, 0x7b, 0x3f, 0x20, 0x23, 0x8e,
0xe5, 0x11, 0x2d, 0x78, 0x15, 0x81, 0xec, 0x08, 0xc0, 0xad, 0x43, 0x6d, 0x40, 0x7f, 0x26, 0x71,
0x76, 0xd0, 0x3f, 0x80, 0x3d, 0x01, 0xf4, 0x26, 0x36, 0x61, 0x91, 0x4b, 0x44, 0x3b, 0x6b, 0x7a,
0x17, 0xf7, 0x19, 0xe6, 0x92, 0xec, 0x69, 0x86, 0xfb, 0x77, 0x01, 0x2a, 0x19, 0x2a, 0x3a, 0x7e,
0x82, 0x19, 0xf1, 0x23, 0x3c, 0xc4, 0x29, 0xa5, 0xb1 , 0xf6, 0x97, 0x25, 0xc0, 0x03, 0x8d, 0x89,
0x8b, 0x32, 0xd9, 0xc7, 0x39, 0x66, 0xe7, 0xb2, 0x15, 0x96, 0x57, 0xd5, 0xd8, 0x2e, 0x66, 0xe7,
0xe8, 0x11, 0x38, 0x13, 0x4a, 0x92, 0x92, 0x30, 0xc2, 0x67, 0x44, 0x67, 0x5b, 0x5d, 0xe3, 0x3d,
0x0d, 0x8b, 0x4b, 0xae, 0x5c, 0xe6, 0x27, 0x38, 0x0c, 0xfc, 0x88, 0x61, 0xae, 0x9f, 0x41, 0x5b,
0xe1, 0x3d, 0x1c, 0x06, 0x07, 0x0c, 0x73, 0xf4, 0x04, 0xee, 0xe4, 0xde, 0xca, 0x1c, 0x5d, 0xd9,
0x18, 0xa5, 0xd9, 0x63, 0x99, 0x4d, 0xb9, 0x0f, 0x96, 0x48, 0x0d, 0x7f, 0x98, 0x12, 0xcc, 0x49,
0xa0, 0x8d, 0x5c, 0x15, 0x58, 0x5b, 0x41, 0xa8, 0x01, 0x25, 0x72, 0x91, 0x84, 0x29, 0x09, 0x64,
0x6a, 0x94, 0xbd, 0xc9, 0xa7, 0x98, 0xcc, 0x38, 0x4d, 0xf1, 0x19, 0xf1, 0x63, 0x1c, 0x11, 0x19,
0x19, 0x15, 0xaf, 0xaa, 0xb1, 0x43, 0x1c, 0x91, 0xcd, 0x07, 0x50, 0x9e, 0xc4, 0x20, 0xb2, 0xa0,
0xbc, 0x7f, 0x74, 0xd4, 0xf3, 0x8f, 0x8e, 0x07, 0xce, 0x2d, 0x54, 0x85, 0x92, 0xfc, 0xea, 0x1e,
0x3a, 0xc6, 0x26, 0x83, 0x4a, 0x96, 0x82, 0xa8, 0x06, 0x95, 0xee, 0x61, 0x77, 0xd0, 0xdd, 0x1e,
0x74, 0x76, 0x9c, 0x5b, 0xe8, 0x0e, 0x2c, 0xf5, 0xbc, 0x4e, 0xf7, 0x60, 0xfb, 0x65, 0xc7, 0xf7,
0x3a, 0xaf, 0x3a, 0xdb, 0xfb, 0x9d, 0x1d, 0xc7, 0x40, 0x08, 0xec, 0xdd, 0xc1, 0x7e, 0xdb, 0xef,
0x1d, 0x3f, 0xdf, 0xef, 0xf6, 0x77, 0x3b, 0x3b, 0x4e, 0x41, 0x68, 0xf6, 0x8f, 0xdb, 0xed, 0x4e,
0xbf, 0xef, 0x14, 0x11, 0xc0, 0xe2, 0x8b, 0xed, 0xae, 0x20, 0x9b, 0x68, 0x19, 0xea, 0xdd, 0xc3,
0x57, 0x47, 0xdd, 0x76, 0xc7, 0xef, 0x77, 0x06, 0x03, 0x01, 0x2e, 0x6c, 0xfd, 0x5a, 0x52, 0xef,
0x40, 0x5b, 0xfe, 0x16, 0x42, 0x1e, 0x94, 0xf4, 0xaf, 0x1b, 0xb4, 0x3a, 0xf5, 0xc3, 0xcc, 0xef,
0x9d, 0xe6, 0x9d, 0x99, 0x08, 0x9a, 0xf8, 0xc9, 0x5d, 0xfd, 0xe5, 0x9f, 0x7f, 0x7f, 0x2b, 0x2c,
0xb9, 0x56, 0xeb, 0xfd, 0x93, 0x96, 0x60, 0xb4, 0xe8, 0x98, 0x3f, 0x33, 0x36, 0xd1, 0x11, 0x2c,
0xaa, 0x47, 0x19, 0xad, 0xcc, 0x48, 0x66, 0xaf, 0xf4, 0x4d, 0x8a, 0x2b, 0x52, 0xd1, 0x71, 0xab,
0x99, 0x62, 0x18, 0x0b, 0xc1, 0x3e, 0x94, 0xf4, 0x6b, 0x96, 0x2b, 0x72, 0xf6, 0x7d, 0x6b, 0x5e,
0x97, 0x93, 0x6e, 0x43, 0x0a, 0x22, 0xe4, 0x64, 0x82, 0x91, 0x9a, 0xf5, 0xbd, 0x81, 0xde, 0x40,
0x25, 0x0b, 0x5f, 0xb4, 0x36, 0x2d, 0xf4, 0x4a, 0x48, 0x37, 0x9b, 0xd7, 0x0d, 0xcd, 0x16, 0x8c,
0xec, 0x4c, 0x5f, 0x06, 0x33, 0x3a, 0x56, 0x06, 0x10, 0xc1, 0x8c, 0x1a, 0x33, 0x85, 0xe5, 0xb2,
0xfa, 0xfa, 0x92, 0x9b, 0x52, 0xf2, 0x36, 0x42, 0x33, 0x92, 0xad, 0x8f, 0x61, 0xf0, 0x09, 0xbd,
0x06, 0x4b, 0x1f, 0x8d, 0xcc, 0x70, 0x34, 0x6d, 0x63, 0x3e, 0xe3, 0x9b, 0x2b, 0x57, 0x61, 0x5d,
0xed, 0xbc, 0x34, 0x1d, 0xf3, 0x16, 0x97, 0x52, 0x7e, 0x26, 0x2d, 0x93, 0x2f, 0x27, 0x9d, 0x8f,
0xeb, 0x9c, 0xf4, 0x4c, 0x40, 0xba, 0xeb, 0x52, 0xba, 0x89, 0x1a, 0x33, 0xd2, 0xef, 0x04, 0xa7,
0xf5, 0x11, 0x47, 0xfc, 0x13, 0x7a, 0x03, 0xf6, 0x4b, 0xc2, 0x95, 0x0d, 0xbe, 0xa8, 0xfa, 0x35,
0xb9, 0xc4, 0x32, 0x5a, 0xca, 0x99, 0x43, 0x17, 0xff, 0x36, 0xa7, 0xfd, 0x45, 0xe5, 0xdf, 0x93,
0xda, 0x6b, 0x68, 0x35, 0xaf, 0x9d, 0xaf, 0xfe, 0x35, 0xd4, 0xc4, 0x0a, 0x93, 0x44, 0x64, 0x39,
0x67, 0xcf, 0xc4, 0x6e, 0x73, 0x75, 0x0e, 0x9f, 0xbd, 0x2d, 0xa8, 0x2e, 0x97, 0x60, 0x98, 0xb7,
0x54, 0xd4, 0x9e, 0x2c, 0xca, 0xff, 0x33, 0x9e, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x04, 0xc2,
0xbc, 0x71, 0x9e, 0x0c, 0x00, 0x00,
// 1445 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xcd, 0x6e, 0xdb, 0xc6,
0x1a, 0x0d, 0x25, 0xd9, 0xa2, 0x3e, 0x51, 0x14, 0x3d, 0x4e, 0x6c, 0x59, 0xf7, 0x06, 0x71, 0x78,
0x6f, 0xee, 0x75, 0xbc, 0x88, 0x1a, 0x67, 0x17, 0x14, 0x05, 0x1c, 0x59, 0x89, 0x65, 0xf8, 0xaf,
0x94, 0x1c, 0x20, 0xd9, 0x30, 0x63, 0x71, 0x6c, 0x13, 0x15, 0x39, 0x0c, 0x67, 0x94, 0xd8, 0x08,
0xb2, 0xe9, 0x03, 0x74, 0xd3, 0x5d, 0x97, 0xdd, 0x74, 0xdd, 0x75, 0x1f, 0xa3, 0xaf, 0xd0, 0xd7,
0x28, 0x50, 0xcc, 0x8f, 0x28, 0xd2, 0xb2, 0xb3, 0xc8, 0x4e, 0x3c, 0x73, 0xe6, 0xcc, 0xc7, 0xef,
0xe7, 0x0c, 0x05, 0xd6, 0x68, 0x1c, 0x92, 0x98, 0x3f, 0x49, 0x52, 0xca, 0x29, 0xaa, 0x8e, 0x29,
0x4d, 0xd2, 0x64, 0xd4, 0xfe, 0xf7, 0x39, 0xa5, 0xe7, 0x63, 0xd2, 0xc1, 0x49, 0xd8, 0xc1, 0x71,
0x4c, 0x39, 0xe6, 0x21, 0x8d, 0x99, 0xa2, 0xb9, 0xbf, 0x94, 0xc1, 0xde, 0xa7, 0x34, 0x39, 0x9a,
0x70, 0x8f, 0xbc, 0x9f, 0x10, 0xc6, 0x91, 0x03, 0x65, 0x1c, 0xf1, 0x96, 0xb1, 0x6e, 0x6c, 0x94,
0x3d, 0xf1, 0x13, 0x21, 0xa8, 0x04, 0x84, 0xf1, 0x56, 0x69, 0xdd, 0xd8, 0xa8, 0x79, 0xf2, 0x37,
0xea, 0xc0, 0xdd, 0x08, 0x5f, 0xfa, 0xec, 0x23, 0x4e, 0xfc, 0x94, 0x4e, 0x78, 0x18, 0x9f, 0xfb,
0x67, 0x84, 0xb4, 0xca, 0x72, 0xdb, 0x52, 0x84, 0x2f, 0x07, 0x1f, 0x71, 0xe2, 0xa9, 0x95, 0x97,
0x84, 0xa0, 0x67, 0xb0, 0x22, 0x36, 0x24, 0x29, 0x49, 0xf0, 0x55, 0x61, 0x4b, 0x45, 0x6e, 0x59,
0x8e, 0xf0, 0xe5, 0xb1, 0x5c, 0xcc, 0x6d, 0x5a, 0x07, 0x2b, 0x3b, 0x45, 0x50, 0x17, 0x24, 0x15,
0xb4, 0xba, 0x60, 0xfc, 0x17, 0xec, 0x9c, 0xac, 0x08, 0x7c, 0x51, 0x72, 0xac, 0x4c, 0x6e, 0x3b,
0xe2, 0xc8, 0x85, 0x86, 0x60, 0x45, 0x61, 0x4c, 0x52, 0x29, 0x54, 0x95, 0xa4, 0x7a, 0x84, 0x2f,
0x0f, 0x04, 0x26, 0x94, 0x36, 0xc0, 0x11, 0x39, 0xf3, 0xe9, 0x84, 0xfb, 0xa3, 0x0b, 0x1c, 0xc7,
0x64, 0xdc, 0x32, 0xd7, 0x8d, 0x8d, 0x8a, 0x67, 0x8f, 0x55, 0x86, 0xba, 0x0a, 0x45, 0x9b, 0xb0,
0xc4, 0x3e, 0x12, 0x92, 0xf8, 0x23, 0x1a, 0x9f, 0xf9, 0x1c, 0xa7, 0xe7, 0x84, 0xb7, 0x6a, 0xeb,
0xc6, 0xc6, 0x82, 0xd7, 0x94, 0x0b, 0x5d, 0x1a, 0x9f, 0x0d, 0x25, 0x8c, 0x9e, 0xc3, 0x9a, 0x8c,
0x3e, 0x99, 0x9c, 0x8e, 0xc3, 0x91, 0xcc, 0xbd, 0x1f, 0x10, 0x1c, 0x8c, 0xc3, 0x98, 0xb4, 0x40,
0xca, 0xaf, 0x0a, 0xc2, 0xf1, 0x6c, 0x7d, 0x47, 0x2f, 0xbb, 0xbf, 0x19, 0xd0, 0x10, 0xc5, 0xe9,
0xc7, 0xb7, 0xd7, 0xe6, 0x7a, 0x86, 0x4a, 0x73, 0x19, 0x9a, 0x7b, 0xf7, 0xf2, 0xfc, 0xbb, 0xaf,
0x81, 0x39, 0xc6, 0x8c, 0xfb, 0x17, 0x34, 0x91, 0xe5, 0xb0, 0xbc, 0xaa, 0x78, 0xde, 0xa5, 0x09,
0xfa, 0x0f, 0x34, 0xc8, 0x25, 0x27, 0x69, 0x8c, 0xc7, 0xfe, 0x05, 0x1f, 0x8f, 0x64, 0x0d, 0x4c,
0xcf, 0x9a, 0x82, 0xbb, 0x7c, 0x3c, 0x72, 0xdf, 0x81, 0x25, 0xcb, 0x4d, 0x58, 0x42, 0x63, 0x46,
0x10, 0x82, 0x52, 0x18, 0xc8, 0x30, 0x6b, 0x2f, 0x4a, 0x2d, 0xc3, 0x2b, 0x85, 0x81, 0x38, 0x23,
0x0c, 0xfc, 0xd3, 0x2b, 0x4e, 0x98, 0x0c, 0xc1, 0xf2, 0xaa, 0x61, 0xf0, 0x42, 0x3c, 0xa2, 0x87,
0x60, 0x09, 0x69, 0x1f, 0x07, 0x41, 0x4a, 0x18, 0xd3, 0x8d, 0x56, 0x17, 0xd8, 0xb6, 0x82, 0x5c,
0x07, 0xec, 0x03, 0x1a, 0x87, 0x9c, 0xa6, 0x3a, 0x17, 0xee, 0xdf, 0x25, 0x00, 0x71, 0xe8, 0x80,
0x63, 0x3e, 0x61, 0x37, 0xb6, 0xad, 0x08, 0xa2, 0x74, 0x6b, 0x10, 0xf5, 0x62, 0x10, 0x8f, 0xa0,
0xc2, 0xaf, 0x12, 0x95, 0x1e, 0x7b, 0x6b, 0xe9, 0x89, 0x1e, 0xa0, 0x27, 0xe2, 0x8c, 0xe1, 0x55,
0x42, 0x3c, 0xb9, 0x8c, 0x36, 0x60, 0x81, 0x71, 0xcc, 0x55, 0xdb, 0xda, 0x5b, 0xa8, 0xc0, 0x13,
0xb1, 0x10, 0x4f, 0x11, 0xd0, 0xff, 0xa1, 0x19, 0xc6, 0x21, 0x0f, 0x55, 0xd1, 0x79, 0x18, 0x4d,
0xfb, 0xd7, 0x9e, 0xc1, 0xc3, 0x30, 0x52, 0x9d, 0x27, 0xb2, 0x3f, 0x49, 0x02, 0xcc, 0x89, 0x62,
0xaa, 0x2e, 0xb6, 0x05, 0x7e, 0x22, 0x61, 0xc9, 0xbc, 0x9e, 0xa8, 0xea, 0x5c, 0xa2, 0xd0, 0x03,
0xa8, 0x8f, 0x28, 0xe3, 0x3e, 0x23, 0xe9, 0x07, 0x92, 0xca, 0x0e, 0x2e, 0x7b, 0x20, 0xa0, 0x81,
0x44, 0x84, 0x86, 0x24, 0xd0, 0x78, 0x74, 0x81, 0xc3, 0x58, 0x36, 0x6e, 0xd9, 0x93, 0x9b, 0x8e,
0x14, 0x24, 0x6a, 0xae, 0x28, 0x67, 0x67, 0x8a, 0x03, 0x6a, 0xa6, 0x24, 0x47, 0x63, 0x2e, 0x02,
0x67, 0x3f, 0x64, 0x5c, 0xbc, 0x36, 0x9b, 0xd6, 0xe4, 0x3b, 0x58, 0xca, 0x61, 0xba, 0x19, 0x1e,
0xc3, 0x82, 0x68, 0x4f, 0xd6, 0x32, 0xd6, 0xcb, 0x1b, 0xf5, 0xad, 0xe5, 0xb9, 0x8c, 0x4d, 0x98,
0xa7, 0x18, 0xee, 0x43, 0x68, 0x0a, 0xb0, 0x1f, 0x9f, 0xd1, 0x69, 0xcb, 0xdb, 0x59, 0x2b, 0x59,
0xa2, 0x82, 0xae, 0x0d, 0xd6, 0x90, 0xa4, 0x51, 0x76, 0xe4, 0x67, 0x68, 0xe8, 0x67, 0x7d, 0xdc,
0xff, 0xa0, 0x19, 0x85, 0xb1, 0x9a, 0x08, 0x1c, 0xd1, 0x49, 0xcc, 0x75, 0xda, 0x1b, 0x51, 0x18,
0x0b, 0xf5, 0x6d, 0x09, 0x4a, 0xde, 0x74, 0x72, 0x34, 0x6f, 0x51, 0xf3, 0xd4, 0xf0, 0x28, 0xde,
0x5e, 0xc5, 0x34, 0x9c, 0xd2, 0x5e, 0xc5, 0x2c, 0x39, 0xe5, 0xbd, 0x8a, 0x59, 0x76, 0x2a, 0x7b,
0x15, 0xb3, 0xe2, 0x2c, 0xec, 0x55, 0xcc, 0xaa, 0x63, 0xba, 0xbf, 0x1a, 0x60, 0x7d, 0x3f, 0xa1,
0x9c, 0xdc, 0x3e, 0xa2, 0xb2, 0x22, 0x33, 0xa3, 0x28, 0x49, 0xa3, 0x80, 0xd1, 0xcc, 0x23, 0xe6,
0x46, 0xac, 0x3c, 0x3f, 0x62, 0x5f, 0x36, 0x92, 0xca, 0x97, 0x8d, 0xe4, 0x77, 0x03, 0x1a, 0x3a,
0x48, 0x9d, 0xa4, 0x35, 0x30, 0x33, 0xcb, 0x50, 0xa1, 0x56, 0x99, 0xf6, 0x8b, 0xfb, 0x00, 0x39,
0x37, 0x55, 0x7e, 0x52, 0x4b, 0x32, 0x2b, 0xfd, 0x17, 0xd4, 0xae, 0x5b, 0x89, 0x19, 0x4d, 0x7d,
0x44, 0x3a, 0xa3, 0x08, 0x12, 0x5f, 0x45, 0x24, 0xe6, 0xbe, 0xbc, 0x36, 0x94, 0xa1, 0x34, 0x65,
0x70, 0x0a, 0xdf, 0x11, 0x89, 0xba, 0x0f, 0x30, 0x1a, 0xf3, 0x0f, 0x7e, 0x40, 0xc6, 0x1c, 0xcb,
0x12, 0x2d, 0x78, 0x35, 0x81, 0xec, 0x08, 0xc0, 0x6d, 0x42, 0x63, 0x48, 0x7f, 0x20, 0x71, 0x56,
0xe8, 0x6f, 0xc1, 0x9e, 0x02, 0xfa, 0x25, 0x36, 0x61, 0x91, 0x4b, 0x44, 0x77, 0xd6, 0x6c, 0x16,
0xf7, 0x19, 0xe6, 0x92, 0xec, 0x69, 0x86, 0xfb, 0x47, 0x09, 0x6a, 0x19, 0x2a, 0x32, 0x7e, 0x8a,
0x19, 0xf1, 0x23, 0x3c, 0xc2, 0x29, 0xa5, 0xb1, 0xee, 0x2f, 0x4b, 0x80, 0x07, 0x1a, 0x13, 0x83,
0x32, 0x7d, 0x8f, 0x0b, 0xcc, 0x2e, 0x64, 0x2a, 0x2c, 0xaf, 0xae, 0xb1, 0x5d, 0xcc, 0x2e, 0xd0,
0x63, 0x70, 0xa6, 0x94, 0x24, 0x25, 0x61, 0x84, 0xcf, 0x89, 0xf6, 0xb6, 0xa6, 0xc6, 0x8f, 0x35,
0x2c, 0x86, 0x5c, 0x75, 0x99, 0x9f, 0xe0, 0x30, 0xf0, 0x23, 0x86, 0xb9, 0xbe, 0xf9, 0x6c, 0x85,
0x1f, 0xe3, 0x30, 0x38, 0x60, 0x98, 0xa3, 0xa7, 0x70, 0x2f, 0x77, 0x3d, 0xe6, 0xe8, 0xaa, 0x8d,
0x51, 0x9a, 0xdd, 0x8f, 0xd9, 0x96, 0x87, 0x60, 0x09, 0xd7, 0xf0, 0x47, 0x29, 0xc1, 0x9c, 0x04,
0xba, 0x91, 0xeb, 0x02, 0xeb, 0x2a, 0x08, 0xb5, 0xa0, 0x4a, 0x2e, 0x93, 0x30, 0x25, 0x81, 0x74,
0x0d, 0xd3, 0x9b, 0x3e, 0x8a, 0xcd, 0x8c, 0xd3, 0x14, 0x9f, 0x13, 0x3f, 0xc6, 0x11, 0x91, 0x96,
0x51, 0xf3, 0xea, 0x1a, 0x3b, 0xc4, 0x11, 0xd9, 0x7c, 0x04, 0xe6, 0xd4, 0x06, 0x91, 0x05, 0xe6,
0xfe, 0xd1, 0xd1, 0xb1, 0x7f, 0x74, 0x32, 0x74, 0xee, 0xa0, 0x3a, 0x54, 0xe5, 0x53, 0xff, 0xd0,
0x31, 0x36, 0x19, 0xd4, 0x32, 0x17, 0x44, 0x0d, 0xa8, 0xf5, 0x0f, 0xfb, 0xc3, 0xfe, 0xf6, 0xb0,
0xb7, 0xe3, 0xdc, 0x41, 0xf7, 0x60, 0xe9, 0xd8, 0xeb, 0xf5, 0x0f, 0xb6, 0x5f, 0xf5, 0x7c, 0xaf,
0xf7, 0xba, 0xb7, 0xbd, 0xdf, 0xdb, 0x71, 0x0c, 0x84, 0xc0, 0xde, 0x1d, 0xee, 0x77, 0xfd, 0xe3,
0x93, 0x17, 0xfb, 0xfd, 0xc1, 0x6e, 0x6f, 0xc7, 0x29, 0x09, 0xcd, 0xc1, 0x49, 0xb7, 0xdb, 0x1b,
0x0c, 0x9c, 0x32, 0x02, 0x58, 0x7c, 0xb9, 0xdd, 0x17, 0xe4, 0x0a, 0x5a, 0x86, 0x66, 0xff, 0xf0,
0xf5, 0x51, 0xbf, 0xdb, 0xf3, 0x07, 0xbd, 0xe1, 0x50, 0x80, 0x0b, 0x5b, 0x3f, 0x55, 0xd5, 0x3d,
0xd0, 0x95, 0x9f, 0x3f, 0xc8, 0x83, 0xaa, 0xfe, 0xa0, 0x41, 0xab, 0xb3, 0x7e, 0x28, 0x7c, 0xe2,
0xb4, 0xef, 0x15, 0x2c, 0x68, 0xda, 0x4f, 0xee, 0xea, 0x8f, 0x7f, 0xfe, 0xf5, 0x73, 0x69, 0xc9,
0xb5, 0x3a, 0x1f, 0x9e, 0x76, 0x04, 0xa3, 0x43, 0x27, 0xfc, 0xb9, 0xb1, 0x89, 0x8e, 0x60, 0x51,
0xdd, 0xc3, 0x68, 0xa5, 0x20, 0x99, 0x5d, 0xcc, 0xb7, 0x29, 0xae, 0x48, 0x45, 0xc7, 0xad, 0x67,
0x8a, 0x61, 0x2c, 0x04, 0x07, 0x50, 0xd5, 0xb7, 0x59, 0x2e, 0xc8, 0xe2, 0xfd, 0xd6, 0xbe, 0xc9,
0x27, 0xdd, 0x96, 0x14, 0x44, 0xc8, 0xc9, 0x04, 0x23, 0xb5, 0xeb, 0x1b, 0x03, 0xbd, 0x85, 0x5a,
0x66, 0xbe, 0x68, 0x6d, 0x16, 0xe8, 0x35, 0x93, 0x6e, 0xb7, 0x6f, 0x5a, 0x2a, 0x06, 0x8c, 0xec,
0x4c, 0x5f, 0x1a, 0x33, 0x3a, 0x51, 0x0d, 0x20, 0x8c, 0x19, 0xb5, 0x0a, 0x81, 0xe5, 0xbc, 0xfa,
0xe6, 0x90, 0xdb, 0x52, 0xf2, 0x2e, 0x42, 0x05, 0xc9, 0xce, 0xa7, 0x30, 0xf8, 0x8c, 0xde, 0x80,
0xa5, 0x4b, 0x23, 0x3d, 0x1c, 0xcd, 0xd2, 0x98, 0xf7, 0xf8, 0xf6, 0xca, 0x75, 0x58, 0x47, 0x3b,
0x2f, 0x4d, 0x27, 0xbc, 0xc3, 0xa5, 0x94, 0x9f, 0x49, 0x4b, 0xe7, 0xcb, 0x49, 0xe7, 0xed, 0x3a,
0x27, 0x5d, 0x30, 0x48, 0x77, 0x5d, 0x4a, 0xb7, 0x51, 0xab, 0x20, 0xfd, 0x5e, 0x70, 0x3a, 0x9f,
0x70, 0xc4, 0x3f, 0xa3, 0xb7, 0x60, 0xbf, 0x22, 0x5c, 0xb5, 0xc1, 0x57, 0x45, 0xbf, 0x26, 0x8f,
0x58, 0x46, 0x4b, 0xb9, 0xe6, 0xd0, 0xc1, 0xbf, 0xcb, 0x69, 0x7f, 0x55, 0xf8, 0x0f, 0xa4, 0xf6,
0x1a, 0x5a, 0xcd, 0x6b, 0xe7, 0xa3, 0x7f, 0x03, 0x0d, 0x71, 0xc2, 0xd4, 0x11, 0x59, 0xae, 0xb3,
0x0b, 0xb6, 0xdb, 0x5e, 0x9d, 0xc3, 0x8b, 0xd3, 0x82, 0x9a, 0xf2, 0x08, 0x86, 0x79, 0x47, 0x59,
0xed, 0xe9, 0xa2, 0xfc, 0x6b, 0xf1, 0xec, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x66, 0x22, 0xfe,
0xe9, 0x91, 0x0c, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

+ 12
- 375
looprpc/client.pb.gw.go View File

@ -13,7 +13,6 @@ import (
"io"
"net/http"
"github.com/golang/protobuf/descriptor"
"github.com/golang/protobuf/proto"
"github.com/grpc-ecosystem/grpc-gateway/runtime"
"github.com/grpc-ecosystem/grpc-gateway/utilities"
@ -23,13 +22,11 @@ import (
"google.golang.org/grpc/status"
)
// Suppress "imported and not used" errors
var _ codes.Code
var _ io.Reader
var _ status.Status
var _ = runtime.String
var _ = utilities.NewDoubleArray
var _ = descriptor.ForMessage
func request_SwapClient_LoopOut_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq LoopOutRequest
@ -48,23 +45,6 @@ func request_SwapClient_LoopOut_0(ctx context.Context, marshaler runtime.Marshal
}
func local_request_SwapClient_LoopOut_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq LoopOutRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.LoopOut(ctx, &protoReq)
return msg, metadata, err
}
func request_SwapClient_LoopIn_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq LoopInRequest
var metadata runtime.ServerMetadata
@ -82,23 +62,6 @@ func request_SwapClient_LoopIn_0(ctx context.Context, marshaler runtime.Marshale
}
func local_request_SwapClient_LoopIn_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq LoopInRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.LoopIn(ctx, &protoReq)
return msg, metadata, err
}
func request_SwapClient_Monitor_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (SwapClient_MonitorClient, runtime.ServerMetadata, error) {
var protoReq MonitorRequest
var metadata runtime.ServerMetadata
@ -125,15 +88,6 @@ func request_SwapClient_ListSwaps_0(ctx context.Context, marshaler runtime.Marsh
}
func local_request_SwapClient_ListSwaps_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq ListSwapsRequest
var metadata runtime.ServerMetadata
msg, err := server.ListSwaps(ctx, &protoReq)
return msg, metadata, err
}
func request_SwapClient_SwapInfo_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq SwapInfoRequest
var metadata runtime.ServerMetadata
@ -161,33 +115,6 @@ func request_SwapClient_SwapInfo_0(ctx context.Context, marshaler runtime.Marsha
}
func local_request_SwapClient_SwapInfo_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq SwapInfoRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["id"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
}
protoReq.Id, err = runtime.Bytes(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
}
msg, err := server.SwapInfo(ctx, &protoReq)
return msg, metadata, err
}
func request_SwapClient_LoopOutTerms_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq TermsRequest
var metadata runtime.ServerMetadata
@ -197,15 +124,6 @@ func request_SwapClient_LoopOutTerms_0(ctx context.Context, marshaler runtime.Ma
}
func local_request_SwapClient_LoopOutTerms_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq TermsRequest
var metadata runtime.ServerMetadata
msg, err := server.LoopOutTerms(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_SwapClient_LoopOutQuote_0 = &utilities.DoubleArray{Encoding: map[string]int{"amt": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
)
@ -232,45 +150,11 @@ func request_SwapClient_LoopOutQuote_0(ctx context.Context, marshaler runtime.Ma
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt", err)
}
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SwapClient_LoopOutQuote_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.LoopOutQuote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_SwapClient_LoopOutQuote_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QuoteRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["amt"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "amt")
}
protoReq.Amt, err = runtime.Int64(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_SwapClient_LoopOutQuote_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.LoopOutQuote(ctx, &protoReq)
msg, err := client.LoopOutQuote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
@ -284,15 +168,6 @@ func request_SwapClient_GetLoopInTerms_0(ctx context.Context, marshaler runtime.
}
func local_request_SwapClient_GetLoopInTerms_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq TermsRequest
var metadata runtime.ServerMetadata
msg, err := server.GetLoopInTerms(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_SwapClient_GetLoopInQuote_0 = &utilities.DoubleArray{Encoding: map[string]int{"amt": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
)
@ -319,45 +194,11 @@ func request_SwapClient_GetLoopInQuote_0(ctx context.Context, marshaler runtime.
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt", err)
}
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SwapClient_GetLoopInQuote_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.GetLoopInQuote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_SwapClient_GetLoopInQuote_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QuoteRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["amt"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "amt")
}
protoReq.Amt, err = runtime.Int64(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_SwapClient_GetLoopInQuote_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.GetLoopInQuote(ctx, &protoReq)
msg, err := client.GetLoopInQuote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
@ -371,210 +212,6 @@ func request_SwapClient_GetLsatTokens_0(ctx context.Context, marshaler runtime.M
}
func local_request_SwapClient_GetLsatTokens_0(ctx context.Context, marshaler runtime.Marshaler, server SwapClientServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq TokensRequest
var metadata runtime.ServerMetadata
msg, err := server.GetLsatTokens(ctx, &protoReq)
return msg, metadata, err
}
// RegisterSwapClientHandlerServer registers the http handlers for service SwapClient to "mux".
// UnaryRPC :call SwapClientServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
func RegisterSwapClientHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SwapClientServer) error {
mux.Handle("POST", pattern_SwapClient_LoopOut_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_LoopOut_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_LoopOut_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_SwapClient_LoopIn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_LoopIn_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_LoopIn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_SwapClient_Monitor_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
})
mux.Handle("GET", pattern_SwapClient_ListSwaps_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_ListSwaps_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_ListSwaps_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_SwapClient_SwapInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_SwapInfo_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_SwapInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_SwapClient_LoopOutTerms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_LoopOutTerms_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_LoopOutTerms_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_SwapClient_LoopOutQuote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_LoopOutQuote_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_LoopOutQuote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_SwapClient_GetLoopInTerms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_GetLoopInTerms_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_GetLoopInTerms_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_SwapClient_GetLoopInQuote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_GetLoopInQuote_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_GetLoopInQuote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_SwapClient_GetLsatTokens_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_SwapClient_GetLsatTokens_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_SwapClient_GetLsatTokens_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
// RegisterSwapClientHandlerFromEndpoint is same as RegisterSwapClientHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterSwapClientHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
@ -817,25 +454,25 @@ func RegisterSwapClientHandlerClient(ctx context.Context, mux *runtime.ServeMux,
}
var (
pattern_SwapClient_LoopOut_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "out"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_LoopOut_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "out"}, ""))
pattern_SwapClient_LoopIn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "in"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_LoopIn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "in"}, ""))
pattern_SwapClient_Monitor_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "monitor"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_Monitor_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "monitor"}, ""))
pattern_SwapClient_ListSwaps_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "swaps"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_ListSwaps_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "swaps"}, ""))
pattern_SwapClient_SwapInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "loop", "swap", "id"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_SwapInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "loop", "swap", "id"}, ""))
pattern_SwapClient_LoopOutTerms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "loop", "out", "terms"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_LoopOutTerms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "loop", "out", "terms"}, ""))
pattern_SwapClient_LoopOutQuote_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "loop", "out", "quote", "amt"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_LoopOutQuote_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "loop", "out", "quote", "amt"}, ""))
pattern_SwapClient_GetLoopInTerms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "loop", "in", "terms"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_GetLoopInTerms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "loop", "in", "terms"}, ""))
pattern_SwapClient_GetLoopInQuote_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "loop", "in", "quote", "amt"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_GetLoopInQuote_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "loop", "in", "quote", "amt"}, ""))
pattern_SwapClient_GetLsatTokens_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "lsat", "tokens"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_SwapClient_GetLsatTokens_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "lsat", "tokens"}, ""))
)
var (

+ 3
- 5
looprpc/client.proto View File

@ -213,12 +213,10 @@ message LoopInRequest {
int64 max_miner_fee = 3;
/**
The channel to loop in. If zero, the channel to loop in is selected based
on the lowest routing fee for the swap payment from the server.
Note: NOT YET IMPLEMENTED
The last hop to use for the loop in swap. If empty, the last hop is selected
based on the lowest routing fee for the swap payment from the server.
*/
uint64 loop_in_channel = 4;
bytes last_hop = 4;
/**
If external_htlc is true, we expect the htlc to be published by an external

+ 22
- 13
looprpc/client.swagger.json View File

@ -4,6 +4,10 @@
"title": "client.proto",
"version": "version not set"
},
"schemes": [
"http",
"https"
],
"consumes": [
"application/json"
],
@ -114,16 +118,7 @@
"200": {
"description": "A successful response.(streaming responses)",
"schema": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/looprpcSwapStatus"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of looprpcSwapStatus"
"$ref": "#/x-stream-definitions/looprpcSwapStatus"
}
}
},
@ -320,10 +315,10 @@
"format": "int64",
"description": "*\nMaximum in on-chain fees that we are willing to spent. If we want to\npublish the on-chain htlc and the fee estimate turns out higher than this\nvalue, we cancel the swap. \n\nmax_miner_fee is typically taken from the response of the GetQuote call."
},
"loop_in_channel": {
"last_hop": {
"type": "string",
"format": "uint64",
"description": "*\nThe channel to loop in. If zero, the channel to loop in is selected based\non the lowest routing fee for the swap payment from the server.\n\nNote: NOT YET IMPLEMENTED"
"format": "byte",
"description": "*\nThe last hop to use for the loop in swap. If empty, the last hop is selected\nbased on the lowest routing fee for the swap payment from the server."
},
"external_htlc": {
"type": "boolean",
@ -620,5 +615,19 @@
}
}
}
},
"x-stream-definitions": {
"looprpcSwapStatus": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/looprpcSwapStatus"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of looprpcSwapStatus"
}
}
}

Loading…
Cancel
Save