GlcoinCore/pool
1
0
Fork 0
mirror of https://github.com/lightninglabs/pool.git synced 2026-08-13 12:33:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

multi: move auctioneer proto to auctioneerrpc package

Browse source 
As a preparation to extract the auctioneer proto package into its own
sub-module, we move it out of the poolrpc package.
This commit is contained in:
Oliver Gugger 2021-01-22 10:28:02 +01:00
parent ae21a944c6
commit 83b458b504
No known key found for this signature in database
GPG key ID: 8E4256593F177720
27 changed files with 793 additions and 738 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Makefile
View file

@ -145,10 +145,12 @@ list:
rpc:
@$(call print, "Compiling protos.")
cd ./poolrpc; ./gen_protos.sh
cd ./auctioneerrpc; ./gen_protos.sh
rpc-format:
@$(call print, "Formatting protos.")
cd ./poolrpc; find . -name "*.proto" | xargs clang-format --style=file -i
cd ./auctioneerrpc; find . -name "*.proto" | xargs clang-format --style=file -i
clean:
@$(call print, "Cleaning source.$(NC)")

20
auctioneer/account_subscription.go
View file

@ -7,8 +7,8 @@ import (
"github.com/lightninglabs/lndclient"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/order"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightningnetwork/lnd/keychain"
)
@ -18,9 +18,9 @@ import (
type acctSubscription struct {
acctKey *keychain.KeyDescriptor
commitHash [32]byte
sendMsg func(*poolrpc.ClientAuctionMessage) error
sendMsg func(*auctioneerrpc.ClientAuctionMessage) error
signer lndclient.SignerClient
msgChan chan *poolrpc.ServerAuctionMessage
msgChan chan *auctioneerrpc.ServerAuctionMessage
errChan chan error
quit chan struct{}
}
@ -46,9 +46,9 @@ func (s *acctSubscription) authenticate(ctx context.Context) error {
// a challenge back. We need to track the subscription from now on so
// the goroutine reading the incoming messages knows which subscription
// to add the received challenge to.
err = s.sendMsg(&poolrpc.ClientAuctionMessage{
Msg: &poolrpc.ClientAuctionMessage_Commit{
Commit: &poolrpc.AccountCommitment{
err = s.sendMsg(&auctioneerrpc.ClientAuctionMessage{
Msg: &auctioneerrpc.ClientAuctionMessage_Commit{
Commit: &auctioneerrpc.AccountCommitment{
CommitHash: s.commitHash[:],
BatchVersion: uint32(order.CurrentBatchVersion),
},
@ -67,7 +67,7 @@ func (s *acctSubscription) authenticate(ctx context.Context) error {
"was received")
}
msg, ok := srvMsg.Msg.(*poolrpc.ServerAuctionMessage_Challenge)
msg, ok := srvMsg.Msg.(*auctioneerrpc.ServerAuctionMessage_Challenge)
if !ok {
return fmt.Errorf("unexpected server message in auth "+
"process: %v", msg)
@ -85,9 +85,9 @@ func (s *acctSubscription) authenticate(ctx context.Context) error {
if err != nil {
return err
}
return s.sendMsg(&poolrpc.ClientAuctionMessage{
Msg: &poolrpc.ClientAuctionMessage_Subscribe{
Subscribe: &poolrpc.AccountSubscription{
return s.sendMsg(&auctioneerrpc.ClientAuctionMessage{
Msg: &auctioneerrpc.ClientAuctionMessage_Subscribe{
Subscribe: &auctioneerrpc.AccountSubscription{
TraderKey: acctPubKey[:],
CommitNonce: nonce[:],
AuthSig: sig,

42
auctioneer/account_subscription_test.go
View file

@ -10,8 +10,8 @@ import (
"time"
"github.com/btcsuite/btcd/btcec"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/internal/test"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightningnetwork/lnd/keychain"
)
@ -32,10 +32,10 @@ var (
// handshake is performed correctly when subscribing for account updates.
func TestAccountSubscriptionAuthenticate(t *testing.T) {
var (
msgChan = make(chan *poolrpc.ClientAuctionMessage)
srvMsgChan = make(chan *poolrpc.ServerAuctionMessage)
msgChan = make(chan *auctioneerrpc.ClientAuctionMessage)
srvMsgChan = make(chan *auctioneerrpc.ServerAuctionMessage)
errChan = make(chan error)
sendMsg = func(msg *poolrpc.ClientAuctionMessage) error {
sendMsg = func(msg *auctioneerrpc.ClientAuctionMessage) error {
msgChan <- msg
return nil
}
@ -56,7 +56,7 @@ func TestAccountSubscriptionAuthenticate(t *testing.T) {
// Step 1: We expect a commitment message.
select {
case msg := <-msgChan:
if _, ok := msg.Msg.(*poolrpc.ClientAuctionMessage_Commit); !ok {
if _, ok := msg.Msg.(*auctioneerrpc.ClientAuctionMessage_Commit); !ok {
t.Fatalf("unexpected message type: %v", msg)
}
@ -65,9 +65,9 @@ func TestAccountSubscriptionAuthenticate(t *testing.T) {
}
// Step 2: Simulate the server sending back the challenge.
srvMsgChan <- &poolrpc.ServerAuctionMessage{
Msg: &poolrpc.ServerAuctionMessage_Challenge{
Challenge: &poolrpc.ServerChallenge{
srvMsgChan <- &auctioneerrpc.ServerAuctionMessage{
Msg: &auctioneerrpc.ServerAuctionMessage_Challenge{
Challenge: &auctioneerrpc.ServerChallenge{
Challenge: []byte{11, 99, 11},
},
},
@ -76,7 +76,7 @@ func TestAccountSubscriptionAuthenticate(t *testing.T) {
// Step 3: We expect the final message, the subscription.
select {
case msg := <-msgChan:
subMsg, ok := msg.Msg.(*poolrpc.ClientAuctionMessage_Subscribe)
subMsg, ok := msg.Msg.(*auctioneerrpc.ClientAuctionMessage_Subscribe)
if !ok {
t.Fatalf("unexpected message type: %v", msg)
}
@ -94,10 +94,10 @@ func TestAccountSubscriptionAuthenticate(t *testing.T) {
// handshake is canceled if the channel is closed prematurely.
func TestAccountSubscriptionAuthenticateAbort(t *testing.T) {
var (
msgChan = make(chan *poolrpc.ClientAuctionMessage)
srvMsgChan = make(chan *poolrpc.ServerAuctionMessage)
msgChan = make(chan *auctioneerrpc.ClientAuctionMessage)
srvMsgChan = make(chan *auctioneerrpc.ServerAuctionMessage)
errChan = make(chan error)
sendMsg = func(msg *poolrpc.ClientAuctionMessage) error {
sendMsg = func(msg *auctioneerrpc.ClientAuctionMessage) error {
msgChan <- msg
return nil
}
@ -118,7 +118,7 @@ func TestAccountSubscriptionAuthenticateAbort(t *testing.T) {
// Step 1: We expect a commitment message.
select {
case msg := <-msgChan:
if _, ok := msg.Msg.(*poolrpc.ClientAuctionMessage_Commit); !ok {
if _, ok := msg.Msg.(*auctioneerrpc.ClientAuctionMessage_Commit); !ok {
t.Fatalf("unexpected message type: %v", msg)
}
@ -146,10 +146,10 @@ func TestAccountSubscriptionAuthenticateAbort(t *testing.T) {
// authentication handshake is canceled if the context is canceled prematurely.
func TestAccountSubscriptionAuthenticateContextClose(t *testing.T) {
var (
msgChan = make(chan *poolrpc.ClientAuctionMessage)
srvMsgChan = make(chan *poolrpc.ServerAuctionMessage)
msgChan = make(chan *auctioneerrpc.ClientAuctionMessage)
srvMsgChan = make(chan *auctioneerrpc.ServerAuctionMessage)
errChan = make(chan error)
sendMsg = func(msg *poolrpc.ClientAuctionMessage) error {
sendMsg = func(msg *auctioneerrpc.ClientAuctionMessage) error {
msgChan <- msg
return nil
}
@ -171,7 +171,7 @@ func TestAccountSubscriptionAuthenticateContextClose(t *testing.T) {
// Step 1: We expect a commitment message.
select {
case msg := <-msgChan:
if _, ok := msg.Msg.(*poolrpc.ClientAuctionMessage_Commit); !ok {
if _, ok := msg.Msg.(*auctioneerrpc.ClientAuctionMessage_Commit); !ok {
t.Fatalf("unexpected message type: %v", msg)
}
@ -200,10 +200,10 @@ func TestAccountSubscriptionAuthenticateContextClose(t *testing.T) {
// in the last step.
func TestAccountSubscriptionAuthenticateError(t *testing.T) {
var (
msgChan = make(chan *poolrpc.ClientAuctionMessage)
srvMsgChan = make(chan *poolrpc.ServerAuctionMessage)
msgChan = make(chan *auctioneerrpc.ClientAuctionMessage)
srvMsgChan = make(chan *auctioneerrpc.ServerAuctionMessage)
errChan = make(chan error)
sendMsg = func(msg *poolrpc.ClientAuctionMessage) error {
sendMsg = func(msg *auctioneerrpc.ClientAuctionMessage) error {
msgChan <- msg
return nil
}
@ -225,7 +225,7 @@ func TestAccountSubscriptionAuthenticateError(t *testing.T) {
// Step 1: We expect a commitment message.
select {
case msg := <-msgChan:
if _, ok := msg.Msg.(*poolrpc.ClientAuctionMessage_Commit); !ok {
if _, ok := msg.Msg.(*auctioneerrpc.ClientAuctionMessage_Commit); !ok {
t.Fatalf("unexpected message type: %v", msg)
}

4
auctioneer/batch.go
View file

@ -9,9 +9,9 @@ import (
"github.com/btcsuite/btcd/wire"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/clientdb"
"github.com/lightninglabs/pool/order"
"github.com/lightninglabs/pool/poolrpc"
)
var (
@ -89,7 +89,7 @@ func (c *Client) checkPendingBatch() error {
func (c *Client) finalizedBatchTx(
snapshot *clientdb.LocalBatchSnapshot) (*wire.MsgTx, error) {
req := &poolrpc.BatchSnapshotRequest{BatchId: snapshot.BatchID[:]}
req := &auctioneerrpc.BatchSnapshotRequest{BatchId: snapshot.BatchID[:]}
batch, err := c.client.BatchSnapshot(context.Background(), req)
if err != nil {
return nil, fmt.Errorf("querying relevant batch snapshot "+

174
auctioneer/client.go
View file

@ -17,6 +17,7 @@ import (
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/lndclient"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/order"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/terms"
@ -104,14 +105,14 @@ type Client struct {
StreamErrChan chan error
errChanSwitch *ErrChanSwitch
FromServerChan chan *poolrpc.ServerAuctionMessage
FromServerChan chan *auctioneerrpc.ServerAuctionMessage
serverConn *grpc.ClientConn
client poolrpc.ChannelAuctioneerClient
client auctioneerrpc.ChannelAuctioneerClient
quit chan struct{}
wg sync.WaitGroup
serverStream poolrpc.ChannelAuctioneer_SubscribeBatchAuctionClient
serverStream auctioneerrpc.ChannelAuctioneer_SubscribeBatchAuctionClient
streamMutex sync.Mutex
streamCancel func()
subscribedAccts map[[33]byte]*acctSubscription
@ -131,7 +132,7 @@ func NewClient(cfg *Config) (*Client, error) {
errChanSwitch := NewErrChanSwitch(mainErrChan)
return &Client{
cfg: cfg,
FromServerChan: make(chan *poolrpc.ServerAuctionMessage),
FromServerChan: make(chan *auctioneerrpc.ServerAuctionMessage),
StreamErrChan: mainErrChan,
errChanSwitch: errChanSwitch,
quit: make(chan struct{}),
@ -152,7 +153,7 @@ func (c *Client) Start() error {
}
c.serverConn = serverConn
c.client = poolrpc.NewChannelAuctioneerClient(serverConn)
c.client = auctioneerrpc.NewChannelAuctioneerClient(serverConn)
c.errChanSwitch.Start()
@ -238,11 +239,13 @@ func (c *Client) ReserveAccount(ctx context.Context, value btcutil.Amount,
expiry uint32, traderKey *btcec.PublicKey) (*account.Reservation,
error) {
resp, err := c.client.ReserveAccount(ctx, &poolrpc.ReserveAccountRequest{
AccountValue: uint64(value),
TraderKey: traderKey.SerializeCompressed(),
AccountExpiry: expiry,
})
resp, err := c.client.ReserveAccount(
ctx, &auctioneerrpc.ReserveAccountRequest{
AccountValue: uint64(value),
TraderKey: traderKey.SerializeCompressed(),
AccountExpiry: expiry,
},
)
if err != nil {
return nil, err
}
@ -274,16 +277,18 @@ func (c *Client) InitAccount(ctx context.Context, account *account.Account) erro
return fmt.Errorf("unable to construct account output: %v", err)
}
_, err = c.client.InitAccount(ctx, &poolrpc.ServerInitAccountRequest{
AccountPoint: &poolrpc.OutPoint{
Txid: account.OutPoint.Hash[:],
OutputIndex: account.OutPoint.Index,
_, err = c.client.InitAccount(
ctx, &auctioneerrpc.ServerInitAccountRequest{
AccountPoint: &auctioneerrpc.OutPoint{
Txid: account.OutPoint.Hash[:],
OutputIndex: account.OutPoint.Index,
},
AccountScript: accountOutput.PkScript,
AccountValue: uint64(account.Value),
AccountExpiry: account.Expiry,
TraderKey: account.TraderKey.PubKey.SerializeCompressed(),
},
AccountScript: accountOutput.PkScript,
AccountValue: uint64(account.Value),
AccountExpiry: account.Expiry,
TraderKey: account.TraderKey.PubKey.SerializeCompressed(),
})
)
return err
}
@ -299,11 +304,11 @@ func (c *Client) ModifyAccount(ctx context.Context, account *account.Account,
inputs []*wire.TxIn, outputs []*wire.TxOut,
modifiers []account.Modifier) ([]byte, error) {
rpcInputs := make([]*poolrpc.ServerInput, 0, len(inputs))
rpcInputs := make([]*auctioneerrpc.ServerInput, 0, len(inputs))
for _, input := range inputs {
op := input.PreviousOutPoint
rpcInputs = append(rpcInputs, &poolrpc.ServerInput{
Outpoint: &poolrpc.OutPoint{
rpcInputs = append(rpcInputs, &auctioneerrpc.ServerInput{
Outpoint: &auctioneerrpc.OutPoint{
Txid: op.Hash[:],
OutputIndex: op.Index,
},
@ -311,29 +316,31 @@ func (c *Client) ModifyAccount(ctx context.Context, account *account.Account,
})
}
rpcOutputs := make([]*poolrpc.ServerOutput, 0, len(outputs))
rpcOutputs := make([]*auctioneerrpc.ServerOutput, 0, len(outputs))
for _, output := range outputs {
rpcOutputs = append(rpcOutputs, &poolrpc.ServerOutput{
rpcOutputs = append(rpcOutputs, &auctioneerrpc.ServerOutput{
Value: uint64(output.Value),
Script: output.PkScript,
})
}
var rpcNewParams *poolrpc.ServerModifyAccountRequest_NewAccountParameters
var rpcNewParams *auctioneerrpc.ServerModifyAccountRequest_NewAccountParameters
modifiedAccount := account.Copy(modifiers...)
if len(modifiers) > 0 {
rpcNewParams = &poolrpc.ServerModifyAccountRequest_NewAccountParameters{
rpcNewParams = &auctioneerrpc.ServerModifyAccountRequest_NewAccountParameters{
Value: uint64(modifiedAccount.Value),
Expiry: modifiedAccount.Expiry,
}
}
resp, err := c.client.ModifyAccount(ctx, &poolrpc.ServerModifyAccountRequest{
TraderKey: account.TraderKey.PubKey.SerializeCompressed(),
NewInputs: rpcInputs,
NewOutputs: rpcOutputs,
NewParams: rpcNewParams,
})
resp, err := c.client.ModifyAccount(
ctx, &auctioneerrpc.ServerModifyAccountRequest{
TraderKey: account.TraderKey.PubKey.SerializeCompressed(),
NewInputs: rpcInputs,
NewOutputs: rpcOutputs,
NewParams: rpcNewParams,
},
)
if err != nil {
return nil, err
}
@ -348,15 +355,15 @@ func (c *Client) SubmitOrder(ctx context.Context, o order.Order,
// Prepare everything that is common to both ask and bid orders.
nonce := o.Nonce()
rpcRequest := &poolrpc.ServerSubmitOrderRequest{}
nodeAddrs := make([]*poolrpc.NodeAddress, 0, len(serverParams.Addrs))
rpcRequest := &auctioneerrpc.ServerSubmitOrderRequest{}
nodeAddrs := make([]*auctioneerrpc.NodeAddress, 0, len(serverParams.Addrs))
for _, addr := range serverParams.Addrs {
nodeAddrs = append(nodeAddrs, &poolrpc.NodeAddress{
nodeAddrs = append(nodeAddrs, &auctioneerrpc.NodeAddress{
Network: addr.Network(),
Addr: addr.String(),
})
}
details := &poolrpc.ServerOrder{
details := &auctioneerrpc.ServerOrder{
TraderKey: o.Details().AcctKey[:],
RateFixed: o.Details().FixedRate,
Amt: uint64(o.Details().Amt),
@ -372,12 +379,12 @@ func (c *Client) SubmitOrder(ctx context.Context, o order.Order,
// Split into server message which is type specific.
switch castOrder := o.(type) {
case *order.Ask:
serverAsk := &poolrpc.ServerAsk{
serverAsk := &auctioneerrpc.ServerAsk{
Details: details,
LeaseDurationBlocks: castOrder.LeaseDuration,
Version: uint32(castOrder.Version),
}
rpcRequest.Details = &poolrpc.ServerSubmitOrderRequest_Ask{
rpcRequest.Details = &auctioneerrpc.ServerSubmitOrderRequest_Ask{
Ask: serverAsk,
}
@ -387,13 +394,13 @@ func (c *Client) SubmitOrder(ctx context.Context, o order.Order,
return err
}
serverBid := &poolrpc.ServerBid{
serverBid := &auctioneerrpc.ServerBid{
Details: details,
LeaseDurationBlocks: castOrder.LeaseDuration,
Version: uint32(castOrder.Version),
MinNodeTier: nodeTierEnum,
}
rpcRequest.Details = &poolrpc.ServerSubmitOrderRequest_Bid{
rpcRequest.Details = &auctioneerrpc.ServerSubmitOrderRequest_Bid{
Bid: serverBid,
}
@ -407,13 +414,13 @@ func (c *Client) SubmitOrder(ctx context.Context, o order.Order,
return err
}
switch submitResp := resp.Details.(type) {
case *poolrpc.ServerSubmitOrderResponse_InvalidOrder:
case *auctioneerrpc.ServerSubmitOrderResponse_InvalidOrder:
return &order.UserError{
FailMsg: submitResp.InvalidOrder.FailString,
Details: submitResp.InvalidOrder,
}
case *poolrpc.ServerSubmitOrderResponse_Accepted:
case *auctioneerrpc.ServerSubmitOrderResponse_Accepted:
return nil
default:
@ -423,9 +430,11 @@ func (c *Client) SubmitOrder(ctx context.Context, o order.Order,
// CancelOrder sends an order cancellation message to the server.
func (c *Client) CancelOrder(ctx context.Context, noncePreimage lntypes.Preimage) error {
_, err := c.client.CancelOrder(ctx, &poolrpc.ServerCancelOrderRequest{
OrderNoncePreimage: noncePreimage[:],
})
_, err := c.client.CancelOrder(
ctx, &auctioneerrpc.ServerCancelOrderRequest{
OrderNoncePreimage: noncePreimage[:],
},
)
return err
}
@ -433,9 +442,9 @@ func (c *Client) CancelOrder(ctx context.Context, noncePreimage lntypes.Preimage
// state as it's currently known to the server's database. For real-time updates
// on the state, the SubscribeBatchAuction stream should be used.
func (c *Client) OrderState(ctx context.Context, nonce order.Nonce) (
*poolrpc.ServerOrderStateResponse, error) {
*auctioneerrpc.ServerOrderStateResponse, error) {
return c.client.OrderState(ctx, &poolrpc.ServerOrderStateRequest{
return c.client.OrderState(ctx, &auctioneerrpc.ServerOrderStateRequest{
OrderNonce: nonce[:],
})
}
@ -510,7 +519,7 @@ func (c *Client) connectAndAuthenticate(ctx context.Context,
acctKey: acctKey,
sendMsg: c.SendAuctionMessage,
signer: c.cfg.Signer,
msgChan: make(chan *poolrpc.ServerAuctionMessage),
msgChan: make(chan *auctioneerrpc.ServerAuctionMessage),
errChan: tempErrChan,
quit: make(chan struct{}),
}
@ -554,7 +563,7 @@ func (c *Client) connectAndAuthenticate(ctx context.Context,
// normal recovery in that case because the account
// subscription cannot be completed. This needs to be
// handled specifically so we return a typed error now.
if errMsg.ErrorCode == poolrpc.SubscribeError_INCOMPLETE_ACCOUNT_RESERVATION {
if errMsg.ErrorCode == auctioneerrpc.SubscribeError_INCOMPLETE_ACCOUNT_RESERVATION {
return sub, true, AcctResNotCompletedErrFromRPC(
*errMsg.AccountReservation,
)
@ -563,7 +572,7 @@ func (c *Client) connectAndAuthenticate(ctx context.Context,
// The account doesn't exist. We are in recovery mode so
// this is fine. We just skip this account key and try
// the next one.
if errMsg.ErrorCode == poolrpc.SubscribeError_ACCOUNT_DOES_NOT_EXIST {
if errMsg.ErrorCode == auctioneerrpc.SubscribeError_ACCOUNT_DOES_NOT_EXIST {
return sub, false, nil
}
@ -657,9 +666,9 @@ func (c *Client) RecoverAccounts(ctx context.Context,
// its database. The response to this message will be handled
// outside of the client.
numNotFoundAccounts = 0
err = c.SendAuctionMessage(&poolrpc.ClientAuctionMessage{
Msg: &poolrpc.ClientAuctionMessage_Recover{
Recover: &poolrpc.AccountRecovery{
err = c.SendAuctionMessage(&auctioneerrpc.ClientAuctionMessage{
Msg: &auctioneerrpc.ClientAuctionMessage_Recover{
Recover: &auctioneerrpc.AccountRecovery{
TraderKey: acctKeyBytes,
},
},
@ -672,7 +681,7 @@ func (c *Client) RecoverAccounts(ctx context.Context,
// Now we wait for the server to send us the account to recover.
select {
case msg := <-subscription.msgChan:
acctMsg, ok := msg.Msg.(*poolrpc.ServerAuctionMessage_Account)
acctMsg, ok := msg.Msg.(*auctioneerrpc.ServerAuctionMessage_Account)
if !ok {
return nil, fmt.Errorf("received unexpected "+
"recovery message from server: %v",
@ -752,7 +761,7 @@ func incompleteAcctFromErr(traderKey *keychain.KeyDescriptor,
// SendAuctionMessage sends an auction message through the long-lived stream to
// the auction server. A message can only be sent as a response to a server
// message, therefore the stream must already be open.
func (c *Client) SendAuctionMessage(msg *poolrpc.ClientAuctionMessage) error {
func (c *Client) SendAuctionMessage(msg *auctioneerrpc.ClientAuctionMessage) error {
if c.serverStream == nil {
return fmt.Errorf("cannot send message, stream not open")
}
@ -794,7 +803,7 @@ func (c *Client) connectServerStream(initialBackoff time.Duration,
// Try connecting by querying a "cheap" RPC that the server can
// answer from memory only.
_, err = c.client.Terms(ctxb, &poolrpc.TermsRequest{})
_, err = c.client.Terms(ctxb, &auctioneerrpc.TermsRequest{})
if err == nil {
log.Debugf("Connected successfully to server after "+
"%d tries", i+1)
@ -904,7 +913,7 @@ func (c *Client) readIncomingStream() { // nolint:gocyclo
switch t := msg.Msg.(type) {
// The server sends us the challenge that we need to complete
// the 3-way handshake.
case *poolrpc.ServerAuctionMessage_Challenge:
case *auctioneerrpc.ServerAuctionMessage_Challenge:
// Try to find the subscription this message is for so
// we can send it over the correct chan.
var commitHash [32]byte
@ -931,7 +940,7 @@ func (c *Client) readIncomingStream() { // nolint:gocyclo
// The server confirms the account subscription. We only really
// care about this response in the recovery case because it
// means we can recover this account.
case *poolrpc.ServerAuctionMessage_Success:
case *auctioneerrpc.ServerAuctionMessage_Success:
err := c.sendToSubscription(t.Success.TraderKey, msg)
if err != nil {
c.errChanSwitch.ErrChan() <- err
@ -941,7 +950,7 @@ func (c *Client) readIncomingStream() { // nolint:gocyclo
// We've requested to recover an account and the auctioneer now
// sent us their state of the account. We'll try to restore it
// in our database.
case *poolrpc.ServerAuctionMessage_Account:
case *auctioneerrpc.ServerAuctionMessage_Account:
err := c.sendToSubscription(t.Account.TraderKey, msg)
if err != nil {
c.errChanSwitch.ErrChan() <- err
@ -951,13 +960,13 @@ func (c *Client) readIncomingStream() { // nolint:gocyclo
// The shutdown message and the account not found error are sent
// as general error messages. We only handle these two specific
// cases here, the rest is forwarded to the handler.
case *poolrpc.ServerAuctionMessage_Error:
case *auctioneerrpc.ServerAuctionMessage_Error:
errCode := t.Error.ErrorCode
switch errCode {
// The server is shutting down. No need to forward this,
// we can just shutdown the stream and try to reconnect.
case poolrpc.SubscribeError_SERVER_SHUTDOWN:
case auctioneerrpc.SubscribeError_SERVER_SHUTDOWN:
err := c.HandleServerShutdown(nil)
if err != nil {
select {
@ -970,8 +979,8 @@ func (c *Client) readIncomingStream() { // nolint:gocyclo
// We received an account not found error. This is not
// a reason to abort in case we are in recovery mode.
// We let the subscription decide what to do.
case poolrpc.SubscribeError_ACCOUNT_DOES_NOT_EXIST,
poolrpc.SubscribeError_INCOMPLETE_ACCOUNT_RESERVATION:
case auctioneerrpc.SubscribeError_ACCOUNT_DOES_NOT_EXIST,
auctioneerrpc.SubscribeError_INCOMPLETE_ACCOUNT_RESERVATION:
err := c.sendToSubscription(
t.Error.TraderKey, msg,
@ -1005,7 +1014,7 @@ func (c *Client) readIncomingStream() { // nolint:gocyclo
// sendToSubscription finds the subscription for a trader's account public key
// and forwards the given message to it.
func (c *Client) sendToSubscription(traderAccountKey []byte,
msg *poolrpc.ServerAuctionMessage) error {
msg *auctioneerrpc.ServerAuctionMessage) error {
// Try to find the subscription this message is for so we can send it
// over the correct chan. If the key isn't a valid pubkey we'll just not
@ -1080,7 +1089,7 @@ func (c *Client) HandleServerShutdown(err error) error {
// unmarshallServerAccount parses the account information sent from the
// auctioneer into our local account struct.
func unmarshallServerRecoveredAccount(keyDesc *keychain.KeyDescriptor,
a *poolrpc.AuctionAccount) (*account.Account, error) {
a *auctioneerrpc.AuctionAccount) (*account.Account, error) {
// Parse all raw public keys.
auctioneerKey, err := btcec.ParsePubKey(a.AuctioneerKey, btcec.S256())
@ -1100,25 +1109,25 @@ func unmarshallServerRecoveredAccount(keyDesc *keychain.KeyDescriptor,
// side.
state := account.StateClosed
switch a.State {
case poolrpc.AuctionAccountState_STATE_OPEN,
poolrpc.AuctionAccountState_STATE_PENDING_OPEN:
case auctioneerrpc.AuctionAccountState_STATE_OPEN,
auctioneerrpc.AuctionAccountState_STATE_PENDING_OPEN:
state = account.StateInitiated
case poolrpc.AuctionAccountState_STATE_CLOSED:
case auctioneerrpc.AuctionAccountState_STATE_CLOSED:
// The auctioneer will keep the state as STATE_OPEN until the
// closing TX confirms on chain. Therefore if we get the
// STATE_CLOSED here it's already confirmed and we don't need to
// watch anything or try to re-publish the closing TX.
state = account.StateClosed
case poolrpc.AuctionAccountState_STATE_PENDING_UPDATE:
case auctioneerrpc.AuctionAccountState_STATE_PENDING_UPDATE:
state = account.StatePendingUpdate
case poolrpc.AuctionAccountState_STATE_PENDING_BATCH:
case auctioneerrpc.AuctionAccountState_STATE_PENDING_BATCH:
state = account.StatePendingBatch
case poolrpc.AuctionAccountState_STATE_EXPIRED:
case auctioneerrpc.AuctionAccountState_STATE_EXPIRED:
state = account.StateExpired
}
@ -1134,7 +1143,7 @@ func unmarshallServerRecoveredAccount(keyDesc *keychain.KeyDescriptor,
// The latest transaction is only known to the auctioneer after it's
// been confirmed.
var latestTx *wire.MsgTx
if a.State != poolrpc.AuctionAccountState_STATE_PENDING_OPEN {
if a.State != auctioneerrpc.AuctionAccountState_STATE_PENDING_OPEN {
latestTx = &wire.MsgTx{}
err := latestTx.Deserialize(bytes.NewReader(a.LatestTx))
if err != nil {
@ -1161,7 +1170,7 @@ func unmarshallServerRecoveredAccount(keyDesc *keychain.KeyDescriptor,
// Terms returns the current dynamic auctioneer terms like max account size, max
// order duration in blocks and the auction fee schedule.
func (c *Client) Terms(ctx context.Context) (*terms.AuctioneerTerms, error) {
resp, err := c.client.Terms(ctx, &poolrpc.TermsRequest{})
resp, err := c.client.Terms(ctx, &auctioneerrpc.TermsRequest{})
if err != nil {
return nil, err
}
@ -1183,9 +1192,10 @@ func (c *Client) Terms(ctx context.Context) (*terms.AuctioneerTerms, error) {
// NOTE: This isn't wrapped in "native" types, as atm we only use this to
// shuffle information back to the client over our RPC interface.
func (c *Client) BatchSnapshot(ctx context.Context,
targetBatch order.BatchID) (*poolrpc.BatchSnapshotResponse, error) {
targetBatch order.BatchID) (*auctioneerrpc.BatchSnapshotResponse,
error) {
return c.client.BatchSnapshot(ctx, &poolrpc.BatchSnapshotRequest{
return c.client.BatchSnapshot(ctx, &auctioneerrpc.BatchSnapshotRequest{
BatchId: targetBatch[:],
})
}
@ -1199,8 +1209,8 @@ func (c *Client) BatchSnapshot(ctx context.Context,
// NOTE: This isn't wrapped in "native" types, as atm we only use this to
// shuffle information back to the client over our RPC interface.
func (c *Client) BatchSnapshots(ctx context.Context,
req *poolrpc.BatchSnapshotsRequest) (*poolrpc.BatchSnapshotsResponse,
error) {
req *auctioneerrpc.BatchSnapshotsRequest) (
*auctioneerrpc.BatchSnapshotsResponse, error) {
return c.client.BatchSnapshots(ctx, req)
}
@ -1215,7 +1225,7 @@ func (c *Client) NodeRating(ctx context.Context,
pubKeys = append(pubKeys, nodeKey.SerializeCompressed())
}
req := &poolrpc.ServerNodeRatingRequest{
req := &auctioneerrpc.ServerNodeRatingRequest{
NodePubkeys: pubKeys,
}
serverResp, err := c.client.NodeRating(ctx, req)
@ -1230,16 +1240,16 @@ func (c *Client) NodeRating(ctx context.Context,
// MarshallNodeTier maps the node tier integer into the enum used on the RPC
// interface.
func MarshallNodeTier(nodeTier order.NodeTier) (poolrpc.NodeTier, error) {
func MarshallNodeTier(nodeTier order.NodeTier) (auctioneerrpc.NodeTier, error) {
switch nodeTier {
case order.NodeTierDefault:
return poolrpc.NodeTier_TIER_DEFAULT, nil
return auctioneerrpc.NodeTier_TIER_DEFAULT, nil
case order.NodeTier0:
return poolrpc.NodeTier_TIER_0, nil
return auctioneerrpc.NodeTier_TIER_0, nil
case order.NodeTier1:
return poolrpc.NodeTier_TIER_1, nil
return auctioneerrpc.NodeTier_TIER_1, nil
default:
return 0, fmt.Errorf("unknown node tier: %v", nodeTier)

4
auctioneer/errors.go
View file

@ -5,7 +5,7 @@ import (
"fmt"
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/auctioneerrpc"
)
var (
@ -60,7 +60,7 @@ func (e *AcctResNotCompletedError) Unwrap() error {
// AcctResNotCompletedErrFromRPC creates a new AcctResNotCompletedError from an
// RPC account message.
func AcctResNotCompletedErrFromRPC(
rpcAcc poolrpc.AuctionAccount) *AcctResNotCompletedError {
rpcAcc auctioneerrpc.AuctionAccount) *AcctResNotCompletedError {
result := &AcctResNotCompletedError{
Value: btcutil.Amount(rpcAcc.Value),

7
auctioneerrpc/.clang-format Normal file
View file

@ -0,0 +1,7 @@
---
Language: Proto
BasedOnStyle: Google
IndentWidth: 4
AllowShortFunctionsOnASingleLine: None
SpaceBeforeParens: Always
CompactNamespaces: false

517
poolrpc/auctioneer.pb.go → auctioneerrpc/auctioneer.pb.go
View file

@ -1,7 +1,12 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: auctioneer.proto
package poolrpc
// We can't rename this to auctioneerrpc, otherwise it would be a breaking
// change since the package name is also contained in the HTTP URIs and old
// clients would call the wrong endpoints. Luckily with the go_package option we
// can have different golang and RPC package names.
package auctioneerrpc
import (
context "context"
@ -4414,263 +4419,263 @@ func init() {
func init() { proto.RegisterFile("auctioneer.proto", fileDescriptor_f3883418d94ca37f) }
var fileDescriptor_f3883418d94ca37f = []byte{
// 4090 bytes of a gzipped FileDescriptorProto
// 4093 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3b, 0x4d, 0x73, 0xe3, 0xd8,
0x56, 0xf1, 0x47, 0x62, 0xfb, 0x58, 0x76, 0x94, 0xeb, 0x24, 0x9d, 0x78, 0x3a, 0x3d, 0xdd, 0x9a,
0x79, 0x43, 0x4f, 0x66, 0x3a, 0xd3, 0x93, 0x9e, 0xd7, 0xcc, 0x9b, 0xd7, 0x0c, 0xc8, 0xb6, 0xf2,
0xec, 0x69, 0xc7, 0xf6, 0xc8, 0x4e, 0xf7, 0xf4, 0x7b, 0x05, 0x2a, 0xd9, 0xbe, 0x76, 0x44, 0x6c,
0xc9, 0x48, 0x72, 0x77, 0xc2, 0xe2, 0x2d, 0xd8, 0xb1, 0x60, 0x49, 0x41, 0x15, 0xc5, 0x8e, 0x5f,
0x00, 0x1b, 0x96, 0x14, 0x0b, 0x58, 0xb1, 0x64, 0x45, 0x15, 0xb0, 0x60, 0x45, 0xb1, 0x60, 0xcb,
0x8e, 0xba, 0x1f, 0x92, 0x25, 0x59, 0x76, 0xf2, 0x98, 0xa1, 0x8a, 0x62, 0xd3, 0x6d, 0x9d, 0x8f,
0x7b, 0xcf, 0x39, 0xf7, 0x7c, 0xdc, 0x73, 0xa4, 0x80, 0xa8, 0xcf, 0x07, 0xae, 0x61, 0x99, 0x18,
0xdb, 0x27, 0x33, 0xdb, 0x72, 0x2d, 0x94, 0x99, 0x59, 0xd6, 0xc4, 0x9e, 0x0d, 0xa4, 0x3f, 0x48,
0xc0, 0x9e, 0x8a, 0x1d, 0x6c, 0xbf, 0xc5, 0xf2, 0x60, 0x60, 0xcd, 0x4d, 0x57, 0xc5, 0xbf, 0x37,
0xc7, 0x8e, 0x8b, 0x3e, 0x80, 0x82, 0xce, 0x20, 0xda, 0x5b, 0x7d, 0x32, 0xc7, 0x07, 0x89, 0x87,
0x89, 0xc7, 0x69, 0x55, 0xe0, 0xc0, 0x57, 0x04, 0x86, 0x7e, 0x04, 0x45, 0x8f, 0x08, 0x5f, 0xcf,
0x0c, 0xfb, 0xe6, 0x20, 0xf9, 0x30, 0xf1, 0xb8, 0xa0, 0x7a, 0xac, 0x0a, 0x05, 0xa2, 0x23, 0x00,
0xd7, 0xd6, 0x87, 0xd8, 0xd6, 0xae, 0xf0, 0xcd, 0x41, 0xea, 0x61, 0xe2, 0xb1, 0xa0, 0xe6, 0x18,
0xe4, 0x25, 0xbe, 0x91, 0xae, 0x60, 0x3f, 0x2a, 0x83, 0x33, 0xb3, 0x4c, 0x87, 0xad, 0xef, 0xcb,
0x4e, 0x99, 0x13, 0x94, 0xb9, 0xb0, 0x80, 0xbe, 0xc4, 0x37, 0xe8, 0x18, 0x76, 0x0c, 0xd3, 0x70,
0x0d, 0x7d, 0xa2, 0xf5, 0x75, 0x77, 0x70, 0x49, 0x29, 0x93, 0x94, 0x72, 0x9b, 0x23, 0x2a, 0x04,
0x4e, 0x36, 0xfb, 0xb7, 0x04, 0x1c, 0x74, 0xc9, 0x5e, 0x76, 0xc3, 0x34, 0xdc, 0x88, 0xd2, 0xcf,
0x17, 0x4a, 0xcf, 0x2c, 0xc3, 0x74, 0xe9, 0x76, 0xf9, 0xd3, 0x9d, 0x13, 0x6e, 0xaf, 0x93, 0xf6,
0xdc, 0xed, 0x10, 0x84, 0x6f, 0x07, 0xfa, 0x14, 0xb4, 0x83, 0x33, 0xb0, 0x8d, 0x99, 0xcb, 0x77,
0xf7, 0x56, 0xeb, 0x52, 0xe0, 0xb2, 0x4d, 0x53, 0x77, 0xb2, 0x69, 0xfa, 0x76, 0x9b, 0x6e, 0x46,
0x6d, 0xfa, 0x1e, 0x1c, 0xc6, 0x68, 0xc9, 0xcc, 0x2a, 0xcd, 0x3d, 0x13, 0x74, 0xe7, 0xfd, 0xa9,
0xe1, 0xb6, 0xed, 0x21, 0xb6, 0x3d, 0x13, 0x7c, 0x04, 0x29, 0xdd, 0xb9, 0xe2, 0x8a, 0x23, 0x5f,
0x71, 0x46, 0x2f, 0x3b, 0x57, 0xf5, 0x0d, 0x95, 0x10, 0x10, 0xba, 0xbe, 0x31, 0xa4, 0x7a, 0x2e,
0xd3, 0x55, 0x8c, 0x21, 0xa1, 0xeb, 0x1b, 0xc3, 0x4a, 0x0e, 0x32, 0x43, 0xec, 0xea, 0xc6, 0xc4,
0x21, 0xce, 0x76, 0x18, 0xb3, 0x2f, 0x3f, 0xeb, 0x17, 0x50, 0x30, 0xcc, 0xb7, 0xfa, 0xc4, 0x18,
0x6a, 0x16, 0x41, 0x70, 0x11, 0xf6, 0xfc, 0xa5, 0x1b, 0x0c, 0x4b, 0xb9, 0xea, 0x1b, 0xaa, 0x60,
0x04, 0x9e, 0xd1, 0x7d, 0xc8, 0xea, 0x83, 0x01, 0x9e, 0xb9, 0x98, 0xc9, 0x94, 0xad, 0x6f, 0xa8,
0x3e, 0x24, 0x28, 0x44, 0xd3, 0xd3, 0xbd, 0xaa, 0x9b, 0x03, 0x3c, 0x09, 0xe9, 0xfe, 0x14, 0x76,
0xe9, 0xd6, 0x9a, 0x69, 0x99, 0x03, 0xac, 0xcd, 0x6c, 0x6c, 0x4c, 0xf5, 0x31, 0xe6, 0x4e, 0x87,
0x28, 0xae, 0x45, 0x50, 0x1d, 0x8e, 0x59, 0x98, 0x39, 0xb4, 0x1a, 0x37, 0xf3, 0xbf, 0x26, 0x61,
0xb7, 0x3a, 0x31, 0xb0, 0xe9, 0xca, 0xcc, 0x5d, 0xcf, 0xb1, 0xe3, 0xe8, 0x63, 0x8c, 0xbe, 0x80,
0xad, 0x81, 0x35, 0x9d, 0x1a, 0x9e, 0x7f, 0x95, 0x7d, 0x1d, 0xf9, 0x49, 0x55, 0x29, 0x76, 0x8a,
0x4d, 0xb7, 0xbe, 0xa1, 0x72, 0x5a, 0xf4, 0x02, 0x72, 0xce, 0xbc, 0x4f, 0xfc, 0xab, 0x8f, 0xb9,
0xdd, 0xef, 0x47, 0x19, 0xbb, 0x8c, 0x60, 0x46, 0x76, 0xab, 0x6f, 0xa8, 0x0b, 0x06, 0xf4, 0x0c,
0xb6, 0x98, 0x39, 0xa8, 0xd3, 0xe5, 0x4f, 0x0f, 0x17, 0x3e, 0x4d, 0x84, 0x3e, 0x27, 0xf1, 0x21,
0x53, 0x02, 0xb2, 0x25, 0x23, 0x25, 0x4c, 0x36, 0xfe, 0x5d, 0x3c, 0x70, 0xa9, 0x0f, 0xc6, 0x33,
0xa9, 0x94, 0x80, 0x30, 0x31, 0x52, 0xf4, 0x04, 0xd2, 0x8e, 0x31, 0x36, 0xa9, 0x4f, 0xe6, 0x4f,
0xef, 0xc5, 0xb0, 0x74, 0x8d, 0x31, 0x91, 0x8e, 0x92, 0xa1, 0x2f, 0x20, 0x63, 0xe3, 0x81, 0xf5,
0x16, 0xdb, 0x07, 0x5b, 0x94, 0xe3, 0x20, 0xaa, 0x94, 0xca, 0xd0, 0x37, 0xf5, 0x0d, 0xd5, 0x23,
0xad, 0x6c, 0x42, 0x6a, 0xea, 0x8c, 0xa5, 0x37, 0xb0, 0xb3, 0x64, 0x32, 0xf4, 0x3e, 0xe4, 0x99,
0xc9, 0xb4, 0x4b, 0xdd, 0xb9, 0xe4, 0xa7, 0x07, 0x0c, 0x54, 0xd7, 0x9d, 0x4b, 0x12, 0x87, 0x2c,
0x4f, 0xbc, 0xc5, 0xb6, 0x63, 0x58, 0x26, 0xcf, 0x5a, 0x02, 0x05, 0xbe, 0x62, 0x30, 0xc9, 0x86,
0x52, 0x8c, 0x51, 0x23, 0x71, 0x97, 0x88, 0xc4, 0x1d, 0x7a, 0x04, 0x02, 0xdf, 0x9b, 0xfa, 0x10,
0xcf, 0x03, 0x5c, 0x1e, 0xea, 0x3b, 0xe8, 0x10, 0xb2, 0xfa, 0xdc, 0xbd, 0xd4, 0x1c, 0x63, 0xcc,
0x73, 0x61, 0x86, 0x3c, 0x77, 0x8d, 0xb1, 0xf4, 0x04, 0xc4, 0xe8, 0x69, 0x10, 0x72, 0x26, 0xac,
0x31, 0xe4, 0xdb, 0x65, 0xe8, 0x73, 0x63, 0x28, 0xfd, 0x45, 0x2a, 0x48, 0xcf, 0x0e, 0x62, 0x0d,
0x3d, 0xda, 0x27, 0xc7, 0xa9, 0x3b, 0x5c, 0xe1, 0x9c, 0xca, 0x9f, 0xd0, 0xcf, 0x20, 0xcf, 0x7e,
0x69, 0x03, 0x6b, 0xc8, 0xb2, 0x52, 0xf1, 0xf4, 0xa3, 0x95, 0x67, 0x7d, 0xc2, 0xfe, 0x53, 0x29,
0x8b, 0x0a, 0x8c, 0xb5, 0x6a, 0x0d, 0x31, 0x7a, 0x05, 0xdb, 0xcc, 0x09, 0x30, 0x0f, 0x62, 0xe7,
0x20, 0xfd, 0x30, 0xf5, 0x38, 0x7f, 0xfa, 0xe4, 0xb6, 0xc5, 0x30, 0x8b, 0x63, 0x47, 0x31, 0x5d,
0xfb, 0x46, 0x2d, 0xda, 0x21, 0x60, 0xf9, 0x35, 0x94, 0x62, 0xc8, 0x90, 0x08, 0x29, 0xef, 0x10,
0x72, 0x2a, 0xf9, 0x89, 0x8e, 0x61, 0x93, 0x65, 0x56, 0x16, 0x1f, 0xbb, 0xe1, 0x6d, 0xb9, 0xdc,
0x8c, 0xe4, 0xab, 0xe4, 0x97, 0x09, 0x69, 0x00, 0x42, 0x50, 0x19, 0x94, 0x87, 0xcc, 0x45, 0xeb,
0x65, 0xab, 0xfd, 0xba, 0x25, 0x6e, 0xa0, 0x7d, 0x40, 0x5d, 0x45, 0x7d, 0xa5, 0xa8, 0xda, 0x79,
0xa3, 0x5b, 0x51, 0xea, 0xf2, 0xab, 0x46, 0x5b, 0x15, 0x13, 0xa8, 0x0c, 0xfb, 0x15, 0xb9, 0x57,
0xad, 0x6b, 0xaf, 0x14, 0xb5, 0xdb, 0x68, 0xb7, 0x08, 0xfa, 0x9c, 0x00, 0xc4, 0x24, 0x42, 0x50,
0xec, 0xc8, 0x6a, 0xaf, 0x21, 0x37, 0x35, 0x55, 0xf9, 0x46, 0xa9, 0xf6, 0xc4, 0x94, 0xf4, 0x57,
0x09, 0xc8, 0x07, 0xf6, 0x0f, 0x1c, 0x43, 0x62, 0xdd, 0x31, 0x24, 0xe3, 0x8e, 0x81, 0x1b, 0x2d,
0xa8, 0xce, 0xd2, 0x31, 0x48, 0x55, 0xd8, 0x59, 0x22, 0x20, 0x92, 0xd5, 0x2e, 0x3a, 0xcd, 0x46,
0x55, 0xee, 0x29, 0x5a, 0x47, 0x51, 0x54, 0x71, 0x83, 0x68, 0x52, 0xad, 0xcb, 0xad, 0x96, 0xd2,
0xd4, 0xce, 0x2e, 0x5a, 0xb5, 0x46, 0xeb, 0x67, 0xda, 0x99, 0xdc, 0x68, 0x2a, 0x35, 0x31, 0x21,
0xfd, 0x57, 0x02, 0xf2, 0xd5, 0x4b, 0xdd, 0x34, 0xf1, 0xa4, 0x61, 0x8e, 0x2c, 0xf4, 0x18, 0xd2,
0xee, 0xcd, 0x8c, 0x25, 0xc3, 0x62, 0xc0, 0xb2, 0x9c, 0xa6, 0x77, 0x33, 0xc3, 0x2a, 0xa5, 0x40,
0x1f, 0x42, 0x71, 0x62, 0x0d, 0xf4, 0x89, 0x66, 0x5a, 0x43, 0x1c, 0xa8, 0xc5, 0x02, 0x85, 0xb6,
0xac, 0x21, 0x26, 0x91, 0xf2, 0x11, 0xf1, 0x95, 0xa9, 0xe5, 0xe2, 0x05, 0x19, 0x8b, 0x86, 0x02,
0x03, 0x7b, 0x74, 0xbf, 0x0e, 0x07, 0x6c, 0xb5, 0x99, 0x7e, 0x43, 0xc2, 0x5b, 0xeb, 0xeb, 0x0e,
0xe6, 0xe5, 0x39, 0x4d, 0x19, 0xf6, 0x28, 0xbe, 0xc3, 0xd0, 0x15, 0xdd, 0xc1, 0xac, 0x28, 0xff,
0x04, 0x0e, 0xf9, 0x06, 0x31, 0x9c, 0xac, 0x60, 0xee, 0x33, 0x82, 0x28, 0xab, 0xf4, 0x2f, 0x49,
0x28, 0x86, 0xd3, 0xd5, 0xba, 0xb0, 0x7a, 0x09, 0x82, 0x5f, 0xfd, 0x8d, 0xb1, 0x73, 0x90, 0xa4,
0x2e, 0xff, 0x78, 0x45, 0xe2, 0xf3, 0x53, 0xb5, 0x31, 0xe6, 0xde, 0x9e, 0xd7, 0x17, 0x10, 0xd4,
0x82, 0xc2, 0x80, 0x59, 0x54, 0x33, 0xcc, 0x91, 0xe5, 0x1c, 0xa4, 0xe8, 0x6a, 0x1f, 0xaf, 0x5a,
0x2d, 0x70, 0x44, 0x7c, 0x39, 0x61, 0x10, 0x00, 0x95, 0xbf, 0x06, 0x31, 0xba, 0x61, 0x4c, 0xdc,
0xec, 0x06, 0xe3, 0x46, 0x08, 0x44, 0x48, 0xf9, 0x02, 0x76, 0x96, 0xb6, 0xf8, 0x55, 0x02, 0x2f,
0xc0, 0x1c, 0x0c, 0xbc, 0xa7, 0xb0, 0x1d, 0xc9, 0xee, 0xb7, 0x64, 0x56, 0xe9, 0xcf, 0x52, 0xb0,
0xcb, 0x6f, 0x21, 0xe1, 0x6a, 0xfa, 0x25, 0xe4, 0x06, 0x97, 0xfa, 0x64, 0x82, 0x4d, 0x5e, 0xaa,
0x83, 0x25, 0x84, 0x57, 0x67, 0x0f, 0x4f, 0x6a, 0xa2, 0x4f, 0x8c, 0x7e, 0x0c, 0x19, 0x67, 0x3e,
0x18, 0x60, 0xc7, 0xe1, 0x62, 0x2f, 0xea, 0x5b, 0xd7, 0x2b, 0x9c, 0x5d, 0x46, 0x40, 0x6a, 0x0f,
0xa7, 0x45, 0x9f, 0xc1, 0x26, 0xb6, 0x6d, 0xcb, 0xe6, 0x95, 0xf4, 0xde, 0x32, 0x93, 0x42, 0xd0,
0xf5, 0x0d, 0x95, 0xd1, 0xa1, 0xe7, 0x90, 0x99, 0xd9, 0x78, 0xa6, 0xdb, 0x98, 0xd7, 0xd1, 0x72,
0xcc, 0x69, 0x76, 0x18, 0x05, 0xd9, 0x88, 0x13, 0xa3, 0xd3, 0x50, 0x25, 0xbd, 0xbf, 0xc2, 0x05,
0x2a, 0x78, 0x6c, 0x2c, 0xca, 0xe9, 0x4f, 0x20, 0x3b, 0x32, 0x4c, 0x7d, 0x62, 0xfc, 0x3e, 0xe6,
0xf5, 0xf4, 0xbd, 0x18, 0xbe, 0x33, 0x4e, 0x42, 0x6e, 0x49, 0x1e, 0x39, 0x7a, 0x06, 0x19, 0xee,
0x89, 0x07, 0x99, 0x88, 0x66, 0xdc, 0xe4, 0xfc, 0xc8, 0x88, 0x8c, 0x9c, 0xd2, 0x2b, 0xc4, 0x1d,
0xd8, 0x8e, 0x98, 0x1a, 0xdd, 0x8f, 0x9e, 0x8b, 0x10, 0xb4, 0x7d, 0xa4, 0x48, 0x27, 0xa3, 0x45,
0x5a, 0xfa, 0x1c, 0xc4, 0xe8, 0x21, 0xdc, 0xe6, 0x22, 0xff, 0x9e, 0x80, 0x02, 0x55, 0x0f, 0x0f,
0xcf, 0x75, 0xfb, 0x0a, 0xbb, 0xa8, 0x03, 0xc5, 0x29, 0x03, 0x78, 0xf5, 0x28, 0x11, 0x09, 0xa7,
0x10, 0xbd, 0xf7, 0x14, 0xac, 0x45, 0x85, 0x69, 0x10, 0x86, 0x4e, 0xa0, 0x34, 0x98, 0x60, 0xdd,
0x36, 0xcc, 0xb1, 0x36, 0xb3, 0x8d, 0x01, 0xd6, 0x6c, 0xdd, 0xc5, 0xfc, 0x06, 0xb1, 0xe3, 0xa1,
0x3a, 0x04, 0xa3, 0xea, 0x2e, 0x2e, 0xbf, 0x06, 0xb4, 0xbc, 0x68, 0x4c, 0x00, 0x7d, 0x12, 0x0e,
0xa0, 0xbd, 0xa8, 0x80, 0x2c, 0xa1, 0x07, 0x22, 0xe8, 0x3f, 0x36, 0x79, 0x96, 0x0f, 0x7a, 0x0f,
0xfa, 0x6e, 0x85, 0xc2, 0x4f, 0x56, 0x7b, 0x5c, 0x8c, 0xd2, 0x95, 0xe4, 0x41, 0x22, 0xaa, 0xf8,
0xe9, 0x1a, 0xc5, 0x29, 0xfd, 0xb2, 0xf2, 0xe8, 0x37, 0x41, 0x1c, 0x5c, 0xea, 0xf6, 0x18, 0x0f,
0x35, 0xee, 0x2f, 0x5e, 0x3e, 0xdb, 0x8d, 0x5e, 0xf2, 0x6a, 0xc6, 0x68, 0xa4, 0x6e, 0x73, 0x6a,
0x0e, 0x73, 0xd0, 0x57, 0x50, 0xc0, 0xd7, 0x78, 0x30, 0x27, 0xce, 0xa7, 0x8d, 0xb0, 0x17, 0x3f,
0x0b, 0xeb, 0x28, 0x1e, 0xf6, 0x0c, 0x63, 0x55, 0xc0, 0x81, 0x27, 0xf4, 0x09, 0xec, 0xb0, 0x8c,
0xed, 0xda, 0xba, 0xe9, 0xe8, 0xd4, 0x81, 0x79, 0xde, 0x17, 0x29, 0xa2, 0xb7, 0x80, 0xa3, 0x4f,
0xa1, 0x34, 0xc2, 0x4c, 0x25, 0xcd, 0xd1, 0x5d, 0x6d, 0x46, 0x7c, 0xec, 0x1d, 0x8d, 0xa0, 0xb4,
0xba, 0x3d, 0xc2, 0x54, 0x9f, 0xae, 0xee, 0x76, 0xb0, 0xfd, 0xf2, 0x1d, 0xa9, 0x70, 0x94, 0x1a,
0xf7, 0x39, 0x3d, 0x0d, 0x98, 0xb4, 0x2a, 0x10, 0x42, 0x0a, 0xec, 0xea, 0xe1, 0x9b, 0x58, 0x36,
0x5c, 0x32, 0x96, 0x6e, 0xa0, 0xb9, 0xe5, 0x1b, 0x28, 0x7a, 0x0d, 0xdb, 0xde, 0x59, 0x4e, 0xa9,
0x7b, 0x3a, 0x07, 0x40, 0x8d, 0x77, 0x72, 0xfb, 0x61, 0x32, 0x7f, 0xf6, 0xae, 0x53, 0xd3, 0x10,
0xf0, 0x7f, 0xcd, 0x27, 0xcb, 0x6f, 0xa0, 0x14, 0xb3, 0x7f, 0x70, 0xe5, 0x02, 0x5b, 0xf9, 0xd3,
0xf0, 0xca, 0xfb, 0xf1, 0xe1, 0x18, 0x2e, 0x18, 0xa5, 0x98, 0xb4, 0xb7, 0xee, 0x76, 0x6c, 0x01,
0x5a, 0x4e, 0x78, 0xeb, 0xea, 0xf8, 0x11, 0x00, 0x77, 0x98, 0x6b, 0xde, 0xd9, 0x0a, 0x6a, 0x8e,
0x79, 0xca, 0xb5, 0x31, 0x24, 0x19, 0xeb, 0x12, 0x1b, 0xe3, 0x4b, 0x57, 0xbb, 0x24, 0x37, 0x88,
0x14, 0xd5, 0x06, 0x18, 0xa8, 0x4e, 0x6e, 0x0d, 0x7f, 0x9d, 0x84, 0x62, 0xb8, 0x04, 0x90, 0xba,
0xca, 0x4a, 0x05, 0xb3, 0x2a, 0xaf, 0x07, 0x2f, 0x00, 0xe8, 0x8f, 0xe0, 0x3d, 0xef, 0x68, 0x45,
0x15, 0x39, 0xa1, 0xff, 0xaa, 0x39, 0xca, 0x40, 0x2f, 0xd9, 0xeb, 0xa7, 0x29, 0xa8, 0x0e, 0x25,
0xef, 0x36, 0x62, 0xd3, 0xa9, 0x8a, 0x4e, 0x1d, 0x3f, 0xbd, 0x36, 0xa3, 0xab, 0x48, 0xf7, 0x67,
0x04, 0x1e, 0x8b, 0x64, 0xc0, 0x26, 0xd3, 0x22, 0x74, 0x2b, 0x2e, 0xc1, 0x36, 0xbf, 0x15, 0x77,
0xeb, 0x17, 0xbd, 0x1a, 0x01, 0xd2, 0x2b, 0xb1, 0x5c, 0xad, 0xb6, 0x2f, 0x5a, 0x3d, 0xad, 0xd6,
0x56, 0xba, 0x5a, 0xab, 0xdd, 0xd3, 0x94, 0xef, 0x1a, 0xdd, 0x9e, 0x98, 0x44, 0x12, 0x3c, 0x68,
0xb4, 0xaa, 0xed, 0xf3, 0x4e, 0x53, 0xe9, 0x29, 0x9a, 0x47, 0xa6, 0x2a, 0x64, 0x15, 0xb9, 0xd7,
0x68, 0xb7, 0xc4, 0x94, 0xf4, 0xb7, 0x49, 0x28, 0x86, 0x25, 0x5a, 0x5c, 0x49, 0xd8, 0xe0, 0x89,
0x3d, 0x90, 0xbb, 0x73, 0x68, 0xd2, 0xc4, 0x9f, 0x6e, 0x33, 0xca, 0xf2, 0x20, 0x29, 0x1d, 0x37,
0x48, 0x7a, 0x0f, 0x72, 0x8b, 0x01, 0x12, 0x4b, 0x15, 0xcc, 0x5b, 0x08, 0xf2, 0x14, 0x36, 0x1d,
0x97, 0xa4, 0xbc, 0x2d, 0x7a, 0x60, 0xf7, 0x57, 0x98, 0xb2, 0x4b, 0x68, 0x54, 0x46, 0x1a, 0xf5,
0x99, 0x4c, 0xd4, 0x67, 0xd0, 0x13, 0xc8, 0x5a, 0x73, 0x97, 0xdd, 0x49, 0xb3, 0xab, 0x86, 0x4d,
0x3e, 0x09, 0x11, 0x70, 0xa2, 0xbb, 0xd8, 0x71, 0x35, 0xf7, 0x9a, 0xe6, 0x0c, 0x41, 0xcd, 0x32,
0x40, 0xef, 0x5a, 0xfa, 0x25, 0x08, 0xc1, 0xc0, 0x44, 0xcf, 0x41, 0xf0, 0xf2, 0x47, 0xdf, 0x18,
0x7a, 0x95, 0xa0, 0x14, 0x8d, 0xb5, 0x8a, 0x31, 0x54, 0xf3, 0x53, 0xff, 0xb7, 0x13, 0xe4, 0xd3,
0x9d, 0x2b, 0xef, 0x3e, 0xbb, 0xc4, 0x27, 0x3b, 0x57, 0x3e, 0x9f, 0xec, 0x5c, 0x39, 0xd2, 0x05,
0xc0, 0x02, 0x85, 0x3e, 0xbc, 0x65, 0x90, 0xc4, 0xc6, 0x48, 0x8f, 0x40, 0x98, 0x9b, 0x86, 0xeb,
0x68, 0x23, 0x63, 0x32, 0xe1, 0xb3, 0x9b, 0x82, 0x9a, 0xa7, 0xb0, 0x33, 0x0a, 0x0a, 0x2c, 0x5b,
0x31, 0x86, 0x64, 0xd9, 0x3e, 0x0f, 0xdd, 0xd8, 0xb9, 0x13, 0x9d, 0x3a, 0xdd, 0x65, 0xd9, 0xbf,
0x49, 0x42, 0x3e, 0x50, 0x7b, 0x88, 0x8b, 0x60, 0x73, 0x48, 0xaa, 0x5b, 0x5f, 0x9f, 0xe8, 0xa4,
0x77, 0x67, 0x8e, 0x57, 0x60, 0xd0, 0x0a, 0x03, 0xa2, 0x1a, 0x08, 0x9c, 0x8c, 0x39, 0x03, 0x8b,
0xde, 0x47, 0x71, 0xe5, 0xec, 0x24, 0xe4, 0x11, 0x79, 0xc6, 0x46, 0x1f, 0xc8, 0x66, 0xde, 0x99,
0x6a, 0x86, 0x39, 0xc4, 0xd7, 0xd4, 0x65, 0x37, 0xd5, 0x82, 0x07, 0x6d, 0x10, 0x60, 0xc4, 0xab,
0xd3, 0xd1, 0xfb, 0xce, 0x2f, 0x41, 0x08, 0x6e, 0x81, 0x76, 0x41, 0x6c, 0x5f, 0xf4, 0x3a, 0x17,
0x24, 0xba, 0xaa, 0xaa, 0x22, 0xf7, 0x94, 0x9a, 0xb8, 0x81, 0x1e, 0xc1, 0x11, 0x87, 0xd6, 0x2e,
0xba, 0x24, 0x2c, 0x7b, 0x4a, 0xab, 0xa6, 0xd4, 0xb4, 0xf6, 0xd9, 0x59, 0xb5, 0x2e, 0x37, 0x48,
0xf8, 0x1e, 0xc1, 0x61, 0x90, 0x44, 0xae, 0x11, 0x7c, 0xaf, 0xad, 0x9d, 0x29, 0x4a, 0x57, 0x4c,
0x92, 0x46, 0x98, 0xa3, 0xcf, 0x2e, 0x9a, 0xcd, 0x37, 0x5a, 0xb7, 0xa3, 0xb4, 0x48, 0x63, 0xfb,
0xa7, 0x29, 0xc8, 0x33, 0xc3, 0x33, 0x87, 0xbb, 0x65, 0x36, 0x72, 0x04, 0x40, 0xeb, 0xeb, 0xc8,
0xb8, 0xf6, 0x8f, 0x24, 0x47, 0x20, 0x67, 0x04, 0x40, 0xaa, 0x84, 0x3e, 0x75, 0xf9, 0x4c, 0x94,
0xfc, 0x44, 0x0f, 0x41, 0x98, 0x1a, 0xa6, 0x46, 0xfa, 0x19, 0x8d, 0xa0, 0xd2, 0x14, 0x05, 0x53,
0xc3, 0x24, 0x5d, 0x85, 0x3c, 0xa5, 0xa3, 0x9e, 0xc0, 0xc4, 0x8e, 0x46, 0xa6, 0xa0, 0xc2, 0x62,
0x50, 0x47, 0x02, 0x86, 0x11, 0x38, 0xc6, 0x98, 0x86, 0x9f, 0xa0, 0x66, 0x29, 0xa0, 0x6b, 0x8c,
0x91, 0x04, 0x85, 0xe9, 0x7c, 0xe2, 0x1a, 0x04, 0x49, 0x45, 0x66, 0x55, 0x3a, 0x4f, 0x81, 0x5d,
0x63, 0x4c, 0x84, 0x3e, 0x84, 0x2c, 0xed, 0x4f, 0x67, 0xf3, 0x3e, 0x0f, 0xb8, 0x0c, 0x79, 0xee,
0xcc, 0xfb, 0xe8, 0x73, 0xc8, 0x51, 0x94, 0x3e, 0x1c, 0xda, 0xbc, 0x32, 0x2f, 0xae, 0x35, 0xa4,
0x7d, 0x95, 0x87, 0x43, 0x1b, 0x3b, 0x8e, 0x4a, 0x57, 0x20, 0x0f, 0x44, 0x1c, 0xaa, 0x0d, 0xed,
0xa4, 0x05, 0x6a, 0x81, 0x2c, 0x01, 0x90, 0xee, 0x19, 0x7d, 0x0d, 0x47, 0x53, 0xfd, 0x9a, 0x8f,
0xb0, 0xe3, 0x6e, 0x23, 0x05, 0xaa, 0xff, 0xbd, 0xa9, 0x7e, 0x4d, 0xc7, 0xd9, 0x67, 0xe1, 0x5b,
0xc9, 0x37, 0xe9, 0xec, 0xa6, 0xb8, 0xf5, 0x4d, 0x3a, 0x9b, 0x17, 0x05, 0xe9, 0xef, 0x12, 0x90,
0xf3, 0x63, 0x02, 0x9d, 0xf8, 0xf3, 0x4f, 0x1e, 0x38, 0xbb, 0x91, 0xc0, 0x61, 0x95, 0xdc, 0x23,
0x42, 0xa7, 0xb0, 0x37, 0xc1, 0xa4, 0x59, 0x1e, 0xce, 0x6d, 0x5a, 0x0b, 0xb4, 0xfe, 0xc4, 0x1a,
0x5c, 0x39, 0xfc, 0xd0, 0x4a, 0x14, 0x59, 0xe3, 0xb8, 0x0a, 0x45, 0xa1, 0x03, 0xc8, 0x78, 0x97,
0x19, 0x36, 0xb0, 0xf6, 0x1e, 0xd1, 0x8f, 0xa1, 0x40, 0x8e, 0x91, 0xda, 0xca, 0x35, 0xb0, 0x4d,
0x33, 0x6b, 0x31, 0x90, 0xe8, 0x88, 0xad, 0x7a, 0x06, 0xb6, 0xd5, 0xfc, 0xd4, 0x30, 0xbd, 0x87,
0x6f, 0xd2, 0xd9, 0x94, 0x98, 0x96, 0xfe, 0xd0, 0x57, 0x84, 0x24, 0x95, 0x1f, 0x4c, 0x91, 0xf4,
0x9d, 0x14, 0xd9, 0x0c, 0x29, 0x22, 0x9d, 0x40, 0x3e, 0x30, 0xe7, 0x8d, 0x3a, 0x5f, 0x22, 0xea,
0x7c, 0xd2, 0x5f, 0x26, 0x40, 0x08, 0x4e, 0xad, 0x6f, 0xe5, 0x40, 0x32, 0xe4, 0x47, 0xba, 0x31,
0xd1, 0x02, 0x63, 0xba, 0xe2, 0xe9, 0xc3, 0xd8, 0x11, 0xf8, 0xc9, 0x99, 0x6e, 0x4c, 0xbc, 0xe1,
0xcf, 0xc8, 0xff, 0x4d, 0xf6, 0xa0, 0x4b, 0x38, 0x2e, 0xb9, 0x8b, 0xd3, 0x70, 0xca, 0x31, 0x82,
0x2e, 0x85, 0x48, 0x47, 0x00, 0x0b, 0x56, 0xb4, 0x0d, 0xf9, 0x46, 0xeb, 0x95, 0xdc, 0x6c, 0xd4,
0x34, 0xf9, 0xbc, 0x27, 0x6e, 0x48, 0xbf, 0xf0, 0x62, 0xba, 0x61, 0xce, 0xe6, 0xe1, 0x02, 0x95,
0xb8, 0xbd, 0x40, 0x1d, 0x01, 0x90, 0x60, 0x0a, 0xbd, 0x05, 0xc9, 0x39, 0xc6, 0x98, 0xbd, 0x01,
0x91, 0x5e, 0x80, 0xc0, 0xcf, 0x69, 0xee, 0x92, 0xd5, 0x57, 0x16, 0xf9, 0xd0, 0x02, 0xfc, 0x49,
0xfa, 0xfb, 0x24, 0x94, 0x19, 0xfb, 0xb9, 0x35, 0x34, 0x46, 0x37, 0x91, 0xb7, 0x37, 0xb7, 0xa4,
0x9f, 0x67, 0x00, 0x26, 0x7e, 0xa7, 0x19, 0x44, 0x2d, 0xaf, 0xa8, 0x45, 0xdd, 0x87, 0xea, 0xac,
0xe6, 0x4c, 0xfc, 0x8e, 0xfe, 0x22, 0xb5, 0x30, 0x4f, 0x98, 0x2c, 0x2a, 0xae, 0xd7, 0xbc, 0xec,
0x45, 0x9d, 0x8e, 0x62, 0x55, 0xb2, 0x3c, 0xfb, 0xe9, 0xa0, 0xd7, 0x6c, 0xb3, 0x99, 0x6e, 0xeb,
0x53, 0x87, 0x5f, 0xbe, 0xbe, 0x8c, 0xb0, 0xc5, 0x29, 0x71, 0xd2, 0xc2, 0xef, 0x38, 0xa4, 0x43,
0x78, 0xb1, 0x8b, 0x6d, 0x87, 0x0a, 0x44, 0x1f, 0x9d, 0x72, 0x0d, 0x76, 0xe3, 0x48, 0x7e, 0xb5,
0xeb, 0x92, 0xf4, 0x35, 0xbc, 0x17, 0x2b, 0x03, 0x7f, 0x17, 0xf3, 0x3e, 0xe4, 0x03, 0x13, 0x2d,
0xcf, 0x4f, 0x17, 0x63, 0x2a, 0xe9, 0x2b, 0xb8, 0x17, 0x88, 0x37, 0x56, 0xe0, 0xf8, 0x29, 0xdc,
0x1a, 0x15, 0xb6, 0xf7, 0x06, 0x26, 0xc8, 0xcb, 0x37, 0xfe, 0xd8, 0xbb, 0x63, 0xb1, 0x29, 0x63,
0x29, 0xdc, 0xe8, 0x84, 0xae, 0x56, 0x9f, 0xc0, 0x0e, 0x2b, 0xf1, 0x73, 0x73, 0x34, 0x9f, 0x84,
0xea, 0xbc, 0x48, 0x11, 0x17, 0x0b, 0xb8, 0x54, 0x04, 0xa1, 0x87, 0xed, 0xa9, 0xc3, 0x85, 0x94,
0xfe, 0x71, 0x13, 0x0a, 0x1c, 0xc0, 0x77, 0x3e, 0x86, 0x1d, 0x92, 0x7c, 0xe3, 0xde, 0x79, 0x6e,
0x4f, 0xf5, 0x6b, 0x39, 0xf8, 0x8a, 0xee, 0x37, 0xe0, 0x90, 0xd0, 0x32, 0x35, 0x63, 0x53, 0x24,
0x6d, 0x88, 0xf7, 0xa7, 0xfa, 0x35, 0x95, 0x3b, 0x92, 0x60, 0x96, 0x9a, 0xda, 0xd4, 0xdd, 0x9b,
0xda, 0xd7, 0xb0, 0x1d, 0x4e, 0x68, 0xde, 0x84, 0xfd, 0xd8, 0xe7, 0x0e, 0xe9, 0x75, 0xd2, 0x0c,
0x66, 0xb8, 0x40, 0x77, 0x5f, 0x0c, 0xa5, 0x3e, 0x07, 0x3d, 0x83, 0x7d, 0x13, 0x5f, 0xbb, 0xbc,
0xfa, 0x0c, 0x2c, 0x73, 0xa4, 0xb9, 0xa4, 0x17, 0x77, 0x79, 0x12, 0x2c, 0x11, 0x2c, 0x2d, 0x3b,
0x55, 0xcb, 0x1c, 0xf5, 0x28, 0x0a, 0xfd, 0x16, 0x3c, 0x08, 0x30, 0xad, 0x6e, 0xa0, 0x0f, 0x7c,
0xe6, 0x48, 0xcd, 0x42, 0x3f, 0x85, 0x72, 0x70, 0xdb, 0x09, 0xd6, 0x6d, 0xcd, 0x35, 0xa6, 0xd8,
0x71, 0xf5, 0xe9, 0x8c, 0x77, 0xd5, 0xf7, 0x16, 0x5b, 0x13, 0x7c, 0xcf, 0x43, 0xa3, 0x11, 0xec,
0x47, 0xb3, 0xfb, 0x7c, 0x40, 0xfb, 0xe4, 0x2c, 0xb5, 0xc9, 0xd3, 0xbb, 0xd8, 0xa4, 0xc2, 0x58,
0x58, 0xa7, 0xbc, 0x3b, 0x89, 0x41, 0x95, 0x65, 0x28, 0xc5, 0x98, 0x31, 0xa6, 0xad, 0x0d, 0x8d,
0x51, 0xb3, 0xc1, 0xce, 0x18, 0xc3, 0xe1, 0xca, 0x5d, 0x63, 0x16, 0x3a, 0x0d, 0x2e, 0x14, 0xec,
0x35, 0xc2, 0xfc, 0x3c, 0x20, 0x16, 0x5d, 0x72, 0x05, 0x76, 0x55, 0x3c, 0xc1, 0x6f, 0x75, 0x93,
0x19, 0xcc, 0x0b, 0xca, 0x22, 0x24, 0xfd, 0x7e, 0x37, 0x69, 0x0c, 0x51, 0x99, 0xbe, 0x2e, 0x65,
0x03, 0x19, 0x92, 0x09, 0x05, 0xd5, 0x7f, 0x96, 0xfe, 0x61, 0x13, 0x0a, 0xa1, 0x45, 0x82, 0x15,
0x31, 0x11, 0x2e, 0xed, 0x6c, 0xdd, 0xa4, 0xbf, 0xee, 0xf7, 0x1e, 0xf8, 0xf4, 0x96, 0xe6, 0x57,
0xe9, 0xc8, 0xc0, 0x2e, 0x24, 0xda, 0xf7, 0x9b, 0x5d, 0x6d, 0xae, 0x9b, 0x5d, 0x2d, 0x45, 0xe9,
0xd6, 0xdd, 0xa3, 0xf4, 0x21, 0xe4, 0x83, 0x43, 0x27, 0x76, 0xef, 0x0c, 0x82, 0x56, 0xcd, 0x9b,
0xb2, 0xf1, 0xf3, 0xa6, 0x53, 0xd8, 0x1b, 0xd8, 0x98, 0xb9, 0xb8, 0x1f, 0x1d, 0x9a, 0xe9, 0xd0,
0x1b, 0x69, 0x5a, 0x2d, 0x79, 0x48, 0x3f, 0x34, 0x5a, 0x0e, 0xea, 0xae, 0x9a, 0x1e, 0x1d, 0xaf,
0x37, 0xe5, 0xff, 0xbb, 0xc9, 0x51, 0x0d, 0x84, 0xe0, 0x51, 0xb1, 0x09, 0x90, 0x83, 0xe9, 0x99,
0xb2, 0x04, 0x9f, 0x21, 0xcf, 0x1c, 0xe5, 0x9d, 0x0a, 0x5d, 0x3f, 0xad, 0x66, 0xf8, 0x51, 0x48,
0x3f, 0x85, 0x7c, 0xe0, 0x4a, 0x4f, 0x42, 0xc2, 0xc4, 0xee, 0x3b, 0xcb, 0xbe, 0xe2, 0x6a, 0x7b,
0x8f, 0x08, 0x41, 0x9a, 0x36, 0x04, 0xec, 0x15, 0x2b, 0xfd, 0x2d, 0xc9, 0x90, 0xf5, 0xee, 0x4a,
0x04, 0x4f, 0xe7, 0x4b, 0x2c, 0x18, 0xe9, 0x6f, 0xd2, 0xae, 0xb2, 0x1b, 0x06, 0x6f, 0x06, 0x79,
0xbb, 0xca, 0x60, 0xb4, 0x15, 0x94, 0xfe, 0x24, 0x01, 0x79, 0xd9, 0xb9, 0xea, 0x9a, 0xfa, 0xcc,
0xb9, 0xb4, 0xdc, 0x35, 0x31, 0xf9, 0x3f, 0xb9, 0xbc, 0x87, 0x5b, 0xb3, 0x54, 0xb4, 0x35, 0x0b,
0xb5, 0x2d, 0xe9, 0x70, 0xdb, 0x42, 0x25, 0xab, 0x18, 0xc3, 0xff, 0x83, 0x92, 0xfd, 0x73, 0x02,
0x76, 0x83, 0x0e, 0xe7, 0x8b, 0x18, 0xfa, 0xc8, 0x25, 0x90, 0x99, 0x16, 0xf6, 0x8d, 0xf9, 0xc8,
0x65, 0x41, 0x17, 0xd0, 0x96, 0x8d, 0x1b, 0x3e, 0x00, 0x96, 0x70, 0x48, 0x7e, 0xa1, 0xce, 0xc3,
0xe4, 0x14, 0x3c, 0x20, 0x4d, 0x28, 0x9f, 0x02, 0x72, 0x2d, 0x57, 0x9f, 0x90, 0x78, 0x77, 0x58,
0xa9, 0xc3, 0x43, 0xde, 0xd3, 0x8a, 0x14, 0xd3, 0xd5, 0x5d, 0xa7, 0xca, 0xe0, 0x64, 0x49, 0x76,
0xbd, 0xe1, 0x11, 0xc8, 0xcb, 0x30, 0x1b, 0x6b, 0x70, 0xa5, 0xa4, 0xcf, 0x61, 0x97, 0xc6, 0xae,
0x2f, 0x0d, 0x4f, 0xf7, 0x6b, 0xa6, 0xa2, 0x7f, 0x94, 0x80, 0xbd, 0x50, 0xa8, 0xf8, 0x46, 0xa9,
0xad, 0x78, 0x75, 0x70, 0x14, 0x1b, 0xbc, 0xfe, 0x96, 0xdf, 0xef, 0xfd, 0x88, 0xf4, 0x4f, 0x69,
0xd8, 0x8b, 0xe8, 0xc0, 0x6f, 0x64, 0xab, 0xfd, 0x28, 0xa8, 0x5e, 0x32, 0x3c, 0xc3, 0x95, 0xa0,
0x30, 0xb3, 0xf1, 0x5b, 0xcd, 0xc7, 0xb3, 0x51, 0x60, 0x9e, 0x00, 0x2b, 0x9c, 0x66, 0x45, 0x35,
0x48, 0xaf, 0xab, 0x06, 0xf5, 0x25, 0xe3, 0x6c, 0xde, 0xc1, 0x38, 0x71, 0xb5, 0xe8, 0x01, 0xe4,
0xbd, 0x29, 0x33, 0x91, 0x2f, 0x43, 0xd3, 0x84, 0x37, 0x66, 0x6e, 0x0c, 0x17, 0xca, 0xb9, 0xd7,
0x7c, 0x9e, 0x91, 0xe1, 0x48, 0xf4, 0x02, 0xee, 0xfb, 0xac, 0xab, 0xab, 0xc7, 0x3e, 0x27, 0x3f,
0xfb, 0x01, 0x8a, 0xc8, 0x2f, 0x56, 0x15, 0x91, 0xd3, 0x45, 0x30, 0xc4, 0x1d, 0xde, 0x9d, 0x8a,
0x89, 0x7e, 0xd7, 0x9c, 0xff, 0x45, 0x38, 0xe7, 0x3f, 0x88, 0xcf, 0xf9, 0xbe, 0x0c, 0x81, 0xdc,
0xff, 0xc2, 0xeb, 0x53, 0x48, 0xee, 0x56, 0x75, 0x97, 0xc4, 0x22, 0x8f, 0x91, 0x47, 0x20, 0x78,
0x83, 0x9d, 0x2b, 0x7c, 0xc3, 0x9c, 0x5d, 0x50, 0xf3, 0x7c, 0xb8, 0x43, 0x40, 0xd2, 0x6f, 0x03,
0x2c, 0xf8, 0x48, 0x63, 0x13, 0x60, 0xf0, 0x1a, 0x9b, 0x05, 0x3d, 0x3a, 0xe1, 0xf3, 0x20, 0x3a,
0xe3, 0x48, 0xae, 0x9a, 0x71, 0xd0, 0x61, 0x10, 0xf9, 0x25, 0xa9, 0x5e, 0x23, 0x14, 0x14, 0x8e,
0x3b, 0xff, 0x73, 0x2e, 0x9d, 0x4d, 0xc1, 0xcb, 0xb3, 0xdb, 0x00, 0x0b, 0x95, 0x8a, 0xfd, 0x76,
0xa4, 0x71, 0x24, 0x9a, 0xbc, 0x8e, 0x07, 0x7d, 0x08, 0x45, 0xc7, 0xd5, 0x6d, 0x57, 0x8b, 0x24,
0x06, 0x81, 0x42, 0xbd, 0xd0, 0x78, 0x0c, 0xa2, 0x39, 0x9f, 0x32, 0x1a, 0xec, 0x68, 0x7d, 0x7d,
0x70, 0xc5, 0x43, 0xb7, 0x68, 0xce, 0xa7, 0x15, 0x06, 0xae, 0xe8, 0x83, 0x2b, 0x49, 0x85, 0xfd,
0xe8, 0x46, 0x5c, 0xf4, 0x2f, 0x21, 0xc3, 0xf9, 0xb9, 0xd4, 0x0f, 0xd6, 0xfb, 0x8a, 0xea, 0x91,
0x1f, 0x7f, 0xec, 0x7f, 0x71, 0x42, 0xe7, 0x61, 0x05, 0xc8, 0xf5, 0x5e, 0x2b, 0xf2, 0xcb, 0xa6,
0xd2, 0xed, 0x8a, 0x1b, 0x28, 0x0f, 0x19, 0xb9, 0x55, 0xad, 0xb7, 0xd5, 0xae, 0x98, 0x38, 0xfe,
0xe3, 0x04, 0x94, 0x62, 0xe6, 0xee, 0xf4, 0x9b, 0x9d, 0x1e, 0xfb, 0xc2, 0x85, 0x7d, 0xcf, 0xd2,
0xee, 0x28, 0x2d, 0x71, 0x03, 0x15, 0x01, 0x18, 0x9c, 0x3e, 0x27, 0xd0, 0x0e, 0x14, 0xd8, 0xb3,
0xf2, 0x5d, 0xa7, 0xa1, 0x2a, 0x35, 0x31, 0x89, 0x0e, 0x60, 0x37, 0xcc, 0x7a, 0xd1, 0xa9, 0xc9,
0x3d, 0x45, 0x4c, 0x21, 0x11, 0x04, 0x86, 0xa9, 0x36, 0xdb, 0x5d, 0xa5, 0x26, 0xa6, 0xd1, 0x3d,
0x28, 0x85, 0x69, 0xe9, 0x07, 0x41, 0xe2, 0xe6, 0xf1, 0x17, 0x90, 0xf5, 0x4e, 0x9a, 0xb0, 0xf5,
0x1a, 0x8a, 0xaa, 0xd5, 0x94, 0x33, 0xf9, 0xa2, 0xd9, 0x13, 0x37, 0x10, 0xc0, 0x16, 0x85, 0x3c,
0x15, 0x13, 0xfe, 0xef, 0xcf, 0xc5, 0xe4, 0xf1, 0x9f, 0x27, 0x00, 0x16, 0x1d, 0x2e, 0x2a, 0xc1,
0x76, 0x5b, 0xad, 0x29, 0xaa, 0xd6, 0xbd, 0xa8, 0x9c, 0x37, 0x7a, 0x6c, 0x8c, 0xbb, 0x03, 0x05,
0x06, 0xac, 0x36, 0x15, 0x99, 0x48, 0x4c, 0xdf, 0xba, 0x30, 0x10, 0xff, 0xe4, 0xa8, 0xf9, 0x46,
0x3b, 0x6b, 0x34, 0x9b, 0x54, 0x1b, 0x04, 0x45, 0x86, 0x53, 0xbe, 0x53, 0xaa, 0x17, 0x64, 0x89,
0xd4, 0x02, 0x56, 0x95, 0x5b, 0x55, 0xa5, 0x49, 0x35, 0xf1, 0x97, 0xf5, 0x0c, 0xb1, 0x49, 0xe4,
0x66, 0x20, 0xfe, 0x2d, 0xd0, 0xd6, 0xf1, 0xef, 0x40, 0x29, 0xa6, 0xf1, 0x20, 0x07, 0xd4, 0x6a,
0x6b, 0xe7, 0xb2, 0xfa, 0x52, 0xe9, 0x31, 0x09, 0xd9, 0x6f, 0xcf, 0x4e, 0x09, 0xb4, 0x0b, 0xa2,
0x5c, 0xad, 0x2a, 0x9d, 0x1e, 0x3d, 0x0a, 0xb2, 0x68, 0x57, 0x4c, 0xa2, 0x6d, 0xc8, 0x73, 0x42,
0x7a, 0x1a, 0xa9, 0xd3, 0xff, 0xcc, 0xf8, 0x5f, 0x99, 0xc8, 0xfe, 0x0b, 0x19, 0xf4, 0x2d, 0x14,
0xc3, 0xdf, 0x05, 0xa3, 0x07, 0x81, 0xab, 0x6b, 0xcc, 0x47, 0xcb, 0xe5, 0xf7, 0x57, 0xe2, 0xb9,
0x6f, 0xf6, 0x20, 0x1f, 0xf8, 0x20, 0x16, 0x3d, 0x5a, 0x1a, 0xff, 0x44, 0x3f, 0x09, 0x2e, 0x4b,
0xeb, 0x48, 0xf8, 0xaa, 0x3f, 0x87, 0x42, 0x68, 0x8e, 0x82, 0x3e, 0xb8, 0xc3, 0xa4, 0xa7, 0xfc,
0xe1, 0x7a, 0xa2, 0x85, 0xc4, 0x81, 0xaf, 0x65, 0x97, 0x24, 0x5e, 0xfe, 0x82, 0x77, 0x49, 0xe2,
0xb8, 0x8f, 0x6d, 0x7b, 0xe1, 0x49, 0x66, 0x74, 0xd5, 0xe5, 0x6f, 0x63, 0x97, 0x56, 0x8d, 0xf9,
0xe0, 0x15, 0x7d, 0x1b, 0xf2, 0xe2, 0x87, 0x71, 0xa3, 0xd9, 0xe0, 0xa8, 0xa8, 0xfc, 0x68, 0x0d,
0x05, 0x5f, 0xf2, 0x0d, 0xec, 0xf9, 0xef, 0x43, 0x69, 0xf6, 0xe0, 0xfe, 0x81, 0x16, 0x85, 0x37,
0xee, 0x13, 0xdb, 0xf2, 0x51, 0xf4, 0x85, 0x53, 0x08, 0xfd, 0x38, 0xf1, 0x34, 0x81, 0x9e, 0xc3,
0x26, 0x1d, 0x0b, 0xa0, 0xbd, 0xe8, 0x98, 0x80, 0x49, 0xb7, 0x1f, 0x3f, 0x3d, 0x40, 0x2d, 0xd8,
0x0b, 0x35, 0x4e, 0xfe, 0x05, 0xea, 0x28, 0xbe, 0xb1, 0x5a, 0x5e, 0x2f, 0xdc, 0x5d, 0xb7, 0xa0,
0xb0, 0x6a, 0x9d, 0xb8, 0xcb, 0x5d, 0xf9, 0x96, 0x74, 0x4a, 0x4e, 0x21, 0x50, 0xb5, 0xa2, 0xa7,
0xb0, 0x54, 0x08, 0x97, 0x4e, 0x21, 0xa6, 0x1a, 0x7d, 0x0b, 0xc5, 0x70, 0xb2, 0x47, 0x2b, 0x84,
0x70, 0x96, 0x23, 0x31, 0xbe, 0x4a, 0x54, 0x7e, 0xed, 0xe7, 0x3f, 0x1a, 0x1b, 0xee, 0xe5, 0xbc,
0x7f, 0x32, 0xb0, 0xa6, 0x9f, 0x4d, 0x8c, 0xf1, 0xa5, 0x6b, 0x1a, 0xe6, 0x78, 0xa2, 0xf7, 0x9d,
0xcf, 0x08, 0xeb, 0x67, 0x9c, 0xbf, 0xbf, 0x45, 0xff, 0x64, 0xe1, 0xd9, 0x7f, 0x07, 0x00, 0x00,
0xff, 0xff, 0x76, 0x2b, 0x71, 0x96, 0xc6, 0x30, 0x00, 0x00,
0x61, 0xaa, 0x27, 0x33, 0x9d, 0xe9, 0x49, 0xcf, 0x6b, 0xe6, 0xcd, 0x6b, 0x06, 0x64, 0x5b, 0x79,
0xf6, 0xb4, 0x63, 0x7b, 0x64, 0xa7, 0x3f, 0xde, 0x2b, 0x50, 0xc9, 0xf6, 0xb5, 0x23, 0x62, 0x4b,
0x46, 0x92, 0xbb, 0x13, 0x16, 0x6f, 0xc1, 0x8e, 0x05, 0x4b, 0x0a, 0xaa, 0x28, 0x76, 0xfc, 0x02,
0xd8, 0xb0, 0xa4, 0x58, 0xc0, 0x8a, 0x25, 0x2b, 0xaa, 0x80, 0x05, 0x2b, 0x8a, 0x05, 0x5b, 0x76,
0xd4, 0xfd, 0x90, 0x2c, 0xc9, 0xb2, 0x93, 0xc7, 0x3c, 0xaa, 0x28, 0x36, 0xdd, 0xd6, 0xf9, 0xb8,
0xf7, 0x9c, 0x73, 0xcf, 0xc7, 0x3d, 0x47, 0x0a, 0x88, 0xfa, 0x7c, 0xe0, 0x1a, 0x96, 0x89, 0xb1,
0x7d, 0x32, 0xb3, 0x2d, 0xd7, 0x42, 0x99, 0x99, 0x65, 0x4d, 0xec, 0xd9, 0x40, 0xfa, 0x83, 0x04,
0xec, 0xa9, 0xd8, 0xc1, 0xf6, 0x3b, 0x2c, 0x0f, 0x06, 0xd6, 0xdc, 0x74, 0x55, 0xfc, 0x7b, 0x73,
0xec, 0xb8, 0xe8, 0x23, 0x28, 0xe8, 0x0c, 0xa2, 0xbd, 0xd3, 0x27, 0x73, 0x7c, 0x90, 0x78, 0x98,
0x78, 0x9c, 0x56, 0x05, 0x0e, 0x7c, 0x45, 0x60, 0xe8, 0xd7, 0xa0, 0xe8, 0x11, 0xe1, 0xeb, 0x99,
0x61, 0xdf, 0x1c, 0x24, 0x1f, 0x26, 0x1e, 0x17, 0x54, 0x8f, 0x55, 0xa1, 0x40, 0x74, 0x04, 0xe0,
0xda, 0xfa, 0x10, 0xdb, 0xda, 0x15, 0xbe, 0x39, 0x48, 0x3d, 0x4c, 0x3c, 0x16, 0xd4, 0x1c, 0x83,
0xbc, 0xc4, 0x37, 0xd2, 0x15, 0xec, 0x47, 0x65, 0x70, 0x66, 0x96, 0xe9, 0xb0, 0xf5, 0x7d, 0xd9,
0x29, 0x73, 0x82, 0x32, 0x17, 0x16, 0xd0, 0x97, 0xf8, 0x06, 0x1d, 0xc3, 0x8e, 0x61, 0x1a, 0xae,
0xa1, 0x4f, 0xb4, 0xbe, 0xee, 0x0e, 0x2e, 0x29, 0x65, 0x92, 0x52, 0x6e, 0x73, 0x44, 0x85, 0xc0,
0xc9, 0x66, 0xff, 0x96, 0x80, 0x83, 0x2e, 0xd9, 0xcb, 0x6e, 0x98, 0x86, 0x1b, 0x51, 0xfa, 0xf9,
0x42, 0xe9, 0x99, 0x65, 0x98, 0x2e, 0xdd, 0x2e, 0x7f, 0xba, 0x73, 0xc2, 0xed, 0x75, 0xd2, 0x9e,
0xbb, 0x1d, 0x82, 0xf0, 0xed, 0x40, 0x9f, 0x82, 0x76, 0x70, 0x06, 0xb6, 0x31, 0x73, 0xf9, 0xee,
0xde, 0x6a, 0x5d, 0x0a, 0x5c, 0xb6, 0x69, 0xea, 0x4e, 0x36, 0x4d, 0xdf, 0x6e, 0xd3, 0xcd, 0xa8,
0x4d, 0x3f, 0x80, 0xc3, 0x18, 0x2d, 0x99, 0x59, 0xa5, 0xb9, 0x67, 0x82, 0xee, 0xbc, 0x3f, 0x35,
0xdc, 0xb6, 0x3d, 0xc4, 0xb6, 0x67, 0x82, 0x4f, 0x20, 0xa5, 0x3b, 0x57, 0x5c, 0x71, 0xe4, 0x2b,
0xce, 0xe8, 0x65, 0xe7, 0xaa, 0xbe, 0xa1, 0x12, 0x02, 0x42, 0xd7, 0x37, 0x86, 0x54, 0xcf, 0x65,
0xba, 0x8a, 0x31, 0x24, 0x74, 0x7d, 0x63, 0x58, 0xc9, 0x41, 0x66, 0x88, 0x5d, 0xdd, 0x98, 0x38,
0xc4, 0xd9, 0x0e, 0x63, 0xf6, 0xe5, 0x67, 0xfd, 0x02, 0x0a, 0x86, 0xf9, 0x4e, 0x9f, 0x18, 0x43,
0xcd, 0x22, 0x08, 0x2e, 0xc2, 0x9e, 0xbf, 0x74, 0x83, 0x61, 0x29, 0x57, 0x7d, 0x43, 0x15, 0x8c,
0xc0, 0x33, 0xba, 0x0f, 0x59, 0x7d, 0x30, 0xc0, 0x33, 0x17, 0x33, 0x99, 0xb2, 0xf5, 0x0d, 0xd5,
0x87, 0x04, 0x85, 0x68, 0x7a, 0xba, 0x57, 0x75, 0x73, 0x80, 0x27, 0x21, 0xdd, 0x9f, 0xc2, 0x2e,
0xdd, 0x5a, 0x33, 0x2d, 0x73, 0x80, 0xb5, 0x99, 0x8d, 0x8d, 0xa9, 0x3e, 0xc6, 0xdc, 0xe9, 0x10,
0xc5, 0xb5, 0x08, 0xaa, 0xc3, 0x31, 0x0b, 0x33, 0x87, 0x56, 0xe3, 0x66, 0xfe, 0xd7, 0x24, 0xec,
0x56, 0x27, 0x06, 0x36, 0x5d, 0x99, 0xb9, 0xeb, 0x39, 0x76, 0x1c, 0x7d, 0x8c, 0xd1, 0x57, 0xb0,
0x35, 0xb0, 0xa6, 0x53, 0xc3, 0xf3, 0xaf, 0xb2, 0xaf, 0x23, 0x3f, 0xa9, 0x2a, 0xc5, 0x4e, 0xb1,
0xe9, 0xd6, 0x37, 0x54, 0x4e, 0x8b, 0x5e, 0x40, 0xce, 0x99, 0xf7, 0x89, 0x7f, 0xf5, 0x31, 0xb7,
0xfb, 0xfd, 0x28, 0x63, 0x97, 0x11, 0xcc, 0xc8, 0x6e, 0xf5, 0x0d, 0x75, 0xc1, 0x80, 0x9e, 0xc1,
0x16, 0x33, 0x07, 0x75, 0xba, 0xfc, 0xe9, 0xe1, 0xc2, 0xa7, 0x89, 0xd0, 0xe7, 0x24, 0x3e, 0x64,
0x4a, 0x40, 0xb6, 0x64, 0xa4, 0x84, 0xc9, 0xc6, 0xbf, 0x8b, 0x07, 0x2e, 0xf5, 0xc1, 0x78, 0x26,
0x95, 0x12, 0x10, 0x26, 0x46, 0x8a, 0x9e, 0x40, 0xda, 0x31, 0xc6, 0x26, 0xf5, 0xc9, 0xfc, 0xe9,
0xbd, 0x18, 0x96, 0xae, 0x31, 0x26, 0xd2, 0x51, 0x32, 0xf4, 0x15, 0x64, 0x6c, 0x3c, 0xb0, 0xde,
0x61, 0xfb, 0x60, 0x8b, 0x72, 0x1c, 0x44, 0x95, 0x52, 0x19, 0xfa, 0xa6, 0xbe, 0xa1, 0x7a, 0xa4,
0x95, 0x4d, 0x48, 0x4d, 0x9d, 0xb1, 0xf4, 0x16, 0x76, 0x96, 0x4c, 0x86, 0x3e, 0x84, 0x3c, 0x33,
0x99, 0x76, 0xa9, 0x3b, 0x97, 0xfc, 0xf4, 0x80, 0x81, 0xea, 0xba, 0x73, 0x49, 0xe2, 0x90, 0xe5,
0x89, 0x77, 0xd8, 0x76, 0x0c, 0xcb, 0xe4, 0x59, 0x4b, 0xa0, 0xc0, 0x57, 0x0c, 0x26, 0xd9, 0x50,
0x8a, 0x31, 0x6a, 0x24, 0xee, 0x12, 0x91, 0xb8, 0x43, 0x8f, 0x40, 0xe0, 0x7b, 0x53, 0x1f, 0xe2,
0x79, 0x80, 0xcb, 0x43, 0x7d, 0x07, 0x1d, 0x42, 0x56, 0x9f, 0xbb, 0x97, 0x9a, 0x63, 0x8c, 0x79,
0x2e, 0xcc, 0x90, 0xe7, 0xae, 0x31, 0x96, 0x9e, 0x80, 0x18, 0x3d, 0x0d, 0x42, 0xce, 0x84, 0x35,
0x86, 0x7c, 0xbb, 0x0c, 0x7d, 0x6e, 0x0c, 0xa5, 0xbf, 0x48, 0x05, 0xe9, 0xd9, 0x41, 0xac, 0xa1,
0x47, 0xfb, 0xe4, 0x38, 0x75, 0x87, 0x2b, 0x9c, 0x53, 0xf9, 0x13, 0xfa, 0x29, 0xe4, 0xd9, 0x2f,
0x6d, 0x60, 0x0d, 0x59, 0x56, 0x2a, 0x9e, 0x7e, 0xb2, 0xf2, 0xac, 0x4f, 0xd8, 0x7f, 0x2a, 0x65,
0x51, 0x81, 0xb1, 0x56, 0xad, 0x21, 0x46, 0xaf, 0x60, 0x9b, 0x39, 0x01, 0xe6, 0x41, 0xec, 0x1c,
0xa4, 0x1f, 0xa6, 0x1e, 0xe7, 0x4f, 0x9f, 0xdc, 0xb6, 0x18, 0x66, 0x71, 0xec, 0x28, 0xa6, 0x6b,
0xdf, 0xa8, 0x45, 0x3b, 0x04, 0x2c, 0xbf, 0x86, 0x52, 0x0c, 0x19, 0x12, 0x21, 0xe5, 0x1d, 0x42,
0x4e, 0x25, 0x3f, 0xd1, 0x31, 0x6c, 0xb2, 0xcc, 0xca, 0xe2, 0x63, 0x37, 0xbc, 0x2d, 0x97, 0x9b,
0x91, 0x7c, 0x93, 0xfc, 0x3a, 0x21, 0x0d, 0x40, 0x08, 0x2a, 0x83, 0xf2, 0x90, 0xb9, 0x68, 0xbd,
0x6c, 0xb5, 0x5f, 0xb7, 0xc4, 0x0d, 0xb4, 0x0f, 0xa8, 0xab, 0xa8, 0xaf, 0x14, 0x55, 0x3b, 0x6f,
0x74, 0x2b, 0x4a, 0x5d, 0x7e, 0xd5, 0x68, 0xab, 0x62, 0x02, 0x95, 0x61, 0xbf, 0x22, 0xf7, 0xaa,
0x75, 0xed, 0x95, 0xa2, 0x76, 0x1b, 0xed, 0x16, 0x41, 0x9f, 0x13, 0x80, 0x98, 0x44, 0x08, 0x8a,
0x1d, 0x59, 0xed, 0x35, 0xe4, 0xa6, 0xa6, 0x2a, 0xdf, 0x29, 0xd5, 0x9e, 0x98, 0x92, 0xfe, 0x2a,
0x01, 0xf9, 0xc0, 0xfe, 0x81, 0x63, 0x48, 0xac, 0x3b, 0x86, 0x64, 0xdc, 0x31, 0x70, 0xa3, 0x05,
0xd5, 0x59, 0x3a, 0x06, 0xa9, 0x0a, 0x3b, 0x4b, 0x04, 0x44, 0xb2, 0xda, 0x45, 0xa7, 0xd9, 0xa8,
0xca, 0x3d, 0x45, 0xeb, 0x28, 0x8a, 0x2a, 0x6e, 0x10, 0x4d, 0xaa, 0x75, 0xb9, 0xd5, 0x52, 0x9a,
0xda, 0xd9, 0x45, 0xab, 0xd6, 0x68, 0xfd, 0x54, 0x3b, 0x93, 0x1b, 0x4d, 0xa5, 0x26, 0x26, 0xa4,
0xff, 0x4a, 0x40, 0xbe, 0x7a, 0xa9, 0x9b, 0x26, 0x9e, 0x34, 0xcc, 0x91, 0x85, 0x1e, 0x43, 0xda,
0xbd, 0x99, 0xb1, 0x64, 0x58, 0x0c, 0x58, 0x96, 0xd3, 0xf4, 0x6e, 0x66, 0x58, 0xa5, 0x14, 0xe8,
0x63, 0x28, 0x4e, 0xac, 0x81, 0x3e, 0xd1, 0x4c, 0x6b, 0x88, 0x03, 0xb5, 0x58, 0xa0, 0xd0, 0x96,
0x35, 0xc4, 0x24, 0x52, 0x3e, 0x21, 0xbe, 0x32, 0xb5, 0x5c, 0xbc, 0x20, 0x63, 0xd1, 0x50, 0x60,
0x60, 0x8f, 0xee, 0xd7, 0xe1, 0x80, 0xad, 0x36, 0xd3, 0x6f, 0x48, 0x78, 0x6b, 0x7d, 0xdd, 0xc1,
0xbc, 0x3c, 0xa7, 0x29, 0xc3, 0x1e, 0xc5, 0x77, 0x18, 0xba, 0xa2, 0x3b, 0x98, 0x15, 0xe5, 0x1f,
0xc3, 0x21, 0xdf, 0x20, 0x86, 0x93, 0x15, 0xcc, 0x7d, 0x46, 0x10, 0x65, 0x95, 0xfe, 0x25, 0x09,
0xc5, 0x70, 0xba, 0x5a, 0x17, 0x56, 0x2f, 0x41, 0xf0, 0xab, 0xbf, 0x31, 0x76, 0x0e, 0x92, 0xd4,
0xe5, 0x1f, 0xaf, 0x48, 0x7c, 0x7e, 0xaa, 0x36, 0xc6, 0xdc, 0xdb, 0xf3, 0xfa, 0x02, 0x82, 0x5a,
0x50, 0x18, 0x30, 0x8b, 0x6a, 0x86, 0x39, 0xb2, 0x9c, 0x83, 0x14, 0x5d, 0xed, 0xd3, 0x55, 0xab,
0x05, 0x8e, 0x88, 0x2f, 0x27, 0x0c, 0x02, 0xa0, 0xf2, 0xb7, 0x20, 0x46, 0x37, 0x8c, 0x89, 0x9b,
0xdd, 0x60, 0xdc, 0x08, 0x81, 0x08, 0x29, 0x5f, 0xc0, 0xce, 0xd2, 0x16, 0xbf, 0x4c, 0xe0, 0x05,
0x98, 0x83, 0x81, 0xf7, 0x14, 0xb6, 0x23, 0xd9, 0xfd, 0x96, 0xcc, 0x2a, 0xfd, 0x59, 0x0a, 0x76,
0xf9, 0x2d, 0x24, 0x5c, 0x4d, 0xbf, 0x86, 0xdc, 0xe0, 0x52, 0x9f, 0x4c, 0xb0, 0xc9, 0x4b, 0x75,
0xb0, 0x84, 0xf0, 0xea, 0xec, 0xe1, 0x49, 0x4d, 0xf4, 0x89, 0xd1, 0x8f, 0x20, 0xe3, 0xcc, 0x07,
0x03, 0xec, 0x38, 0x5c, 0xec, 0x45, 0x7d, 0xeb, 0x7a, 0x85, 0xb3, 0xcb, 0x08, 0x48, 0xed, 0xe1,
0xb4, 0xe8, 0x0b, 0xd8, 0xc4, 0xb6, 0x6d, 0xd9, 0xbc, 0x92, 0xde, 0x5b, 0x66, 0x52, 0x08, 0xba,
0xbe, 0xa1, 0x32, 0x3a, 0xf4, 0x1c, 0x32, 0x33, 0x1b, 0xcf, 0x74, 0x1b, 0xf3, 0x3a, 0x5a, 0x8e,
0x39, 0xcd, 0x0e, 0xa3, 0x20, 0x1b, 0x71, 0x62, 0x74, 0x1a, 0xaa, 0xa4, 0xf7, 0x57, 0xb8, 0x40,
0x05, 0x8f, 0x8d, 0x45, 0x39, 0xfd, 0x31, 0x64, 0x47, 0x86, 0xa9, 0x4f, 0x8c, 0xdf, 0xc7, 0xbc,
0x9e, 0x7e, 0x10, 0xc3, 0x77, 0xc6, 0x49, 0xc8, 0x2d, 0xc9, 0x23, 0x47, 0xcf, 0x20, 0xc3, 0x3d,
0xf1, 0x20, 0x13, 0xd1, 0x8c, 0x9b, 0x9c, 0x1f, 0x19, 0x91, 0x91, 0x53, 0x7a, 0x85, 0xb8, 0x03,
0xdb, 0x11, 0x53, 0xa3, 0xfb, 0xd1, 0x73, 0x11, 0x82, 0xb6, 0x8f, 0x14, 0xe9, 0x64, 0xb4, 0x48,
0x4b, 0x5f, 0x82, 0x18, 0x3d, 0x84, 0xdb, 0x5c, 0xe4, 0xdf, 0x13, 0x50, 0xa0, 0xea, 0xe1, 0xe1,
0xb9, 0x6e, 0x5f, 0x61, 0x17, 0x75, 0xa0, 0x38, 0x65, 0x00, 0xaf, 0x1e, 0x25, 0x22, 0xe1, 0x14,
0xa2, 0xf7, 0x9e, 0x82, 0xb5, 0xa8, 0x30, 0x0d, 0xc2, 0xd0, 0x09, 0x94, 0x06, 0x13, 0xac, 0xdb,
0x86, 0x39, 0xd6, 0x66, 0xb6, 0x31, 0xc0, 0x9a, 0xad, 0xbb, 0x98, 0xdf, 0x20, 0x76, 0x3c, 0x54,
0x87, 0x60, 0x54, 0xdd, 0xc5, 0xe5, 0xd7, 0x80, 0x96, 0x17, 0x8d, 0x09, 0xa0, 0xcf, 0xc2, 0x01,
0xb4, 0x17, 0x15, 0x90, 0x25, 0xf4, 0x40, 0x04, 0xfd, 0xc7, 0x26, 0xcf, 0xf2, 0x41, 0xef, 0x41,
0x6f, 0x56, 0x28, 0xfc, 0x64, 0xb5, 0xc7, 0xc5, 0x28, 0x5d, 0x49, 0x1e, 0x24, 0xa2, 0x8a, 0x9f,
0xae, 0x51, 0x9c, 0xd2, 0x2f, 0x2b, 0x8f, 0x7e, 0x13, 0xc4, 0xc1, 0xa5, 0x6e, 0x8f, 0xf1, 0x50,
0xe3, 0xfe, 0xe2, 0xe5, 0xb3, 0xdd, 0xe8, 0x25, 0xaf, 0x66, 0x8c, 0x46, 0xea, 0x36, 0xa7, 0xe6,
0x30, 0x07, 0x7d, 0x03, 0x05, 0x7c, 0x8d, 0x07, 0x73, 0xe2, 0x7c, 0xda, 0x08, 0x7b, 0xf1, 0xb3,
0xb0, 0x8e, 0xe2, 0x61, 0xcf, 0x30, 0x56, 0x05, 0x1c, 0x78, 0x42, 0x9f, 0xc1, 0x0e, 0xcb, 0xd8,
0xae, 0xad, 0x9b, 0x8e, 0x4e, 0x1d, 0x98, 0xe7, 0x7d, 0x91, 0x22, 0x7a, 0x0b, 0x38, 0xfa, 0x1c,
0x4a, 0x23, 0xcc, 0x54, 0xd2, 0x1c, 0xdd, 0xd5, 0x66, 0xc4, 0xc7, 0xde, 0xd3, 0x08, 0x4a, 0xab,
0xdb, 0x23, 0x4c, 0xf5, 0xe9, 0xea, 0x6e, 0x07, 0xdb, 0x2f, 0xdf, 0x93, 0x0a, 0x47, 0xa9, 0x71,
0x9f, 0xd3, 0xd3, 0x80, 0x49, 0xab, 0x02, 0x21, 0xa4, 0xc0, 0xae, 0x1e, 0xbe, 0x89, 0x65, 0xc3,
0x25, 0x63, 0xe9, 0x06, 0x9a, 0x5b, 0xbe, 0x81, 0xa2, 0xd7, 0xb0, 0xed, 0x9d, 0xe5, 0x94, 0xba,
0xa7, 0x73, 0x00, 0xd4, 0x78, 0x27, 0xb7, 0x1f, 0x26, 0xf3, 0x67, 0xef, 0x3a, 0x35, 0x0d, 0x01,
0xff, 0xd7, 0x7c, 0xb2, 0xfc, 0x16, 0x4a, 0x31, 0xfb, 0x07, 0x57, 0x2e, 0xb0, 0x95, 0x3f, 0x0f,
0xaf, 0xbc, 0x1f, 0x1f, 0x8e, 0xe1, 0x82, 0x51, 0x8a, 0x49, 0x7b, 0xeb, 0x6e, 0xc7, 0x16, 0xa0,
0xe5, 0x84, 0xb7, 0xae, 0x8e, 0x1f, 0x01, 0x70, 0x87, 0xb9, 0xe6, 0x9d, 0xad, 0xa0, 0xe6, 0x98,
0xa7, 0x5c, 0x1b, 0x43, 0x92, 0xb1, 0x2e, 0xb1, 0x31, 0xbe, 0x74, 0xb5, 0x4b, 0x72, 0x83, 0x48,
0x51, 0x6d, 0x80, 0x81, 0xea, 0xe4, 0xd6, 0xf0, 0xd7, 0x49, 0x28, 0x86, 0x4b, 0x00, 0xa9, 0xab,
0xac, 0x54, 0x30, 0xab, 0xf2, 0x7a, 0xf0, 0x02, 0x80, 0xfe, 0x08, 0xde, 0xf3, 0x8e, 0x56, 0x54,
0x91, 0x13, 0xfa, 0xaf, 0x9a, 0xa3, 0x0c, 0xf4, 0x92, 0xbd, 0x7e, 0x9a, 0x82, 0xea, 0x50, 0xf2,
0x6e, 0x23, 0x36, 0x9d, 0xaa, 0xe8, 0xd4, 0xf1, 0xd3, 0x6b, 0x33, 0xba, 0x8a, 0x74, 0x7f, 0x46,
0xe0, 0xb1, 0x48, 0x06, 0x6c, 0x32, 0x2d, 0x42, 0xb7, 0xe2, 0x12, 0x6c, 0xf3, 0x5b, 0x71, 0xb7,
0x7e, 0xd1, 0xab, 0x11, 0x20, 0xbd, 0x12, 0xcb, 0xd5, 0x6a, 0xfb, 0xa2, 0xd5, 0xd3, 0x6a, 0x6d,
0xa5, 0xab, 0xb5, 0xda, 0x3d, 0x4d, 0x79, 0xd3, 0xe8, 0xf6, 0xc4, 0x24, 0x92, 0xe0, 0x41, 0xa3,
0x55, 0x6d, 0x9f, 0x77, 0x9a, 0x4a, 0x4f, 0xd1, 0x3c, 0x32, 0x55, 0x21, 0xab, 0xc8, 0xbd, 0x46,
0xbb, 0x25, 0xa6, 0xa4, 0xbf, 0x4d, 0x42, 0x31, 0x2c, 0xd1, 0xe2, 0x4a, 0xc2, 0x06, 0x4f, 0xec,
0x81, 0xdc, 0x9d, 0x43, 0x93, 0x26, 0xfe, 0x74, 0x9b, 0x51, 0x96, 0x07, 0x49, 0xe9, 0xb8, 0x41,
0xd2, 0x07, 0x90, 0x5b, 0x0c, 0x90, 0x58, 0xaa, 0x60, 0xde, 0x42, 0x90, 0xa7, 0xb0, 0xe9, 0xb8,
0x24, 0xe5, 0x6d, 0xd1, 0x03, 0xbb, 0xbf, 0xc2, 0x94, 0x5d, 0x42, 0xa3, 0x32, 0xd2, 0xa8, 0xcf,
0x64, 0xa2, 0x3e, 0x83, 0x9e, 0x40, 0xd6, 0x9a, 0xbb, 0xec, 0x4e, 0x9a, 0x5d, 0x35, 0x6c, 0xf2,
0x49, 0x88, 0x80, 0x13, 0xdd, 0xc5, 0x8e, 0xab, 0xb9, 0xd7, 0x34, 0x67, 0x08, 0x6a, 0x96, 0x01,
0x7a, 0xd7, 0xd2, 0x2f, 0x40, 0x08, 0x06, 0x26, 0x7a, 0x0e, 0x82, 0x97, 0x3f, 0xfa, 0xc6, 0xd0,
0xab, 0x04, 0xa5, 0x68, 0xac, 0x55, 0x8c, 0xa1, 0x9a, 0x9f, 0xfa, 0xbf, 0x9d, 0x20, 0x9f, 0xee,
0x5c, 0x79, 0xf7, 0xd9, 0x25, 0x3e, 0xd9, 0xb9, 0xf2, 0xf9, 0x64, 0xe7, 0xca, 0x91, 0x2e, 0x00,
0x16, 0x28, 0xf4, 0xf1, 0x2d, 0x83, 0x24, 0x36, 0x46, 0x7a, 0x04, 0xc2, 0xdc, 0x34, 0x5c, 0x47,
0x1b, 0x19, 0x93, 0x09, 0x9f, 0xdd, 0x14, 0xd4, 0x3c, 0x85, 0x9d, 0x51, 0x50, 0x60, 0xd9, 0x8a,
0x31, 0x24, 0xcb, 0xf6, 0x79, 0xe8, 0xc6, 0xce, 0x9d, 0xe8, 0xd4, 0xe9, 0x2e, 0xcb, 0xfe, 0x4d,
0x12, 0xf2, 0x81, 0xda, 0x43, 0x5c, 0x04, 0x9b, 0x43, 0x52, 0xdd, 0xfa, 0xfa, 0x44, 0x27, 0xbd,
0x3b, 0x73, 0xbc, 0x02, 0x83, 0x56, 0x18, 0x10, 0xd5, 0x40, 0xe0, 0x64, 0xcc, 0x19, 0x58, 0xf4,
0x3e, 0x8a, 0x2b, 0x67, 0x27, 0x21, 0x8f, 0xc8, 0x33, 0x36, 0xfa, 0x40, 0x36, 0xf3, 0xce, 0x54,
0x33, 0xcc, 0x21, 0xbe, 0xa6, 0x2e, 0xbb, 0xa9, 0x16, 0x3c, 0x68, 0x83, 0x00, 0x23, 0x5e, 0x9d,
0x8e, 0xde, 0x77, 0x7e, 0x01, 0x42, 0x70, 0x0b, 0xb4, 0x0b, 0x62, 0xfb, 0xa2, 0xd7, 0xb9, 0x20,
0xd1, 0x55, 0x55, 0x15, 0xb9, 0xa7, 0xd4, 0xc4, 0x0d, 0xf4, 0x08, 0x8e, 0x38, 0xb4, 0x76, 0xd1,
0x25, 0x61, 0xd9, 0x53, 0x5a, 0x35, 0xa5, 0xa6, 0xb5, 0xcf, 0xce, 0xaa, 0x75, 0xb9, 0x41, 0xc2,
0xf7, 0x08, 0x0e, 0x83, 0x24, 0x72, 0x8d, 0xe0, 0x7b, 0x6d, 0xed, 0x4c, 0x51, 0xba, 0x62, 0x92,
0x34, 0xc2, 0x1c, 0x7d, 0x76, 0xd1, 0x6c, 0xbe, 0xd5, 0xba, 0x1d, 0xa5, 0x45, 0x1a, 0xdb, 0x3f,
0x4d, 0x41, 0x9e, 0x19, 0x9e, 0x39, 0xdc, 0x2d, 0xb3, 0x91, 0x23, 0x00, 0x5a, 0x5f, 0x47, 0xc6,
0xb5, 0x7f, 0x24, 0x39, 0x02, 0x39, 0x23, 0x00, 0x52, 0x25, 0xf4, 0xa9, 0xcb, 0x67, 0xa2, 0xe4,
0x27, 0x7a, 0x08, 0xc2, 0xd4, 0x30, 0x35, 0xd2, 0xcf, 0x68, 0x04, 0x95, 0xa6, 0x28, 0x98, 0x1a,
0x26, 0xe9, 0x2a, 0xe4, 0x29, 0x1d, 0xf5, 0x04, 0x26, 0x76, 0x34, 0x32, 0x05, 0x15, 0x16, 0x83,
0x3a, 0x12, 0x30, 0x8c, 0xc0, 0x31, 0xc6, 0x34, 0xfc, 0x04, 0x35, 0x4b, 0x01, 0x5d, 0x63, 0x8c,
0x24, 0x28, 0x4c, 0xe7, 0x13, 0xd7, 0x20, 0x48, 0x2a, 0x32, 0xab, 0xd2, 0x79, 0x0a, 0xec, 0x1a,
0x63, 0x22, 0xf4, 0x21, 0x64, 0x69, 0x7f, 0x3a, 0x9b, 0xf7, 0x79, 0xc0, 0x65, 0xc8, 0x73, 0x67,
0xde, 0x47, 0x5f, 0x42, 0x8e, 0xa2, 0xf4, 0xe1, 0xd0, 0xe6, 0x95, 0x79, 0x71, 0xad, 0x21, 0xed,
0xab, 0x3c, 0x1c, 0xda, 0xd8, 0x71, 0x54, 0xba, 0x02, 0x79, 0x20, 0xe2, 0x50, 0x6d, 0x68, 0x27,
0x2d, 0x50, 0x0b, 0x64, 0x09, 0x80, 0x74, 0xcf, 0xe8, 0x5b, 0x38, 0x9a, 0xea, 0xd7, 0x7c, 0x84,
0x1d, 0x77, 0x1b, 0x29, 0x50, 0xfd, 0xef, 0x4d, 0xf5, 0x6b, 0x3a, 0xce, 0x3e, 0x0b, 0xdf, 0x4a,
0xbe, 0x4b, 0x67, 0x37, 0xc5, 0xad, 0xef, 0xd2, 0xd9, 0xbc, 0x28, 0x48, 0x7f, 0x97, 0x80, 0x9c,
0x1f, 0x13, 0xe8, 0xc4, 0x9f, 0x7f, 0xf2, 0xc0, 0xd9, 0x8d, 0x04, 0x0e, 0xab, 0xe4, 0x1e, 0x11,
0x3a, 0x85, 0xbd, 0x09, 0x26, 0xcd, 0xf2, 0x70, 0x6e, 0xd3, 0x5a, 0xa0, 0xf5, 0x27, 0xd6, 0xe0,
0xca, 0xe1, 0x87, 0x56, 0xa2, 0xc8, 0x1a, 0xc7, 0x55, 0x28, 0x0a, 0x1d, 0x40, 0xc6, 0xbb, 0xcc,
0xb0, 0x81, 0xb5, 0xf7, 0x88, 0x7e, 0x04, 0x05, 0x72, 0x8c, 0xd4, 0x56, 0xae, 0x81, 0x6d, 0x9a,
0x59, 0x8b, 0x81, 0x44, 0x47, 0x6c, 0xd5, 0x33, 0xb0, 0xad, 0xe6, 0xa7, 0x86, 0xe9, 0x3d, 0x7c,
0x97, 0xce, 0xa6, 0xc4, 0xb4, 0xf4, 0x87, 0xbe, 0x22, 0x24, 0xa9, 0xfc, 0xca, 0x14, 0x49, 0xdf,
0x49, 0x91, 0xcd, 0x90, 0x22, 0xd2, 0x09, 0xe4, 0x03, 0x73, 0xde, 0xa8, 0xf3, 0x25, 0xa2, 0xce,
0x27, 0xfd, 0x65, 0x02, 0x84, 0xe0, 0xd4, 0xfa, 0x56, 0x0e, 0x24, 0x43, 0x7e, 0xa4, 0x1b, 0x13,
0x2d, 0x30, 0xa6, 0x2b, 0x9e, 0x3e, 0x8c, 0x1d, 0x81, 0x9f, 0x9c, 0xe9, 0xc6, 0xc4, 0x1b, 0xfe,
0x8c, 0xfc, 0xdf, 0x64, 0x0f, 0xba, 0x84, 0xe3, 0x92, 0xbb, 0x38, 0x0d, 0xa7, 0x1c, 0x23, 0xe8,
0x52, 0x88, 0x74, 0x04, 0xb0, 0x60, 0x45, 0xdb, 0x90, 0x6f, 0xb4, 0x5e, 0xc9, 0xcd, 0x46, 0x4d,
0x93, 0xcf, 0x7b, 0xe2, 0x86, 0xf4, 0x73, 0x2f, 0xa6, 0x1b, 0xe6, 0x6c, 0x1e, 0x2e, 0x50, 0x89,
0xdb, 0x0b, 0xd4, 0x11, 0x00, 0x09, 0xa6, 0xd0, 0x5b, 0x90, 0x9c, 0x63, 0x8c, 0xd9, 0x1b, 0x10,
0xe9, 0x05, 0x08, 0xfc, 0x9c, 0xe6, 0x2e, 0x59, 0x7d, 0x65, 0x91, 0x0f, 0x2d, 0xc0, 0x9f, 0xa4,
0xbf, 0x4f, 0x42, 0x99, 0xb1, 0x9f, 0x5b, 0x43, 0x63, 0x74, 0x13, 0x79, 0x7b, 0x73, 0x4b, 0xfa,
0x79, 0x06, 0x60, 0xe2, 0xf7, 0x9a, 0x41, 0xd4, 0xf2, 0x8a, 0x5a, 0xd4, 0x7d, 0xa8, 0xce, 0x6a,
0xce, 0xc4, 0xef, 0xe9, 0x2f, 0x52, 0x0b, 0xf3, 0x84, 0xc9, 0xa2, 0xe2, 0x7a, 0xcd, 0xcb, 0x5e,
0xd4, 0xe9, 0x28, 0x56, 0x25, 0xcb, 0xb3, 0x9f, 0x0e, 0x7a, 0xcd, 0x36, 0x9b, 0xe9, 0xb6, 0x3e,
0x75, 0xf8, 0xe5, 0xeb, 0xeb, 0x08, 0x5b, 0x9c, 0x12, 0x27, 0x2d, 0xfc, 0x9e, 0x43, 0x3a, 0x84,
0x17, 0xbb, 0xd8, 0x76, 0xa8, 0x40, 0xf4, 0xd1, 0x29, 0xd7, 0x60, 0x37, 0x8e, 0xe4, 0x97, 0xbb,
0x2e, 0x49, 0xdf, 0xc2, 0x07, 0xb1, 0x32, 0xf0, 0x77, 0x31, 0x1f, 0x42, 0x3e, 0x30, 0xd1, 0xf2,
0xfc, 0x74, 0x31, 0xa6, 0x92, 0xbe, 0x81, 0x7b, 0x81, 0x78, 0x63, 0x05, 0x8e, 0x9f, 0xc2, 0xad,
0x51, 0x61, 0x7b, 0x6f, 0x60, 0x82, 0xbc, 0x7c, 0xe3, 0x4f, 0xbd, 0x3b, 0x16, 0x9b, 0x32, 0x96,
0xc2, 0x8d, 0x4e, 0xe8, 0x6a, 0xf5, 0x19, 0xec, 0xb0, 0x12, 0x3f, 0x37, 0x47, 0xf3, 0x49, 0xa8,
0xce, 0x8b, 0x14, 0x71, 0xb1, 0x80, 0x4b, 0x45, 0x10, 0x7a, 0xd8, 0x9e, 0x3a, 0x5c, 0x48, 0xe9,
0x1f, 0x37, 0xa1, 0xc0, 0x01, 0x7c, 0xe7, 0x63, 0xd8, 0x21, 0xc9, 0x37, 0xee, 0x9d, 0xe7, 0xf6,
0x54, 0xbf, 0x96, 0x83, 0xaf, 0xe8, 0x7e, 0x03, 0x0e, 0x09, 0x2d, 0x53, 0x33, 0x36, 0x45, 0xd2,
0x86, 0x78, 0x7f, 0xaa, 0x5f, 0x53, 0xb9, 0x23, 0x09, 0x66, 0xa9, 0xa9, 0x4d, 0xdd, 0xbd, 0xa9,
0x7d, 0x0d, 0xdb, 0xe1, 0x84, 0xe6, 0x4d, 0xd8, 0x8f, 0x7d, 0xee, 0x90, 0x5e, 0x27, 0xcd, 0x60,
0x86, 0x0b, 0x74, 0xf7, 0xc5, 0x50, 0xea, 0x73, 0xd0, 0x33, 0xd8, 0x37, 0xf1, 0xb5, 0xcb, 0xab,
0xcf, 0xc0, 0x32, 0x47, 0x9a, 0x4b, 0x7a, 0x71, 0x97, 0x27, 0xc1, 0x12, 0xc1, 0xd2, 0xb2, 0x53,
0xb5, 0xcc, 0x51, 0x8f, 0xa2, 0xd0, 0x6f, 0xc1, 0x83, 0x00, 0xd3, 0xea, 0x06, 0xfa, 0xc0, 0x67,
0x8e, 0xd4, 0x2c, 0xf4, 0x13, 0x28, 0x07, 0xb7, 0x9d, 0x60, 0xdd, 0xd6, 0x5c, 0x63, 0x8a, 0x1d,
0x57, 0x9f, 0xce, 0x78, 0x57, 0x7d, 0x6f, 0xb1, 0x35, 0xc1, 0xf7, 0x3c, 0x34, 0x1a, 0xc1, 0x7e,
0x34, 0xbb, 0xcf, 0x07, 0xb4, 0x4f, 0xce, 0x52, 0x9b, 0x3c, 0xbd, 0x8b, 0x4d, 0x2a, 0x8c, 0x85,
0x75, 0xca, 0xbb, 0x93, 0x18, 0x54, 0x59, 0x86, 0x52, 0x8c, 0x19, 0x63, 0xda, 0xda, 0xd0, 0x18,
0x35, 0x1b, 0xec, 0x8c, 0x31, 0x1c, 0xae, 0xdc, 0x35, 0x66, 0xa1, 0xd3, 0xe0, 0x42, 0xc1, 0x5e,
0x23, 0xcc, 0xcf, 0x03, 0x62, 0xd1, 0x25, 0x57, 0x60, 0x57, 0xc5, 0x13, 0xfc, 0x4e, 0x37, 0x99,
0xc1, 0xbc, 0xa0, 0x2c, 0x42, 0xd2, 0xef, 0x77, 0x93, 0xc6, 0x10, 0x95, 0xe9, 0xeb, 0x52, 0x36,
0x90, 0x21, 0x99, 0x50, 0x50, 0xfd, 0x67, 0xe9, 0x1f, 0x36, 0xa1, 0x10, 0x5a, 0x24, 0x58, 0x11,
0x13, 0xe1, 0xd2, 0xce, 0xd6, 0x4d, 0xfa, 0xeb, 0xfe, 0xe0, 0x81, 0x4f, 0x6f, 0x69, 0x7e, 0x95,
0x8e, 0x0c, 0xec, 0x42, 0xa2, 0xfd, 0xb0, 0xd9, 0xd5, 0xe6, 0xba, 0xd9, 0xd5, 0x52, 0x94, 0x6e,
0xdd, 0x3d, 0x4a, 0x1f, 0x42, 0x3e, 0x38, 0x74, 0x62, 0xf7, 0xce, 0x20, 0x68, 0xd5, 0xbc, 0x29,
0x1b, 0x3f, 0x6f, 0x3a, 0x85, 0xbd, 0x81, 0x8d, 0x99, 0x8b, 0xfb, 0xd1, 0xa1, 0x99, 0x0e, 0xbd,
0x91, 0xa6, 0xd5, 0x92, 0x87, 0xf4, 0x43, 0xa3, 0xe5, 0xa0, 0xee, 0xaa, 0xe9, 0xd1, 0xf1, 0x7a,
0x53, 0xfe, 0xbf, 0x9b, 0x1c, 0xd5, 0x40, 0x08, 0x1e, 0x15, 0x9b, 0x00, 0x39, 0x98, 0x9e, 0x29,
0x4b, 0xf0, 0x19, 0xf2, 0xcc, 0x51, 0xde, 0xa9, 0xd0, 0xf5, 0xd3, 0x6a, 0x86, 0x1f, 0x85, 0xf4,
0x13, 0xc8, 0x07, 0xae, 0xf4, 0x24, 0x24, 0x4c, 0xec, 0xbe, 0xb7, 0xec, 0x2b, 0xae, 0xb6, 0xf7,
0x88, 0x10, 0xa4, 0x69, 0x43, 0xc0, 0x5e, 0xb1, 0xd2, 0xdf, 0x92, 0x0c, 0x59, 0xef, 0xae, 0x44,
0xf0, 0x74, 0xbe, 0xc4, 0x82, 0x91, 0xfe, 0x26, 0xed, 0x2a, 0xbb, 0x61, 0xf0, 0x66, 0x90, 0xb7,
0xab, 0x0c, 0x46, 0x5b, 0x41, 0xe9, 0x4f, 0x12, 0x90, 0x97, 0x9d, 0xab, 0xae, 0xa9, 0xcf, 0x9c,
0x4b, 0xcb, 0x5d, 0x13, 0x93, 0xff, 0x93, 0xcb, 0x7b, 0xb8, 0x35, 0x4b, 0x45, 0x5b, 0xb3, 0x50,
0xdb, 0x92, 0x0e, 0xb7, 0x2d, 0x54, 0xb2, 0x8a, 0x31, 0xfc, 0x3f, 0x28, 0xd9, 0x3f, 0x27, 0x60,
0x37, 0xe8, 0x70, 0xbe, 0x88, 0xa1, 0x8f, 0x5c, 0x02, 0x99, 0x69, 0x61, 0xdf, 0x98, 0x8f, 0x5c,
0x16, 0x74, 0x01, 0x6d, 0xd9, 0xb8, 0xe1, 0x23, 0x60, 0x09, 0x87, 0xe4, 0x17, 0xea, 0x3c, 0x4c,
0x4e, 0xc1, 0x03, 0xd2, 0x84, 0xf2, 0x39, 0x20, 0xd7, 0x72, 0xf5, 0x09, 0x89, 0x77, 0x87, 0x95,
0x3a, 0x3c, 0xe4, 0x3d, 0xad, 0x48, 0x31, 0x5d, 0xdd, 0x75, 0xaa, 0x0c, 0x4e, 0x96, 0x64, 0xd7,
0x1b, 0x1e, 0x81, 0xbc, 0x0c, 0xb3, 0xb1, 0x06, 0x57, 0x4a, 0xfa, 0x12, 0x76, 0x69, 0xec, 0xfa,
0xd2, 0xf0, 0x74, 0xbf, 0x66, 0x2a, 0xfa, 0x47, 0x09, 0xd8, 0x0b, 0x85, 0x8a, 0x6f, 0x94, 0xda,
0x8a, 0x57, 0x07, 0x47, 0xb1, 0xc1, 0xeb, 0x6f, 0xf9, 0xc3, 0xde, 0x8f, 0x48, 0xff, 0x94, 0x86,
0xbd, 0x88, 0x0e, 0xfc, 0x46, 0xb6, 0xda, 0x8f, 0x82, 0xea, 0x25, 0xc3, 0x33, 0x5c, 0x09, 0x0a,
0x33, 0x1b, 0xbf, 0xd3, 0x7c, 0x3c, 0x1b, 0x05, 0xe6, 0x09, 0xb0, 0xc2, 0x69, 0x56, 0x54, 0x83,
0xf4, 0xba, 0x6a, 0x50, 0x5f, 0x32, 0xce, 0xe6, 0x1d, 0x8c, 0x13, 0x57, 0x8b, 0x1e, 0x40, 0xde,
0x9b, 0x32, 0x13, 0xf9, 0x32, 0x34, 0x4d, 0x78, 0x63, 0xe6, 0xc6, 0x70, 0xa1, 0x9c, 0x7b, 0xcd,
0xe7, 0x19, 0x19, 0x8e, 0x44, 0x2f, 0xe0, 0xbe, 0xcf, 0xba, 0xba, 0x7a, 0xec, 0x73, 0xf2, 0xb3,
0x5f, 0x41, 0x11, 0xf9, 0xf9, 0xaa, 0x22, 0x72, 0xba, 0x08, 0x86, 0xb8, 0xc3, 0xbb, 0x53, 0x31,
0xd1, 0xef, 0x9a, 0xf3, 0xbf, 0x0a, 0xe7, 0xfc, 0x07, 0xf1, 0x39, 0xdf, 0x97, 0x21, 0x90, 0xfb,
0x5f, 0x78, 0x7d, 0x0a, 0xc9, 0xdd, 0xaa, 0xee, 0x92, 0x58, 0xe4, 0x31, 0xf2, 0x08, 0x04, 0x6f,
0xb0, 0x73, 0x85, 0x6f, 0x98, 0xb3, 0x0b, 0x6a, 0x9e, 0x0f, 0x77, 0x08, 0x48, 0xfa, 0x6d, 0x80,
0x05, 0x1f, 0x69, 0x6c, 0x02, 0x0c, 0x5e, 0x63, 0xb3, 0xa0, 0x47, 0x27, 0x7c, 0x1e, 0x44, 0x67,
0x1c, 0xc9, 0x55, 0x33, 0x0e, 0x3a, 0x0c, 0x22, 0xbf, 0x24, 0xd5, 0x6b, 0x84, 0x82, 0xc2, 0x71,
0xe7, 0x7f, 0xce, 0xa5, 0xb3, 0x29, 0x78, 0x79, 0x76, 0x1b, 0x60, 0xa1, 0x52, 0xb1, 0xdf, 0x8e,
0x34, 0x8e, 0x44, 0x93, 0xd7, 0xf1, 0xa0, 0x8f, 0xa1, 0xe8, 0xb8, 0xba, 0xed, 0x6a, 0x91, 0xc4,
0x20, 0x50, 0xa8, 0x17, 0x1a, 0x8f, 0x41, 0x34, 0xe7, 0x53, 0x46, 0x83, 0x1d, 0xad, 0xaf, 0x0f,
0xae, 0x78, 0xe8, 0x16, 0xcd, 0xf9, 0xb4, 0xc2, 0xc0, 0x15, 0x7d, 0x70, 0x25, 0xa9, 0xb0, 0x1f,
0xdd, 0x88, 0x8b, 0xfe, 0x35, 0x64, 0x38, 0x3f, 0x97, 0xfa, 0xc1, 0x7a, 0x5f, 0x51, 0x3d, 0xf2,
0xe3, 0x4f, 0xfd, 0x2f, 0x4e, 0xe8, 0x3c, 0xac, 0x00, 0xb9, 0xde, 0x6b, 0x45, 0x7e, 0xd9, 0x54,
0xba, 0x5d, 0x71, 0x03, 0xe5, 0x21, 0x23, 0xb7, 0xaa, 0xf5, 0xb6, 0xda, 0x15, 0x13, 0xc7, 0x7f,
0x9c, 0x80, 0x52, 0xcc, 0xdc, 0x9d, 0x7e, 0xb3, 0xd3, 0x63, 0x5f, 0xb8, 0xb0, 0xef, 0x59, 0xda,
0x1d, 0xa5, 0x25, 0x6e, 0xa0, 0x22, 0x00, 0x83, 0xd3, 0xe7, 0x04, 0xda, 0x81, 0x02, 0x7b, 0x56,
0xde, 0x74, 0x1a, 0xaa, 0x52, 0x13, 0x93, 0xe8, 0x00, 0x76, 0xc3, 0xac, 0x17, 0x9d, 0x9a, 0xdc,
0x53, 0xc4, 0x14, 0x12, 0x41, 0x60, 0x98, 0x6a, 0xb3, 0xdd, 0x55, 0x6a, 0x62, 0x1a, 0xdd, 0x83,
0x52, 0x98, 0x96, 0x7e, 0x10, 0x24, 0x6e, 0x1e, 0x7f, 0x05, 0x59, 0xef, 0xa4, 0x09, 0x5b, 0xaf,
0xa1, 0xa8, 0x5a, 0x4d, 0x39, 0x93, 0x2f, 0x9a, 0x3d, 0x71, 0x03, 0x01, 0x6c, 0x51, 0xc8, 0x53,
0x31, 0xe1, 0xff, 0xfe, 0x52, 0x4c, 0x1e, 0xff, 0x79, 0x02, 0x60, 0xd1, 0xe1, 0xa2, 0x12, 0x6c,
0xb7, 0xd5, 0x9a, 0xa2, 0x6a, 0xdd, 0x8b, 0xca, 0x79, 0xa3, 0xc7, 0xc6, 0xb8, 0x3b, 0x50, 0x60,
0xc0, 0x6a, 0x53, 0x91, 0x89, 0xc4, 0xf4, 0xad, 0x0b, 0x03, 0xf1, 0x4f, 0x8e, 0x9a, 0x6f, 0xb5,
0xb3, 0x46, 0xb3, 0x49, 0xb5, 0x41, 0x50, 0x64, 0x38, 0xe5, 0x8d, 0x52, 0xbd, 0x20, 0x4b, 0xa4,
0x16, 0xb0, 0xaa, 0xdc, 0xaa, 0x2a, 0x4d, 0xaa, 0x89, 0xbf, 0xac, 0x67, 0x88, 0x4d, 0x22, 0x37,
0x03, 0xf1, 0x6f, 0x81, 0xb6, 0x8e, 0x7f, 0x07, 0x4a, 0x31, 0x8d, 0x07, 0x39, 0xa0, 0x56, 0x5b,
0x3b, 0x97, 0xd5, 0x97, 0x4a, 0x8f, 0x49, 0xc8, 0x7e, 0x7b, 0x76, 0x4a, 0xa0, 0x5d, 0x10, 0xe5,
0x6a, 0x55, 0xe9, 0xf4, 0xe8, 0x51, 0x90, 0x45, 0xbb, 0x62, 0x12, 0x6d, 0x43, 0x9e, 0x13, 0xd2,
0xd3, 0x48, 0x9d, 0xfe, 0x67, 0xc6, 0xff, 0xca, 0x44, 0xf6, 0x5f, 0xc8, 0xa0, 0xef, 0xa1, 0x18,
0xfe, 0x2e, 0x18, 0x3d, 0x08, 0x5c, 0x5d, 0x63, 0x3e, 0x5a, 0x2e, 0x7f, 0xb8, 0x12, 0xcf, 0x7d,
0xb3, 0x07, 0xf9, 0xc0, 0x07, 0xb1, 0xe8, 0xd1, 0xd2, 0xf8, 0x27, 0xfa, 0x49, 0x70, 0x59, 0x5a,
0x47, 0xc2, 0x57, 0xfd, 0x19, 0x14, 0x42, 0x73, 0x14, 0xf4, 0xd1, 0x1d, 0x26, 0x3d, 0xe5, 0x8f,
0xd7, 0x13, 0x2d, 0x24, 0x0e, 0x7c, 0x2d, 0xbb, 0x24, 0xf1, 0xf2, 0x17, 0xbc, 0x4b, 0x12, 0xc7,
0x7d, 0x6c, 0xdb, 0x0b, 0x4f, 0x32, 0xa3, 0xab, 0x2e, 0x7f, 0x1b, 0xbb, 0xb4, 0x6a, 0xcc, 0x07,
0xaf, 0xe8, 0xfb, 0x90, 0x17, 0x3f, 0x8c, 0x1b, 0xcd, 0x06, 0x47, 0x45, 0xe5, 0x47, 0x6b, 0x28,
0xf8, 0x92, 0x6f, 0x61, 0xcf, 0x7f, 0x1f, 0x4a, 0xb3, 0x07, 0xf7, 0x0f, 0xb4, 0x28, 0xbc, 0x71,
0x9f, 0xd8, 0x96, 0x8f, 0xa2, 0x2f, 0x9c, 0x42, 0xe8, 0xc7, 0x89, 0xa7, 0x09, 0xf4, 0x1c, 0x36,
0xe9, 0x58, 0x00, 0xed, 0x45, 0xc7, 0x04, 0x4c, 0xba, 0xfd, 0xf8, 0xe9, 0x01, 0x6a, 0xc1, 0x5e,
0xa8, 0x71, 0xf2, 0x2f, 0x50, 0x47, 0xf1, 0x8d, 0xd5, 0xf2, 0x7a, 0xe1, 0xee, 0xba, 0x05, 0x85,
0x55, 0xeb, 0xc4, 0x5d, 0xee, 0xca, 0xb7, 0xa4, 0x53, 0x72, 0x0a, 0x81, 0xaa, 0x15, 0x3d, 0x85,
0xa5, 0x42, 0xb8, 0x74, 0x0a, 0x31, 0xd5, 0xe8, 0x7b, 0x28, 0x86, 0x93, 0x3d, 0x5a, 0x21, 0x84,
0xb3, 0x1c, 0x89, 0xf1, 0x55, 0xa2, 0xf2, 0xe4, 0x67, 0x9f, 0x8d, 0x0d, 0xf7, 0x72, 0xde, 0x3f,
0x19, 0x58, 0xd3, 0x2f, 0x26, 0xc6, 0xf8, 0xd2, 0x35, 0x0d, 0x73, 0x3c, 0xd1, 0xfb, 0xce, 0x17,
0x84, 0xf5, 0x8b, 0xc5, 0x9b, 0x59, 0x7b, 0x36, 0xe8, 0x6f, 0xd1, 0x3f, 0x5c, 0x78, 0xf6, 0xdf,
0x01, 0x00, 0x00, 0xff, 0xff, 0xa2, 0x17, 0xee, 0x85, 0xcc, 0x30, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

6
poolrpc/auctioneer.proto → auctioneerrpc/auctioneer.proto
View file

@ -1,8 +1,12 @@
syntax = "proto3";
// We can't rename this to auctioneerrpc, otherwise it would be a breaking
// change since the package name is also contained in the HTTP URIs and old
// clients would call the wrong endpoints. Luckily with the go_package option we
// can have different golang and RPC package names.
package poolrpc;
option go_package = "github.com/lightninglabs/pool/poolrpc";
option go_package = "github.com/lightninglabs/pool/auctioneerrpc";
service ChannelAuctioneer {
rpc ReserveAccount (ReserveAccountRequest) returns (ReserveAccountResponse);

11
auctioneerrpc/gen_protos.sh Executable file
View file

@ -0,0 +1,11 @@
#!/bin/sh
set -e
# Generate the gRPC bindings for all proto files.
for file in ./*.proto; do
protoc -I/usr/local/include -I. \
--go_out=plugins=grpc,paths=source_relative:. \
"${file}"
done

7
clientdb/order_event.go
View file

@ -5,6 +5,7 @@ import (
"io"
"time"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/event"
"github.com/lightninglabs/pool/order"
"github.com/lightninglabs/pool/poolrpc"
@ -440,7 +441,7 @@ func (db *DB) StoreBatchEvents(batch *order.Batch, state order.MatchState,
// orders involved in a batch and stores it to the main event store, including
// the reason for the reject.
func (db *DB) StoreBatchPartialRejectEvents(batch *order.Batch,
partialRejects map[order.Nonce]*poolrpc.OrderReject) error {
partialRejects map[order.Nonce]*auctioneerrpc.OrderReject) error {
// In case an order itself wasn't rejected but was just in the same
// batch as a reject, we mark it in the event as such. If it was, this
@ -472,10 +473,10 @@ func (db *DB) StoreBatchPartialRejectEvents(batch *order.Batch,
reject, ok := partialRejects[otherNonce]
if ok {
switch reject.ReasonCode {
case poolrpc.OrderReject_CHANNEL_FUNDING_FAILED:
case auctioneerrpc.OrderReject_CHANNEL_FUNDING_FAILED:
evt.RejectReason = reasonFundingFailed
case poolrpc.OrderReject_DUPLICATE_PEER:
case auctioneerrpc.OrderReject_DUPLICATE_PEER:
evt.RejectReason = reasonDuplicatePeer
}
}

7
cmd/pool/auction.go
View file

@ -6,6 +6,7 @@ import (
"fmt"
"github.com/btcsuite/btcd/chaincfg/chainhash"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/poolrpc"
"github.com/urfave/cli"
)
@ -51,7 +52,7 @@ func NewLeaseFromProto(a *poolrpc.Lease) *Lease {
// Markets is a simple type alias to make the following Snapshot struct more
// compact.
type Markets = map[uint32]*poolrpc.MatchedMarketSnapshot
type Markets = map[uint32]*auctioneerrpc.MatchedMarketSnapshot
// Snapshot is a copy of poolrpc.BatchSnapshotResponse that does not include the
// deprecated fields.
@ -67,7 +68,7 @@ type Snapshot struct {
}
// NewSnapshotsFromProtos creates a display Snapshot from its proto.
func NewSnapshotsFromProto(s []*poolrpc.BatchSnapshotResponse) []*Snapshot {
func NewSnapshotsFromProto(s []*auctioneerrpc.BatchSnapshotResponse) []*Snapshot {
result := make([]*Snapshot, len(s))
for idx, snapshot := range s {
result[idx] = &Snapshot{
@ -192,7 +193,7 @@ func batchSnapshot(ctx *cli.Context) error {
}
resp, err := client.BatchSnapshots(
ctxb, &poolrpc.BatchSnapshotsRequest{
ctxb, &auctioneerrpc.BatchSnapshotsRequest{
StartBatchId: batchID,
NumBatchesBack: uint32(ctx.Uint64("num_batches")),
},

26
funding/manager.go
View file

@ -12,10 +12,10 @@ import (
"github.com/btcsuite/btcd/chaincfg/chainhash"
"github.com/btcsuite/btcd/wire"
"github.com/lightninglabs/lndclient"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/chaninfo"
"github.com/lightninglabs/pool/clientdb"
"github.com/lightninglabs/pool/order"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightningnetwork/lnd/input"
"github.com/lightningnetwork/lnd/lnrpc"
"github.com/lightningnetwork/lnd/routing/route"
@ -41,7 +41,7 @@ var (
type MatchRejectErr struct {
// RejectedOrders is the map of matches we reject, keyed with our order
// nonce.
RejectedOrders map[order.Nonce]*poolrpc.OrderReject
RejectedOrders map[order.Nonce]*auctioneerrpc.OrderReject
}
// Error returns the underlying error string.
@ -368,7 +368,7 @@ func (m *Manager) BatchChannelSetup(batch *order.Batch,
var (
eg errgroup.Group
chanPoints = make(map[wire.OutPoint]order.Nonce)
fundingRejects = make(map[order.Nonce]*poolrpc.OrderReject)
fundingRejects = make(map[order.Nonce]*auctioneerrpc.OrderReject)
fundingRejectsMtx sync.Mutex
)
partialReject := func(nonce order.Nonce, reason string,
@ -377,8 +377,8 @@ func (m *Manager) BatchChannelSetup(batch *order.Batch,
fundingRejectsMtx.Lock()
defer fundingRejectsMtx.Unlock()
fundingRejects[nonce] = &poolrpc.OrderReject{
ReasonCode: poolrpc.OrderReject_CHANNEL_FUNDING_FAILED,
fundingRejects[nonce] = &auctioneerrpc.OrderReject{
ReasonCode: auctioneerrpc.OrderReject_CHANNEL_FUNDING_FAILED,
Reason: reason,
}
@ -797,7 +797,7 @@ func (m *Manager) waitForPeerConnections(ctx context.Context,
// rejected because they would create channels to peers that the trader already
// has channels with.
func (m *Manager) rejectDuplicateChannels(
batch *order.Batch) (map[order.Nonce]*poolrpc.OrderReject, error) {
batch *order.Batch) (map[order.Nonce]*auctioneerrpc.OrderReject, error) {
// We gather all peers from the open and pending channels.
ctxb := context.Background()
@ -822,8 +822,8 @@ func (m *Manager) rejectDuplicateChannels(
// Gather the list of matches we reject because they are to peers we
// already have channels with.
const haveChannel = "already have open/pending channel with peer"
const rejectCode = poolrpc.OrderReject_DUPLICATE_PEER
fundingRejects := make(map[order.Nonce]*poolrpc.OrderReject)
const rejectCode = auctioneerrpc.OrderReject_DUPLICATE_PEER
fundingRejects := make(map[order.Nonce]*auctioneerrpc.OrderReject)
for _, matchedOrders := range batch.MatchedOrders {
for _, matchedOrder := range matchedOrders {
_, ok := peers[matchedOrder.NodeKey]
@ -834,7 +834,7 @@ func (m *Manager) rejectDuplicateChannels(
log.Debugf("Rejecting channel to node %x: %v",
matchedOrder.NodeKey[:], haveChannel)
otherNonce := matchedOrder.Order.Nonce()
fundingRejects[otherNonce] = &poolrpc.OrderReject{
fundingRejects[otherNonce] = &auctioneerrpc.OrderReject{
ReasonCode: rejectCode,
Reason: haveChannel,
}
@ -847,13 +847,13 @@ func (m *Manager) rejectDuplicateChannels(
// rejectFailedConnections gathers a list of all matched orders that are to
// peers to which we couldn't connect and want to reject because of that.
func (m *Manager) rejectFailedConnections(peers map[route.Vertex]struct{},
batch *order.Batch) map[order.Nonce]*poolrpc.OrderReject {
batch *order.Batch) map[order.Nonce]*auctioneerrpc.OrderReject {
// Gather the list of matches we reject because the connection to them
// failed.
const connFailed = "connection not established before timeout"
const rejectCode = poolrpc.OrderReject_CHANNEL_FUNDING_FAILED
fundingRejects := make(map[order.Nonce]*poolrpc.OrderReject)
const rejectCode = auctioneerrpc.OrderReject_CHANNEL_FUNDING_FAILED
fundingRejects := make(map[order.Nonce]*auctioneerrpc.OrderReject)
for _, matchedOrders := range batch.MatchedOrders {
for _, matchedOrder := range matchedOrders {
_, ok := peers[matchedOrder.NodeKey]
@ -864,7 +864,7 @@ func (m *Manager) rejectFailedConnections(peers map[route.Vertex]struct{},
log.Debugf("Rejecting channel to node %x: %v",
matchedOrder.NodeKey[:], connFailed)
otherNonce := matchedOrder.Order.Nonce()
fundingRejects[otherNonce] = &poolrpc.OrderReject{
fundingRejects[otherNonce] = &auctioneerrpc.OrderReject{
ReasonCode: rejectCode,
Reason: connFailed,
}

22
funding/manager_test.go
View file

@ -13,10 +13,10 @@ import (
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/lndclient"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/clientdb"
"github.com/lightninglabs/pool/internal/test"
"github.com/lightninglabs/pool/order"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightningnetwork/lnd/input"
"github.com/lightningnetwork/lnd/keychain"
"github.com/lightningnetwork/lnd/lnrpc"
@ -385,9 +385,9 @@ func TestFundingManager(t *testing.T) {
require.Error(t, err)
expectedErr := &MatchRejectErr{
RejectedOrders: map[order.Nonce]*poolrpc.OrderReject{
RejectedOrders: map[order.Nonce]*auctioneerrpc.OrderReject{
ask.Nonce(): {
ReasonCode: poolrpc.OrderReject_DUPLICATE_PEER,
ReasonCode: auctioneerrpc.OrderReject_DUPLICATE_PEER,
Reason: "already have open/pending channel " +
"with peer",
},
@ -403,9 +403,9 @@ func TestFundingManager(t *testing.T) {
require.Error(t, err)
expectedErr = &MatchRejectErr{
RejectedOrders: map[order.Nonce]*poolrpc.OrderReject{
RejectedOrders: map[order.Nonce]*auctioneerrpc.OrderReject{
ask.Nonce(): {
ReasonCode: poolrpc.OrderReject_CHANNEL_FUNDING_FAILED,
ReasonCode: auctioneerrpc.OrderReject_CHANNEL_FUNDING_FAILED,
Reason: "connection not established before " +
"timeout",
},
@ -461,13 +461,13 @@ func TestFundingManager(t *testing.T) {
_, err = h.mgr.BatchChannelSetup(batch, h.quit)
require.Error(t, err)
code := &poolrpc.OrderReject{
ReasonCode: poolrpc.OrderReject_CHANNEL_FUNDING_FAILED,
code := &auctioneerrpc.OrderReject{
ReasonCode: auctioneerrpc.OrderReject_CHANNEL_FUNDING_FAILED,
Reason: "timed out waiting for pending open " +
"channel notification",
}
expectedErr = &MatchRejectErr{
RejectedOrders: map[order.Nonce]*poolrpc.OrderReject{
RejectedOrders: map[order.Nonce]*auctioneerrpc.OrderReject{
ask.Nonce(): code,
bid.Nonce(): code,
},
@ -566,12 +566,12 @@ func TestWaitForPeerConnections(t *testing.T) {
)
require.Error(t, err)
code := &poolrpc.OrderReject{
ReasonCode: poolrpc.OrderReject_CHANNEL_FUNDING_FAILED,
code := &auctioneerrpc.OrderReject{
ReasonCode: auctioneerrpc.OrderReject_CHANNEL_FUNDING_FAILED,
Reason: "connection not established before timeout",
}
expectedErr := &MatchRejectErr{
RejectedOrders: map[order.Nonce]*poolrpc.OrderReject{
RejectedOrders: map[order.Nonce]*auctioneerrpc.OrderReject{
fakeNonce2: code,
},
}

12
order/batch.go
View file

@ -11,7 +11,7 @@ import (
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/lndclient"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/poolscript"
"github.com/lightninglabs/pool/terms"
"github.com/lightningnetwork/lnd/input"
@ -72,7 +72,7 @@ type AccountDiff struct {
// EndingState is the ending on-chain state of the account after the
// executed batch as the auctioneer calculated it.
EndingState poolrpc.AccountDiff_AccountState
EndingState auctioneerrpc.AccountDiff_AccountState
// EndingBalance is the ending balance for a trader's account.
EndingBalance btcutil.Amount
@ -101,9 +101,9 @@ func (d *AccountDiff) validateEndingState(tx *wire.MsgTx,
// by a simple transaction and not create a dust output. We
// expect the server to set the state correctly and not re-
// create an account outpoint.
if state != poolrpc.AccountDiff_OUTPUT_DUST_EXTENDED_OFFCHAIN &&
state != poolrpc.AccountDiff_OUTPUT_DUST_ADDED_TO_FEES &&
state != poolrpc.AccountDiff_OUTPUT_FULLY_SPENT {
if state != auctioneerrpc.AccountDiff_OUTPUT_DUST_EXTENDED_OFFCHAIN &&
state != auctioneerrpc.AccountDiff_OUTPUT_DUST_ADDED_TO_FEES &&
state != auctioneerrpc.AccountDiff_OUTPUT_FULLY_SPENT {
return wrongStateErr
}
@ -114,7 +114,7 @@ func (d *AccountDiff) validateEndingState(tx *wire.MsgTx,
} else {
// There should be enough balance left to justify a new account
// output. We should get the outpoint from the server.
if state != poolrpc.AccountDiff_OUTPUT_RECREATED {
if state != auctioneerrpc.AccountDiff_OUTPUT_RECREATED {
return wrongStateErr
}
if d.OutpointIndex < 0 {

10
order/batch_storer.go
View file

@ -6,7 +6,7 @@ import (
"github.com/btcsuite/btcd/btcec"
"github.com/btcsuite/btcd/wire"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/auctioneerrpc"
)
const (
@ -102,7 +102,7 @@ func (s *batchStorer) StorePendingBatch(batch *Batch, bestHeight uint32) error {
switch diff.EndingState {
// The account output has been recreated and needs to wait to be
// confirmed again.
case poolrpc.AccountDiff_OUTPUT_RECREATED:
case auctioneerrpc.AccountDiff_OUTPUT_RECREATED:
modifiers = append(
modifiers,
account.StateModifier(account.StatePendingBatch),
@ -115,9 +115,9 @@ func (s *batchStorer) StorePendingBatch(batch *Batch, bestHeight uint32) error {
// The account was fully spent on-chain. We need to wait for the
// batch (spend) TX to be confirmed still.
case poolrpc.AccountDiff_OUTPUT_FULLY_SPENT,
poolrpc.AccountDiff_OUTPUT_DUST_ADDED_TO_FEES,
poolrpc.AccountDiff_OUTPUT_DUST_EXTENDED_OFFCHAIN:
case auctioneerrpc.AccountDiff_OUTPUT_FULLY_SPENT,
auctioneerrpc.AccountDiff_OUTPUT_DUST_ADDED_TO_FEES,
auctioneerrpc.AccountDiff_OUTPUT_DUST_EXTENDED_OFFCHAIN:
modifiers = append(
modifiers,

6
order/batch_storer_test.go
View file

@ -5,7 +5,7 @@ import (
"github.com/btcsuite/btcd/wire"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightningnetwork/lnd/keychain"
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
)
@ -67,14 +67,14 @@ func TestBatchStorer(t *testing.T) {
{
AccountKeyRaw: acctIDBig,
AccountKey: acctKeyBig,
EndingState: poolrpc.AccountDiff_OUTPUT_RECREATED,
EndingState: auctioneerrpc.AccountDiff_OUTPUT_RECREATED,
OutpointIndex: 0,
EndingBalance: 600_000,
},
{
AccountKeyRaw: acctIDSmall,
AccountKey: acctKeySmall,
EndingState: poolrpc.AccountDiff_OUTPUT_FULLY_SPENT,
EndingState: auctioneerrpc.AccountDiff_OUTPUT_FULLY_SPENT,
OutpointIndex: -1,
EndingBalance: 0,
},

6
order/batch_verifier_test.go
View file

@ -9,8 +9,8 @@ import (
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/internal/test"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/terms"
"github.com/lightningnetwork/lnd/input"
"github.com/lightningnetwork/lnd/keychain"
@ -29,8 +29,8 @@ var (
execFeeRate = btcutil.Amount(50)
clearingPrice = FixedRatePremium(5000)
leaseDuration = uint32(1000)
stateRecreated = poolrpc.AccountDiff_OUTPUT_RECREATED
stateExtendedOffchain = poolrpc.AccountDiff_OUTPUT_DUST_EXTENDED_OFFCHAIN
stateRecreated = auctioneerrpc.AccountDiff_OUTPUT_RECREATED
stateExtendedOffchain = auctioneerrpc.AccountDiff_OUTPUT_DUST_EXTENDED_OFFCHAIN
)
func TestBatchVerifier(t *testing.T) {

4
order/interface.go
View file

@ -10,7 +10,7 @@ import (
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/terms"
"github.com/lightningnetwork/lnd/keychain"
"github.com/lightningnetwork/lnd/lntypes"
@ -633,7 +633,7 @@ type Store interface {
// an invalid action or information provided by the user.
type UserError struct {
FailMsg string
Details *poolrpc.InvalidOrder
Details *auctioneerrpc.InvalidOrder
}
// Error returns the string representation of the underlying failure message.

6
order/manager_test.go
View file

@ -5,7 +5,7 @@ import (
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/terms"
"github.com/lightningnetwork/lnd/keychain"
)
@ -55,8 +55,8 @@ func TestValidateOrderAccountIsolation(t *testing.T) {
testTerms := &terms.AuctioneerTerms{
OrderExecBaseFee: 1,
OrderExecFeeRate: 100,
LeaseDurationBuckets: map[uint32]poolrpc.DurationBucketState{
144: poolrpc.DurationBucketState_MARKET_OPEN,
LeaseDurationBuckets: map[uint32]auctioneerrpc.DurationBucketState{
144: auctioneerrpc.DurationBucketState_MARKET_OPEN,
},
}

14
order/rpc_parse.go
View file

@ -11,6 +11,7 @@ import (
"github.com/btcsuite/btcd/btcec"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/terms"
"github.com/lightningnetwork/lnd/lntypes"
@ -66,7 +67,8 @@ func ParseRPCOrder(version, leaseDuration uint32,
// parseNodeAddrs parses the set of address in strong format as returned over
// the RPC layer into a proper interface we can use.
func parseNodeAddrs(rpcAddrs []*poolrpc.NodeAddress, orderIsAsk bool) ([]net.Addr, error) {
func parseNodeAddrs(rpcAddrs []*auctioneerrpc.NodeAddress,
orderIsAsk bool) ([]net.Addr, error) {
if len(rpcAddrs) == 0 && orderIsAsk {
return nil, fmt.Errorf("ask order doesn't include any node " +
@ -109,7 +111,7 @@ func parseNodeAddrs(rpcAddrs []*poolrpc.NodeAddress, orderIsAsk bool) ([]net.Add
// ParseRPCServerOrder parses the incoming raw RPC server order into the go
// native data types used in the order struct.
func ParseRPCServerOrder(version uint32, details *poolrpc.ServerOrder,
func ParseRPCServerOrder(version uint32, details *auctioneerrpc.ServerOrder,
orderIsAsk bool, leaseDuration uint32) (*Kit, [33]byte, []net.Addr, [33]byte, error) {
var (
@ -171,7 +173,7 @@ func ParseRPCServerOrder(version uint32, details *poolrpc.ServerOrder,
// ParseRPCServerAsk parses the incoming raw RPC server ask into the go
// native data types used in the order struct.
func ParseRPCServerAsk(details *poolrpc.ServerAsk) (*MatchedOrder, error) {
func ParseRPCServerAsk(details *auctioneerrpc.ServerAsk) (*MatchedOrder, error) {
var (
o = &MatchedOrder{}
kit *Kit
@ -196,7 +198,7 @@ func ParseRPCServerAsk(details *poolrpc.ServerAsk) (*MatchedOrder, error) {
// ParseRPCServerBid parses the incoming raw RPC server bid into the go
// native data types used in the order struct.
func ParseRPCServerBid(details *poolrpc.ServerBid) (*MatchedOrder, error) {
func ParseRPCServerBid(details *auctioneerrpc.ServerBid) (*MatchedOrder, error) {
var (
o = &MatchedOrder{}
kit *Kit
@ -219,7 +221,7 @@ func ParseRPCServerBid(details *poolrpc.ServerBid) (*MatchedOrder, error) {
// ParseRPCBatch parses the incoming raw RPC batch into the go native data types
// used by the order manager.
func ParseRPCBatch(prepareMsg *poolrpc.OrderMatchPrepare) (*Batch,
func ParseRPCBatch(prepareMsg *auctioneerrpc.OrderMatchPrepare) (*Batch,
error) {
b := &Batch{
@ -325,7 +327,7 @@ func ParseRPCBatch(prepareMsg *poolrpc.OrderMatchPrepare) (*Batch,
// ParseRPCMatchedOrders parses the incoming raw RPC matched orders into the go
// native structs used by the order manager.
func ParseRPCMatchedOrders(orders *poolrpc.MatchedOrder) ([]*MatchedOrder,
func ParseRPCMatchedOrders(orders *auctioneerrpc.MatchedOrder) ([]*MatchedOrder,
error) {
var result []*MatchedOrder

13
poolrpc/gen_protos.sh
View file

@ -3,19 +3,18 @@
set -e
# Generate the gRPC bindings for all proto files.
for file in ./*.proto
do
protoc -I/usr/local/include -I. \
--go_out=plugins=grpc,paths=source_relative:. \
"${file}"
for file in ./*.proto; do
protoc -I/usr/local/include -I. -I.. \
--go_out=plugins=grpc,paths=source_relative:. \
"${file}"
# Generate the REST reverse proxy.
protoc -I/usr/local/include -I. \
protoc -I/usr/local/include -I. -I.. \
--grpc-gateway_out=logtostderr=true,paths=source_relative,grpc_api_configuration=rest-annotations.yaml:. \
"${file}"
# Finally, generate the swagger file which describes the REST API in detail.
protoc -I/usr/local/include -I. \
protoc -I/usr/local/include -I. -I.. \
--swagger_out=logtostderr=true,grpc_api_configuration=rest-annotations.yaml:. \
"${file}"

479
poolrpc/trader.pb.go
View file

@ -7,6 +7,7 @@ import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
auctioneerrpc "github.com/lightninglabs/pool/auctioneerrpc"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
@ -1275,7 +1276,7 @@ type Account struct {
//
//The current outpoint associated with the account. This will change every
//time the account has been updated.
Outpoint *OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
Outpoint *auctioneerrpc.OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
// The current total amount of satoshis in the account.
Value uint64 `protobuf:"varint,3,opt,name=value,proto3" json:"value,omitempty"`
//
@ -1325,7 +1326,7 @@ func (m *Account) GetTraderKey() []byte {
return nil
}
func (m *Account) GetOutpoint() *OutPoint {
func (m *Account) GetOutpoint() *auctioneerrpc.OutPoint {
if m != nil {
return m.Outpoint
}
@ -1487,7 +1488,7 @@ type isSubmitOrderResponse_Details interface {
}
type SubmitOrderResponse_InvalidOrder struct {
InvalidOrder *InvalidOrder `protobuf:"bytes,1,opt,name=invalid_order,json=invalidOrder,proto3,oneof"`
InvalidOrder *auctioneerrpc.InvalidOrder `protobuf:"bytes,1,opt,name=invalid_order,json=invalidOrder,proto3,oneof"`
}
type SubmitOrderResponse_AcceptedOrderNonce struct {
@ -1505,7 +1506,7 @@ func (m *SubmitOrderResponse) GetDetails() isSubmitOrderResponse_Details {
return nil
}
func (m *SubmitOrderResponse) GetInvalidOrder() *InvalidOrder {
func (m *SubmitOrderResponse) GetInvalidOrder() *auctioneerrpc.InvalidOrder {
if x, ok := m.GetDetails().(*SubmitOrderResponse_InvalidOrder); ok {
return x.InvalidOrder
}
@ -1715,7 +1716,7 @@ type Order struct {
OrderNonce []byte `protobuf:"bytes,5,opt,name=order_nonce,json=orderNonce,proto3" json:"order_nonce,omitempty"`
//
//The state the order currently is in.
State OrderState `protobuf:"varint,6,opt,name=state,proto3,enum=poolrpc.OrderState" json:"state,omitempty"`
State auctioneerrpc.OrderState `protobuf:"varint,6,opt,name=state,proto3,enum=poolrpc.OrderState" json:"state,omitempty"`
//
//The number of order units the amount corresponds to.
Units uint32 `protobuf:"varint,7,opt,name=units,proto3" json:"units,omitempty"`
@ -1800,11 +1801,11 @@ func (m *Order) GetOrderNonce() []byte {
return nil
}
func (m *Order) GetState() OrderState {
func (m *Order) GetState() auctioneerrpc.OrderState {
if m != nil {
return m.State
}
return OrderState_ORDER_SUBMITTED
return auctioneerrpc.OrderState_ORDER_SUBMITTED
}
func (m *Order) GetUnits() uint32 {
@ -1864,10 +1865,10 @@ type Bid struct {
//
//The minium node tier this order should be matched with. Only asks backed by
//a node this tier or higher will be eligible for matching with this bid.
MinNodeTier NodeTier `protobuf:"varint,4,opt,name=min_node_tier,json=minNodeTier,proto3,enum=poolrpc.NodeTier" json:"min_node_tier,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
MinNodeTier auctioneerrpc.NodeTier `protobuf:"varint,4,opt,name=min_node_tier,json=minNodeTier,proto3,enum=poolrpc.NodeTier" json:"min_node_tier,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Bid) Reset() { *m = Bid{} }
@ -1916,11 +1917,11 @@ func (m *Bid) GetVersion() uint32 {
return 0
}
func (m *Bid) GetMinNodeTier() NodeTier {
func (m *Bid) GetMinNodeTier() auctioneerrpc.NodeTier {
if m != nil {
return m.MinNodeTier
}
return NodeTier_TIER_DEFAULT
return auctioneerrpc.NodeTier_TIER_DEFAULT
}
type Ask struct {
@ -2090,11 +2091,11 @@ type UpdatedEvent struct {
//
//The state of the order previous to the change. This is what the state
//changed from.
PreviousState OrderState `protobuf:"varint,1,opt,name=previous_state,json=previousState,proto3,enum=poolrpc.OrderState" json:"previous_state,omitempty"`
PreviousState auctioneerrpc.OrderState `protobuf:"varint,1,opt,name=previous_state,json=previousState,proto3,enum=poolrpc.OrderState" json:"previous_state,omitempty"`
//
//The new state of the order after the change. This is what the state changed
//to.
NewState OrderState `protobuf:"varint,2,opt,name=new_state,json=newState,proto3,enum=poolrpc.OrderState" json:"new_state,omitempty"`
NewState auctioneerrpc.OrderState `protobuf:"varint,2,opt,name=new_state,json=newState,proto3,enum=poolrpc.OrderState" json:"new_state,omitempty"`
// The units that were filled at the time of the event.
UnitsFilled uint32 `protobuf:"varint,3,opt,name=units_filled,json=unitsFilled,proto3" json:"units_filled,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -2127,18 +2128,18 @@ func (m *UpdatedEvent) XXX_DiscardUnknown() {
var xxx_messageInfo_UpdatedEvent proto.InternalMessageInfo
func (m *UpdatedEvent) GetPreviousState() OrderState {
func (m *UpdatedEvent) GetPreviousState() auctioneerrpc.OrderState {
if m != nil {
return m.PreviousState
}
return OrderState_ORDER_SUBMITTED
return auctioneerrpc.OrderState_ORDER_SUBMITTED
}
func (m *UpdatedEvent) GetNewState() OrderState {
func (m *UpdatedEvent) GetNewState() auctioneerrpc.OrderState {
if m != nil {
return m.NewState
}
return OrderState_ORDER_SUBMITTED
return auctioneerrpc.OrderState_ORDER_SUBMITTED
}
func (m *UpdatedEvent) GetUnitsFilled() uint32 {
@ -2322,10 +2323,10 @@ var xxx_messageInfo_AuctionFeeRequest proto.InternalMessageInfo
type AuctionFeeResponse struct {
//
//The execution fee charged per matched order.
ExecutionFee *ExecutionFee `protobuf:"bytes,1,opt,name=execution_fee,json=executionFee,proto3" json:"execution_fee,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
ExecutionFee *auctioneerrpc.ExecutionFee `protobuf:"bytes,1,opt,name=execution_fee,json=executionFee,proto3" json:"execution_fee,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AuctionFeeResponse) Reset() { *m = AuctionFeeResponse{} }
@ -2353,7 +2354,7 @@ func (m *AuctionFeeResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_AuctionFeeResponse proto.InternalMessageInfo
func (m *AuctionFeeResponse) GetExecutionFee() *ExecutionFee {
func (m *AuctionFeeResponse) GetExecutionFee() *auctioneerrpc.ExecutionFee {
if m != nil {
return m.ExecutionFee
}
@ -2362,7 +2363,7 @@ func (m *AuctionFeeResponse) GetExecutionFee() *ExecutionFee {
type Lease struct {
// The outpoint of the channel created.
ChannelPoint *OutPoint `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"`
ChannelPoint *auctioneerrpc.OutPoint `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"`
// The amount, in satoshis, of the channel created.
ChannelAmtSat uint64 `protobuf:"varint,2,opt,name=channel_amt_sat,json=channelAmtSat,proto3" json:"channel_amt_sat,omitempty"`
// The intended duration, in blocks, of the channel created.
@ -2395,10 +2396,10 @@ type Lease struct {
// The pubkey of the node that this channel was bought/sold from.
ChannelRemoteNodeKey []byte `protobuf:"bytes,12,opt,name=channel_remote_node_key,json=channelRemoteNodeKey,proto3" json:"channel_remote_node_key,omitempty"`
// The tier of the node that this channel was bought/sold from.
ChannelNodeTier NodeTier `protobuf:"varint,13,opt,name=channel_node_tier,json=channelNodeTier,proto3,enum=poolrpc.NodeTier" json:"channel_node_tier,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
ChannelNodeTier auctioneerrpc.NodeTier `protobuf:"varint,13,opt,name=channel_node_tier,json=channelNodeTier,proto3,enum=poolrpc.NodeTier" json:"channel_node_tier,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Lease) Reset() { *m = Lease{} }
@ -2426,7 +2427,7 @@ func (m *Lease) XXX_DiscardUnknown() {
var xxx_messageInfo_Lease proto.InternalMessageInfo
func (m *Lease) GetChannelPoint() *OutPoint {
func (m *Lease) GetChannelPoint() *auctioneerrpc.OutPoint {
if m != nil {
return m.ChannelPoint
}
@ -2510,11 +2511,11 @@ func (m *Lease) GetChannelRemoteNodeKey() []byte {
return nil
}
func (m *Lease) GetChannelNodeTier() NodeTier {
func (m *Lease) GetChannelNodeTier() auctioneerrpc.NodeTier {
if m != nil {
return m.ChannelNodeTier
}
return NodeTier_TIER_DEFAULT
return auctioneerrpc.NodeTier_TIER_DEFAULT
}
type LeasesRequest struct {
@ -2852,10 +2853,10 @@ type LeaseDurationResponse struct {
//
//The set of lease durations the market is currently accepting and the state
//the duration buckets currently are in.
LeaseDurationBuckets map[uint32]DurationBucketState `protobuf:"bytes,2,rep,name=lease_duration_buckets,json=leaseDurationBuckets,proto3" json:"lease_duration_buckets,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=poolrpc.DurationBucketState"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
LeaseDurationBuckets map[uint32]auctioneerrpc.DurationBucketState `protobuf:"bytes,2,rep,name=lease_duration_buckets,json=leaseDurationBuckets,proto3" json:"lease_duration_buckets,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=poolrpc.DurationBucketState"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LeaseDurationResponse) Reset() { *m = LeaseDurationResponse{} }
@ -2891,7 +2892,7 @@ func (m *LeaseDurationResponse) GetLeaseDurations() map[uint32]bool {
return nil
}
func (m *LeaseDurationResponse) GetLeaseDurationBuckets() map[uint32]DurationBucketState {
func (m *LeaseDurationResponse) GetLeaseDurationBuckets() map[uint32]auctioneerrpc.DurationBucketState {
if m != nil {
return m.LeaseDurationBuckets
}
@ -3035,10 +3036,10 @@ func (m *NodeRatingRequest) GetNodePubkeys() [][]byte {
type NodeRatingResponse struct {
// A series of node ratings for each of the queried nodes.
NodeRatings []*NodeRating `protobuf:"bytes,1,rep,name=node_ratings,json=nodeRatings,proto3" json:"node_ratings,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
NodeRatings []*auctioneerrpc.NodeRating `protobuf:"bytes,1,rep,name=node_ratings,json=nodeRatings,proto3" json:"node_ratings,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *NodeRatingResponse) Reset() { *m = NodeRatingResponse{} }
@ -3066,7 +3067,7 @@ func (m *NodeRatingResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_NodeRatingResponse proto.InternalMessageInfo
func (m *NodeRatingResponse) GetNodeRatings() []*NodeRating {
func (m *NodeRatingResponse) GetNodeRatings() []*auctioneerrpc.NodeRating {
if m != nil {
return m.NodeRatings
}
@ -3120,7 +3121,7 @@ func init() {
proto.RegisterType((*LsatToken)(nil), "poolrpc.LsatToken")
proto.RegisterType((*LeaseDurationRequest)(nil), "poolrpc.LeaseDurationRequest")
proto.RegisterType((*LeaseDurationResponse)(nil), "poolrpc.LeaseDurationResponse")
proto.RegisterMapType((map[uint32]DurationBucketState)(nil), "poolrpc.LeaseDurationResponse.LeaseDurationBucketsEntry")
proto.RegisterMapType((map[uint32]auctioneerrpc.DurationBucketState)(nil), "poolrpc.LeaseDurationResponse.LeaseDurationBucketsEntry")
proto.RegisterMapType((map[uint32]bool)(nil), "poolrpc.LeaseDurationResponse.LeaseDurationsEntry")
proto.RegisterType((*NextBatchInfoRequest)(nil), "poolrpc.NextBatchInfoRequest")
proto.RegisterType((*NextBatchInfoResponse)(nil), "poolrpc.NextBatchInfoResponse")
@ -3131,7 +3132,7 @@ func init() {
func init() { proto.RegisterFile("trader.proto", fileDescriptor_b8f61804588c75fe) }
var fileDescriptor_b8f61804588c75fe = []byte{
// 2994 bytes of a gzipped FileDescriptorProto
// 3002 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x3a, 0x49, 0x73, 0x1b, 0xc7,
0xd5, 0x1c, 0x70, 0x7f, 0x58, 0x08, 0x36, 0x48, 0x8a, 0xa6, 0x4c, 0x4b, 0x9a, 0xaf, 0x6c, 0x4b,
0xb2, 0x3f, 0xc9, 0x61, 0x2c, 0xc5, 0x51, 0x9c, 0xd8, 0x00, 0x39, 0x34, 0x10, 0x51, 0x20, 0xdc,
@ -3139,187 +3140,187 @@ var fileDescriptor_b8f61804588c75fe = []byte{
0x9c, 0x92, 0x7b, 0x52, 0x4e, 0x25, 0xd7, 0xfc, 0x89, 0xdc, 0x52, 0x95, 0x43, 0x4e, 0xa9, 0x8a,
0x2f, 0xf9, 0x01, 0xf9, 0x1d, 0xb9, 0xa6, 0x7a, 0xc3, 0xf4, 0x0c, 0x06, 0xde, 0x2e, 0xb9, 0x71,
0xde, 0xd2, 0xfd, 0xf6, 0xf7, 0xfa, 0x81, 0x50, 0x62, 0x11, 0xf1, 0x68, 0xf4, 0x68, 0x14, 0x85,
0x2c, 0x44, 0xcb, 0xa3, 0x30, 0x1c, 0x44, 0xa3, 0xfe, 0x4e, 0x95, 0x8c, 0xfb, 0xcc, 0x0f, 0x03,
0xaa, 0x51, 0xf6, 0x57, 0x16, 0xa0, 0x56, 0xe0, 0xb3, 0x7a, 0xbf, 0x1f, 0x8e, 0x03, 0x86, 0xe9,
0xaf, 0xc6, 0x34, 0x66, 0xe8, 0xff, 0xa0, 0x4c, 0x24, 0xc4, 0xbd, 0x24, 0x83, 0x31, 0xdd, 0xb6,
0xee, 0x5a, 0xf7, 0x17, 0x70, 0x49, 0x01, 0x5f, 0x71, 0x18, 0x7a, 0x00, 0x6b, 0xa4, 0x17, 0x87,
0x83, 0x31, 0xa3, 0xee, 0x39, 0xf5, 0xcf, 0xce, 0xd9, 0x76, 0xe1, 0xae, 0x75, 0xbf, 0xdc, 0x9c,
0xc3, 0x15, 0x8d, 0x68, 0x0a, 0x38, 0x27, 0x8d, 0xe8, 0x80, 0x30, 0xff, 0x72, 0x42, 0x3a, 0xaf,
0x49, 0x35, 0x42, 0x91, 0xde, 0x83, 0x62, 0x3f, 0x0c, 0x4e, 0x5d, 0x46, 0xa2, 0x33, 0xca, 0xb6,
0x17, 0x04, 0x99, 0x85, 0x81, 0x03, 0xbb, 0x02, 0xd6, 0xa8, 0x42, 0x45, 0x4b, 0x47, 0xaf, 0x47,
0x7e, 0x74, 0xd3, 0x58, 0x82, 0x85, 0x53, 0x4a, 0x63, 0x9b, 0x42, 0xed, 0xd3, 0x71, 0xc8, 0xe8,
0xf7, 0x51, 0x27, 0x73, 0xb1, 0x56, 0xc5, 0xbc, 0x58, 0x5f, 0x73, 0x05, 0x1b, 0xe9, 0x6b, 0xe2,
0x51, 0x18, 0xc4, 0x14, 0xfd, 0x08, 0x5e, 0x1b, 0xfa, 0x01, 0x8d, 0xdc, 0x53, 0x4a, 0xdd, 0x88,
0x30, 0xea, 0xc6, 0x84, 0xb9, 0x23, 0x1a, 0xb9, 0x17, 0x57, 0xea, 0xce, 0x0d, 0x41, 0x70, 0x48,
0x29, 0x26, 0x8c, 0x9e, 0x10, 0xd6, 0xa1, 0xd1, 0xf3, 0x2b, 0xf4, 0x16, 0xac, 0x25, 0x8c, 0x2c,
0x64, 0x64, 0x20, 0xee, 0x5f, 0xc0, 0x65, 0x4d, 0xde, 0xe5, 0x40, 0xfb, 0x29, 0xd4, 0x8e, 0xfc,
0x58, 0x7b, 0x2b, 0xd6, 0xfa, 0xdd, 0x81, 0x22, 0xe9, 0x0b, 0xe3, 0x86, 0xc1, 0xe0, 0x46, 0xdc,
0xb4, 0x82, 0x41, 0x82, 0x8e, 0x83, 0xc1, 0x8d, 0x7d, 0x00, 0x1b, 0x69, 0x3e, 0x25, 0xf0, 0xbb,
0xb0, 0xa2, 0x6c, 0x10, 0x6f, 0x5b, 0x77, 0xe7, 0xef, 0x17, 0xf7, 0xaa, 0x8f, 0x54, 0xb0, 0x3c,
0xd2, 0xca, 0x4d, 0x28, 0xec, 0x8f, 0x60, 0xe9, 0x78, 0xcc, 0x46, 0x63, 0x86, 0x6e, 0xc3, 0xaa,
0x30, 0x24, 0xd7, 0x4f, 0x29, 0xb6, 0x22, 0x00, 0x27, 0x84, 0xa1, 0x6d, 0x58, 0x26, 0x9e, 0x17,
0xd1, 0x38, 0x16, 0x4a, 0xac, 0x62, 0xfd, 0x69, 0xff, 0xd6, 0x82, 0xb2, 0x3c, 0xe1, 0x17, 0x3e,
0x3b, 0x3f, 0xa4, 0xd4, 0xa4, 0xb5, 0x52, 0xb4, 0xdf, 0xc2, 0x1d, 0xe8, 0x11, 0xd4, 0xf2, 0x0c,
0xcd, 0x23, 0x6b, 0xa1, 0x39, 0x87, 0xd7, 0x4e, 0xd3, 0x56, 0x9e, 0xb8, 0x6f, 0x1f, 0xb6, 0xa4,
0x14, 0x31, 0x17, 0xa3, 0x35, 0x1c, 0x0d, 0xfc, 0xbe, 0xcf, 0xb8, 0x38, 0x0f, 0x60, 0x39, 0x94,
0x18, 0x65, 0x8e, 0xb5, 0x89, 0x39, 0x24, 0x07, 0xd6, 0x78, 0xfb, 0x1f, 0x16, 0xd4, 0xf6, 0x07,
0x61, 0x9c, 0x8d, 0xb5, 0x5d, 0x00, 0x99, 0x7c, 0xee, 0x05, 0x95, 0xae, 0x28, 0xe1, 0x55, 0x09,
0x79, 0x4e, 0x6f, 0xd0, 0xc7, 0xb0, 0x26, 0x4f, 0x70, 0xaf, 0x7c, 0x76, 0xce, 0xfd, 0x2d, 0x54,
0x2b, 0xee, 0x6d, 0x65, 0x6e, 0x52, 0x16, 0x6a, 0xce, 0xe1, 0x72, 0x98, 0x32, 0xd9, 0x4f, 0x12,
0x19, 0xe7, 0x05, 0xe7, 0x9d, 0x0c, 0x67, 0x56, 0xab, 0xe6, 0xdc, 0x44, 0xea, 0x46, 0x0d, 0xd6,
0x4f, 0xc7, 0x81, 0x17, 0xbb, 0x1e, 0x8d, 0x99, 0x1f, 0x10, 0x5e, 0x0d, 0xec, 0x27, 0xb0, 0x91,
0xd6, 0x44, 0x45, 0xc7, 0x2e, 0x40, 0x9f, 0xc3, 0x5d, 0x76, 0xed, 0x7b, 0x5a, 0x15, 0x01, 0xe9,
0x5e, 0xfb, 0x9e, 0xfd, 0x7b, 0x0b, 0xb6, 0xf8, 0x55, 0x5e, 0x44, 0xae, 0xbe, 0x9b, 0x11, 0x0c,
0x33, 0x17, 0xbe, 0xde, 0xcc, 0xe8, 0xdd, 0xaf, 0xf1, 0xf1, 0x94, 0x87, 0xed, 0x2f, 0xe0, 0xd6,
0x94, 0x44, 0x4a, 0x99, 0x87, 0xb0, 0xac, 0x02, 0x59, 0xc8, 0x93, 0x17, 0xe9, 0x9a, 0x80, 0xd7,
0x8b, 0x2b, 0x75, 0x8c, 0xd4, 0xbd, 0x20, 0x34, 0x28, 0x69, 0xa0, 0x50, 0xff, 0x37, 0x16, 0x6c,
0x1e, 0xd0, 0x51, 0x18, 0x4f, 0x55, 0xcf, 0x6f, 0xd0, 0x7e, 0x17, 0x80, 0x0c, 0x45, 0x31, 0xe2,
0xd9, 0x23, 0xf3, 0x7c, 0x55, 0x42, 0x78, 0xfa, 0x7c, 0x37, 0x8d, 0xcf, 0x60, 0x2b, 0x2b, 0xc4,
0xf7, 0x50, 0xf8, 0x1e, 0x94, 0x3c, 0x79, 0x8a, 0xa9, 0x6f, 0x51, 0xc1, 0x84, 0xba, 0x5f, 0x59,
0x50, 0xc3, 0x34, 0xa0, 0x59, 0x57, 0x8b, 0xda, 0x23, 0x6b, 0x6b, 0xa2, 0x2d, 0x28, 0x90, 0x74,
0x76, 0xd2, 0x26, 0x64, 0xb9, 0x9e, 0x6e, 0x13, 0x8e, 0x80, 0xa7, 0xda, 0x84, 0x22, 0x9d, 0x6a,
0x13, 0x8a, 0x74, 0x86, 0x95, 0x16, 0x72, 0xad, 0x34, 0xdd, 0x31, 0x6c, 0x0a, 0x1b, 0x69, 0x6d,
0xbe, 0x9f, 0xd5, 0x22, 0x7e, 0x06, 0x19, 0xa4, 0xac, 0xa6, 0x60, 0xc2, 0x6a, 0x1e, 0x6c, 0x36,
0xc6, 0xc3, 0x91, 0x62, 0xe5, 0x65, 0xff, 0xdb, 0xc5, 0xc8, 0x0c, 0xf5, 0x0a, 0xf9, 0x41, 0xb0,
0x0d, 0x5b, 0xd9, 0x5b, 0xa4, 0x3a, 0xf6, 0x1f, 0x0b, 0xb0, 0xac, 0xc0, 0xdf, 0x74, 0xe5, 0xff,
0xc3, 0x0a, 0x4f, 0xba, 0xd0, 0x0f, 0x98, 0x2a, 0x49, 0xeb, 0x66, 0x56, 0x76, 0x38, 0x02, 0x4f,
0x48, 0xd0, 0x06, 0x2c, 0xca, 0x5e, 0x2a, 0x03, 0x53, 0x7e, 0xa0, 0x77, 0x60, 0x9d, 0x5c, 0x12,
0x7f, 0x40, 0x7a, 0x03, 0xea, 0xf6, 0xc8, 0x80, 0x04, 0x7d, 0xaa, 0x9c, 0x52, 0x9d, 0x20, 0x1a,
0x12, 0xce, 0x89, 0x85, 0x37, 0x44, 0x15, 0xd2, 0x73, 0xc1, 0x22, 0x77, 0x38, 0xae, 0x26, 0x08,
0x35, 0x17, 0xbc, 0x03, 0x8b, 0x31, 0x23, 0x8c, 0x6e, 0x2f, 0xdd, 0xb5, 0xee, 0x57, 0xf6, 0x36,
0xb3, 0x6e, 0x39, 0xe1, 0x48, 0x2c, 0x69, 0x78, 0x50, 0x0e, 0x08, 0xa3, 0xb1, 0x0a, 0xe7, 0x65,
0x19, 0x94, 0x12, 0x24, 0xfc, 0xd2, 0x07, 0x74, 0x32, 0xee, 0x0d, 0x7d, 0x76, 0x1c, 0x79, 0x34,
0xd2, 0x4e, 0xb9, 0x0b, 0xf3, 0x24, 0xbe, 0x50, 0x8e, 0x2f, 0x25, 0x37, 0xc4, 0x17, 0xcd, 0x39,
0xcc, 0x51, 0x9c, 0xa2, 0xa7, 0x3c, 0x6d, 0x52, 0x34, 0x7c, 0x8f, 0x53, 0xf4, 0x7c, 0xaf, 0xb1,
0x0a, 0xcb, 0x1e, 0x65, 0xc4, 0x1f, 0xc4, 0xf6, 0x97, 0x16, 0xd4, 0x52, 0xb7, 0xa8, 0x18, 0xfb,
0x10, 0xca, 0x7e, 0x70, 0x49, 0x06, 0xbe, 0xe7, 0x86, 0x1c, 0xa1, 0x2e, 0x4c, 0x54, 0x6a, 0x49,
0xac, 0xe0, 0x6a, 0xce, 0xe1, 0x92, 0x6f, 0x7c, 0xa3, 0x3d, 0xd8, 0x20, 0xfd, 0x3e, 0x1d, 0x31,
0xaa, 0xd8, 0xdd, 0x20, 0xe4, 0x56, 0x16, 0xd1, 0xd7, 0x9c, 0xc3, 0x48, 0x63, 0x05, 0x79, 0x9b,
0xe3, 0x4c, 0xa1, 0xda, 0xb0, 0xce, 0x47, 0x01, 0x81, 0x9c, 0x0c, 0x10, 0xdb, 0xb0, 0x7c, 0x49,
0xa3, 0x5e, 0x18, 0x53, 0x35, 0x3c, 0xe8, 0xcf, 0xec, 0x68, 0x51, 0x98, 0x1a, 0x2d, 0x3e, 0x03,
0x64, 0x9e, 0xa7, 0x54, 0xbc, 0x0b, 0x0b, 0x24, 0xbe, 0xd0, 0x5d, 0x34, 0x65, 0x4a, 0x2c, 0x30,
0x9c, 0xa2, 0xe7, 0x7b, 0xba, 0x01, 0xa4, 0x4c, 0x89, 0x05, 0xc6, 0x7e, 0x02, 0x68, 0x9f, 0xc7,
0xc9, 0x20, 0xe5, 0xa3, 0x3b, 0x50, 0x34, 0xb5, 0x56, 0xf5, 0x26, 0x9c, 0xe8, 0x6a, 0x6f, 0x42,
0x2d, 0xc5, 0xa6, 0x32, 0xe1, 0xdf, 0xf3, 0xb0, 0x28, 0x0d, 0xf8, 0xcd, 0xe5, 0x59, 0xa4, 0xdd,
0xa9, 0x7f, 0x4d, 0xa5, 0xa7, 0xcb, 0x78, 0x95, 0x43, 0x0e, 0x39, 0x00, 0x55, 0x61, 0x9e, 0x0c,
0x99, 0x8a, 0x7a, 0xfe, 0x27, 0xfa, 0x19, 0xec, 0x0e, 0xc9, 0xb5, 0xdb, 0x23, 0xac, 0x7f, 0xee,
0xce, 0x2e, 0x4a, 0xb7, 0x86, 0xe4, 0xba, 0xc1, 0x69, 0xb2, 0xc3, 0x5f, 0x46, 0xa3, 0xc5, 0xac,
0x46, 0xe8, 0x41, 0x3a, 0xf4, 0x6b, 0x49, 0x5a, 0x72, 0x9a, 0x54, 0xe0, 0x6f, 0xc0, 0xe2, 0x38,
0xf0, 0x59, 0x2c, 0x42, 0xbe, 0x8c, 0xe5, 0x07, 0x4f, 0x34, 0xf1, 0x87, 0x3b, 0x0e, 0x4e, 0xc7,
0x83, 0x53, 0x7f, 0x30, 0xa0, 0xde, 0xf6, 0x8a, 0x4c, 0x34, 0x81, 0x78, 0x99, 0xc0, 0xd1, 0xbb,
0x80, 0x22, 0x1a, 0xd3, 0xe8, 0x92, 0x7a, 0x6e, 0x32, 0xe4, 0xad, 0xca, 0x1c, 0xd6, 0x98, 0x57,
0x7a, 0xd8, 0xdb, 0x83, 0xcd, 0x7e, 0x44, 0x65, 0x06, 0x33, 0x7f, 0x48, 0x63, 0x46, 0x86, 0x23,
0x37, 0x88, 0xb7, 0x41, 0x30, 0xd4, 0x34, 0xb2, 0xab, 0x71, 0x6d, 0x2e, 0xce, 0x12, 0xbd, 0xa4,
0x7c, 0xe6, 0x2c, 0x0a, 0xe7, 0x67, 0x14, 0x72, 0x38, 0x0e, 0x2b, 0x12, 0x35, 0x1a, 0xbb, 0x52,
0xfe, 0x21, 0xb7, 0xdf, 0x76, 0x49, 0x48, 0xce, 0x47, 0xe3, 0x97, 0x1c, 0xfa, 0x82, 0x03, 0xed,
0xbf, 0x58, 0x30, 0xdf, 0xf0, 0x3d, 0x74, 0x7f, 0x12, 0xea, 0x2a, 0xad, 0x2a, 0xe9, 0xd3, 0xb1,
0x46, 0x73, 0xd1, 0x07, 0x94, 0xc4, 0xd4, 0xf5, 0xc6, 0xaa, 0x04, 0xf5, 0x06, 0x61, 0xff, 0x22,
0x56, 0x3e, 0xaf, 0x09, 0xe4, 0x81, 0xc2, 0x35, 0x04, 0x4a, 0x25, 0x4a, 0xec, 0x87, 0x81, 0xec,
0x4c, 0x58, 0x7f, 0xa2, 0x27, 0xc0, 0x05, 0x72, 0x83, 0xd0, 0xa3, 0x2e, 0xf3, 0x69, 0x24, 0xbc,
0x5e, 0x31, 0x6a, 0x68, 0x3b, 0xf4, 0x68, 0xd7, 0xa7, 0x11, 0x2e, 0x0e, 0xfd, 0x40, 0x7f, 0xd8,
0xbf, 0x86, 0xf9, 0x7a, 0x7c, 0xf1, 0xbf, 0x92, 0xda, 0xfe, 0xbb, 0x05, 0x90, 0x18, 0x9d, 0x77,
0xb4, 0x94, 0x13, 0xb9, 0x2c, 0xf3, 0xb8, 0xc8, 0x0c, 0xe7, 0xdd, 0x86, 0x55, 0xe1, 0x19, 0x37,
0x66, 0x91, 0x9a, 0xef, 0x57, 0x04, 0xe0, 0x84, 0x45, 0xe8, 0x19, 0x94, 0x44, 0x1c, 0xba, 0xfd,
0x73, 0x12, 0x9c, 0x51, 0x35, 0xa0, 0x26, 0x85, 0xed, 0xe5, 0xc8, 0x23, 0x8c, 0x7a, 0xe2, 0xb2,
0xe6, 0x1c, 0x2e, 0x0a, 0xe2, 0x7d, 0x41, 0x8b, 0x1e, 0xc3, 0xb2, 0x70, 0x2f, 0xf5, 0x84, 0xe9,
0xcc, 0xb0, 0x10, 0x1e, 0xd6, 0x4c, 0x9a, 0xaa, 0xb1, 0x0c, 0x8b, 0xe2, 0x62, 0xfb, 0xcf, 0x16,
0x94, 0xcc, 0x93, 0xd1, 0x33, 0xa8, 0x8c, 0x22, 0x7a, 0xe9, 0x87, 0xe3, 0xd8, 0x95, 0x99, 0x63,
0xcd, 0xce, 0x9c, 0xb2, 0x26, 0x15, 0x9f, 0xe8, 0x3d, 0x58, 0x0d, 0xe8, 0x95, 0x62, 0x2b, 0xcc,
0x66, 0x5b, 0x09, 0xe8, 0x95, 0xe4, 0xb8, 0x07, 0x25, 0x19, 0x9d, 0x2a, 0xb1, 0xa4, 0x89, 0x8b,
0x02, 0x76, 0x28, 0x40, 0xf6, 0x3f, 0x2d, 0x80, 0x44, 0x09, 0xf4, 0x3e, 0x14, 0x85, 0x12, 0x33,
0x84, 0x13, 0x94, 0xf2, 0x16, 0x18, 0x4e, 0xfe, 0x9e, 0xba, 0xa7, 0x30, 0x75, 0x0f, 0x1f, 0x5c,
0x95, 0x75, 0x54, 0x67, 0x99, 0x97, 0x83, 0xab, 0x02, 0xca, 0xfa, 0xf7, 0x11, 0x94, 0x23, 0xfa,
0x05, 0xed, 0x33, 0x37, 0xa2, 0x24, 0x0e, 0x03, 0x15, 0xa9, 0x3b, 0xe9, 0xfb, 0xb1, 0x20, 0xc1,
0x82, 0x02, 0x97, 0x22, 0xe3, 0x8b, 0x8f, 0x1b, 0x98, 0xf6, 0xc3, 0x4b, 0x1a, 0x65, 0x1e, 0xa2,
0xf6, 0x31, 0xdc, 0x9a, 0xc2, 0xa8, 0x8e, 0xf0, 0x3e, 0x6c, 0x05, 0xe3, 0xa1, 0x1b, 0x49, 0x34,
0xf5, 0x5c, 0xe3, 0xe1, 0xc9, 0xf5, 0xd8, 0x08, 0xc6, 0x43, 0xac, 0x91, 0x9a, 0xdb, 0xae, 0xc1,
0x7a, 0x5d, 0xee, 0x2c, 0x92, 0xd9, 0xc9, 0xee, 0x00, 0x32, 0x81, 0xea, 0x82, 0x67, 0x50, 0xa6,
0xd7, 0xb4, 0x3f, 0x16, 0x39, 0xc1, 0xdf, 0x55, 0xd9, 0xae, 0xea, 0x68, 0x2c, 0xe7, 0x2a, 0x51,
0xe3, 0xcb, 0xfe, 0xd7, 0x02, 0x2c, 0x1e, 0xf1, 0xc4, 0x41, 0x4f, 0xa1, 0xcc, 0x63, 0x37, 0xa0,
0x03, 0x57, 0x8e, 0x42, 0xd6, 0xac, 0x51, 0xa8, 0xa4, 0xe8, 0xc4, 0x17, 0x2f, 0x53, 0x9a, 0x8f,
0x0c, 0xcd, 0xc9, 0x5e, 0x1f, 0x57, 0x1f, 0x8a, 0xe9, 0xfe, 0x29, 0xdc, 0xd2, 0x74, 0xd9, 0x04,
0x96, 0x71, 0xb3, 0xa9, 0xd0, 0x99, 0x14, 0x7e, 0x0f, 0x36, 0x34, 0x9f, 0x4c, 0x7f, 0x35, 0x1f,
0x8b, 0xfd, 0x08, 0x46, 0x0a, 0x27, 0x74, 0x50, 0x13, 0xf2, 0x1d, 0x28, 0x8e, 0x22, 0x3a, 0xf4,
0xc7, 0x43, 0x21, 0xcd, 0xa2, 0x90, 0x06, 0x14, 0x88, 0x8b, 0xf2, 0x90, 0x8f, 0x5f, 0x86, 0xc1,
0x04, 0xd9, 0x92, 0x9c, 0x30, 0x4d, 0xeb, 0x70, 0x5a, 0x5b, 0x98, 0xc5, 0x4f, 0xe8, 0x96, 0x05,
0x5d, 0x51, 0x00, 0x15, 0xcd, 0x23, 0xa8, 0xf5, 0x07, 0x94, 0x44, 0x7e, 0x70, 0x26, 0x5b, 0xe0,
0x28, 0xf2, 0xfb, 0x54, 0xf4, 0x99, 0x05, 0xbc, 0xae, 0x51, 0xbc, 0xf5, 0x75, 0x38, 0x02, 0xdd,
0x87, 0xaa, 0xec, 0x7b, 0xa2, 0xd3, 0x0a, 0x16, 0xd5, 0x66, 0x2a, 0x02, 0x2e, 0xfa, 0x2d, 0x56,
0xe3, 0x9c, 0xd9, 0x21, 0x61, 0xaa, 0x43, 0xbe, 0x0e, 0xab, 0xa3, 0x71, 0xd4, 0x3f, 0x27, 0x31,
0xf5, 0xb6, 0x8b, 0x62, 0x46, 0x49, 0x00, 0xe8, 0x49, 0x62, 0xf3, 0x88, 0x0e, 0x43, 0x46, 0x65,
0x95, 0xe6, 0xdd, 0xbf, 0x24, 0x8e, 0xd2, 0xa6, 0xc5, 0x02, 0xcb, 0x6b, 0x33, 0x1f, 0x04, 0x7e,
0x0a, 0xeb, 0x9a, 0x2d, 0xa9, 0xea, 0xe5, 0x59, 0x55, 0x5d, 0xbb, 0x7f, 0x52, 0xd9, 0x9b, 0x50,
0x16, 0xee, 0x98, 0x0c, 0x59, 0xb7, 0x61, 0x55, 0xce, 0x08, 0x7c, 0xec, 0xe1, 0x83, 0x51, 0x09,
0xaf, 0x08, 0x40, 0xcb, 0x8b, 0xd1, 0x8e, 0xb1, 0x89, 0x29, 0x48, 0xdc, 0x64, 0xef, 0xf2, 0x27,
0x0b, 0x2a, 0xfa, 0x28, 0x15, 0xec, 0x6f, 0xc1, 0x92, 0x08, 0x03, 0x3d, 0x61, 0x25, 0xed, 0x42,
0x10, 0x62, 0x85, 0x45, 0x8f, 0x61, 0x43, 0xac, 0x93, 0x44, 0x50, 0x52, 0x12, 0x05, 0xd4, 0x33,
0x62, 0x73, 0x5d, 0xe0, 0xea, 0x43, 0xe6, 0x08, 0x0c, 0x77, 0xe2, 0x3b, 0x80, 0x12, 0x86, 0x11,
0xf1, 0x25, 0xb9, 0x7a, 0x7c, 0x6a, 0xf2, 0x0e, 0xf1, 0x39, 0xb1, 0xbd, 0x06, 0xe5, 0x6e, 0x78,
0x41, 0x83, 0x49, 0xfe, 0x7f, 0x08, 0x15, 0x0d, 0x98, 0xbc, 0xa7, 0x96, 0x98, 0x80, 0x28, 0x41,
0x51, 0x22, 0x68, 0x4c, 0x98, 0x20, 0xc6, 0x8a, 0xc2, 0xfe, 0x6b, 0x01, 0x56, 0x27, 0x50, 0x5e,
0xcb, 0x7a, 0x3c, 0xd0, 0x87, 0xa4, 0x4f, 0xa2, 0x30, 0x0c, 0xd4, 0xa4, 0x56, 0xe2, 0xc0, 0x17,
0x0a, 0xc6, 0x6b, 0xe2, 0x88, 0xdc, 0x0c, 0x79, 0x3f, 0x3a, 0x27, 0xf1, 0xb9, 0x7e, 0x82, 0x29,
0x58, 0x93, 0xc4, 0xe7, 0xe8, 0x01, 0x54, 0x35, 0xc9, 0x28, 0xa2, 0xfe, 0x90, 0xa8, 0xbe, 0x54,
0xc2, 0x6b, 0x0a, 0xde, 0x51, 0x60, 0x1e, 0x91, 0xea, 0x65, 0x2e, 0x34, 0x1f, 0x72, 0xd5, 0x17,
0x44, 0x0b, 0xac, 0x48, 0x38, 0x57, 0xfc, 0x45, 0x4c, 0x18, 0xfa, 0x01, 0x6c, 0x46, 0xe1, 0x98,
0xf1, 0x50, 0xe7, 0x19, 0x91, 0x90, 0x2f, 0x0a, 0x72, 0xa4, 0x90, 0x87, 0x94, 0x4e, 0x58, 0x54,
0x6f, 0x75, 0xc5, 0x44, 0x44, 0x3d, 0x91, 0x69, 0xaa, 0xb7, 0xee, 0x4b, 0x10, 0xef, 0xd3, 0x22,
0xad, 0xa9, 0x7c, 0xb2, 0xac, 0x60, 0xfd, 0xc9, 0x99, 0x63, 0x16, 0x46, 0xe4, 0x8c, 0xba, 0x01,
0x19, 0xca, 0xa4, 0x5a, 0xe5, 0xfd, 0x53, 0xc0, 0xda, 0x64, 0x48, 0xed, 0x2d, 0xd8, 0x38, 0x32,
0x7b, 0xbf, 0xf6, 0xc9, 0x97, 0xf3, 0xb0, 0x99, 0x41, 0x28, 0xdf, 0xb8, 0xb0, 0x96, 0x1e, 0x25,
0xb4, 0x93, 0xf6, 0xd2, 0xd1, 0x94, 0x65, 0x4c, 0x43, 0x63, 0x27, 0x60, 0xd1, 0x4d, 0xa3, 0xb0,
0x6d, 0xe1, 0x4a, 0x6a, 0xf8, 0x88, 0x51, 0x00, 0x5b, 0xd9, 0x59, 0x65, 0xdc, 0xbf, 0xa0, 0x93,
0xb5, 0xcf, 0x07, 0xdf, 0xe5, 0x9e, 0x86, 0x64, 0x15, 0xb7, 0xe1, 0x8d, 0x41, 0x0e, 0x6a, 0xa7,
0x0e, 0xb5, 0x1c, 0xd1, 0xf8, 0xc8, 0xae, 0x27, 0xfd, 0x32, 0xe6, 0x7f, 0x26, 0x8f, 0x57, 0xf9,
0x9e, 0x91, 0x1f, 0xcf, 0x0a, 0x1f, 0x58, 0x3b, 0x14, 0x5e, 0x9b, 0x79, 0x6b, 0xce, 0x41, 0x7b,
0xe6, 0x41, 0x95, 0xbd, 0xd7, 0x27, 0x0a, 0xa5, 0xf9, 0xd5, 0x8c, 0x3e, 0xb9, 0x86, 0x3b, 0xab,
0x4d, 0xaf, 0x99, 0x78, 0x0f, 0xb4, 0x82, 0xd3, 0x50, 0x3b, 0xeb, 0x77, 0x16, 0x6c, 0x66, 0x10,
0xca, 0x59, 0x77, 0xd2, 0xfb, 0x50, 0xf9, 0x4c, 0x36, 0xb7, 0xa1, 0x33, 0x56, 0x06, 0x4b, 0xb9,
0x2b, 0x03, 0xf4, 0x36, 0xac, 0x89, 0x8a, 0x9c, 0x0c, 0xed, 0xaa, 0xa4, 0x57, 0x04, 0x78, 0x32,
0xae, 0xdb, 0x4f, 0x61, 0x9d, 0x97, 0x34, 0x4c, 0x78, 0x3c, 0xeb, 0x52, 0x76, 0x0f, 0x4a, 0xa2,
0x24, 0x8e, 0xc6, 0xbd, 0x0b, 0x7a, 0xa3, 0xab, 0x59, 0x91, 0xc3, 0x3a, 0x12, 0x64, 0x1f, 0x01,
0x32, 0xf9, 0x94, 0x16, 0x4f, 0x15, 0x63, 0x24, 0xc0, 0x3a, 0xde, 0x6a, 0xa9, 0x72, 0xaa, 0x58,
0xc4, 0x69, 0xf2, 0xef, 0xf8, 0xe1, 0x1f, 0x2c, 0x28, 0x99, 0x0f, 0x7d, 0x54, 0x85, 0x52, 0xc7,
0x69, 0x1f, 0xb4, 0xda, 0x9f, 0xb8, 0xc7, 0x1d, 0xa7, 0x5d, 0x9d, 0x43, 0x08, 0x2a, 0x1a, 0xf2,
0xb2, 0x73, 0x50, 0xef, 0x3a, 0x55, 0x0b, 0xad, 0xc0, 0x82, 0xc0, 0x16, 0x50, 0x11, 0x96, 0x9d,
0xcf, 0x3a, 0x2d, 0xec, 0x1c, 0x54, 0xe7, 0x4d, 0xd2, 0xfd, 0xa3, 0xe3, 0x13, 0xe7, 0xa0, 0xba,
0x80, 0x00, 0x96, 0xd4, 0xdf, 0x8b, 0xa8, 0x06, 0x6b, 0xd8, 0xd9, 0x3f, 0x7e, 0xe5, 0xe0, 0x5f,
0xba, 0x87, 0xf5, 0xd6, 0x91, 0x73, 0x50, 0x5d, 0x42, 0xeb, 0x50, 0xd6, 0x4c, 0x8d, 0x7a, 0x77,
0xbf, 0x59, 0x5d, 0x7e, 0xd8, 0x51, 0x53, 0x9d, 0x14, 0xa9, 0x08, 0xcb, 0x1d, 0xec, 0x74, 0xea,
0xd8, 0xa9, 0xce, 0xa1, 0x12, 0xac, 0xd4, 0xf7, 0xf7, 0x9d, 0x4e, 0xd7, 0x39, 0xa8, 0x5a, 0xfc,
0x0b, 0x3b, 0x3f, 0x77, 0xf6, 0xf9, 0x57, 0x81, 0x5f, 0x75, 0xd2, 0xfa, 0xa4, 0x2d, 0x44, 0x29,
0xc3, 0xea, 0x61, 0xab, 0x5d, 0x3f, 0x6a, 0x7d, 0xce, 0xa5, 0x78, 0xf8, 0x37, 0x0b, 0xd6, 0xa7,
0xc6, 0x2f, 0xae, 0x46, 0xfb, 0xb8, 0xcd, 0x8f, 0xdd, 0x02, 0x74, 0xe2, 0xe0, 0x57, 0x0e, 0x76,
0x5f, 0xb4, 0x4e, 0x1a, 0x4e, 0xb3, 0xfe, 0xaa, 0x75, 0x8c, 0xab, 0x16, 0xda, 0x81, 0x2d, 0x21,
0x94, 0xfb, 0xca, 0xc1, 0x27, 0xad, 0xe3, 0x36, 0x47, 0xbf, 0x10, 0x52, 0x16, 0xd0, 0x2e, 0xbc,
0xd6, 0xa9, 0xe3, 0x6e, 0xab, 0x7e, 0xe4, 0x4a, 0x21, 0xdc, 0xfd, 0xe3, 0xa3, 0xa3, 0x7a, 0xd7,
0xc1, 0xf5, 0xa3, 0xea, 0x3c, 0xba, 0x07, 0xbb, 0x19, 0xf4, 0xc1, 0xcb, 0xce, 0x51, 0x6b, 0xbf,
0xde, 0x75, 0xdc, 0x8e, 0xe3, 0xe0, 0xea, 0x02, 0x7a, 0x00, 0x6f, 0x66, 0x4f, 0x68, 0xd6, 0xdb,
0x6d, 0xe7, 0xc8, 0x3d, 0x7c, 0x29, 0x2d, 0xa2, 0xac, 0xb4, 0xb8, 0xf7, 0x9f, 0x22, 0x2c, 0x75,
0xc5, 0x5b, 0x1a, 0x3d, 0x87, 0x92, 0xf9, 0x2b, 0x09, 0x4a, 0x92, 0x23, 0xe7, 0x37, 0x9a, 0x9d,
0xdd, 0x19, 0xd8, 0xc9, 0xce, 0xa4, 0x68, 0xfc, 0x4e, 0x85, 0x6e, 0x1b, 0xbb, 0x92, 0xec, 0xfe,
0x75, 0x67, 0x6a, 0x65, 0xc7, 0x45, 0x31, 0x7f, 0xff, 0x30, 0x44, 0xc9, 0xf9, 0x39, 0xc5, 0x10,
0x25, 0xf7, 0x47, 0x93, 0xe7, 0x50, 0x32, 0xd7, 0xe5, 0xc6, 0x61, 0x39, 0xbf, 0x07, 0x18, 0x87,
0xe5, 0xee, 0xd8, 0xbb, 0xb0, 0x96, 0xd9, 0x58, 0xa3, 0x64, 0x9f, 0x9f, 0xbf, 0x5d, 0xdf, 0xb9,
0x3b, 0x9b, 0x40, 0x9d, 0xfa, 0x29, 0x54, 0xd2, 0x5b, 0x61, 0xf4, 0x46, 0x52, 0x99, 0xf2, 0x76,
0xd6, 0x3b, 0x77, 0x66, 0xe2, 0x13, 0xad, 0xcd, 0x85, 0xa9, 0xa1, 0x75, 0xce, 0x56, 0xd8, 0xd0,
0x3a, 0x77, 0xcb, 0xfa, 0x29, 0x54, 0xd2, 0x0b, 0x4b, 0x43, 0xbe, 0xdc, 0x7d, 0xa9, 0x21, 0x5f,
0xfe, 0xa6, 0x93, 0x1b, 0x32, 0xf3, 0xf4, 0x30, 0x0c, 0x99, 0xff, 0x5c, 0x31, 0x0c, 0x39, 0xeb,
0xd5, 0xd2, 0x84, 0xa2, 0xb1, 0xc1, 0x33, 0xc2, 0x6e, 0x7a, 0x7b, 0xb8, 0xf3, 0x7a, 0x3e, 0x52,
0x9d, 0xe4, 0x00, 0x24, 0x7b, 0x32, 0xb4, 0x93, 0x0a, 0xb1, 0xd4, 0x32, 0x6e, 0xe7, 0x76, 0x2e,
0x2e, 0x11, 0xc8, 0xd8, 0x6e, 0x19, 0x02, 0x4d, 0xaf, 0xca, 0x0c, 0x81, 0x72, 0x16, 0x62, 0x5c,
0xa0, 0xe4, 0x15, 0x65, 0x08, 0x34, 0xf5, 0xde, 0x32, 0x04, 0xca, 0x79, 0x76, 0x1d, 0xab, 0xd9,
0x34, 0xe9, 0xfa, 0xbb, 0xb3, 0xba, 0xba, 0x3c, 0xed, 0x8d, 0xaf, 0x6f, 0xfa, 0xa8, 0x0d, 0xe5,
0x54, 0x07, 0x34, 0xce, 0xcb, 0x6b, 0x99, 0xc6, 0x79, 0xf9, 0x8d, 0xb3, 0x0d, 0x65, 0x01, 0x3c,
0x09, 0xc8, 0x28, 0x3e, 0x0f, 0x99, 0x71, 0x5e, 0x0a, 0x3e, 0x7d, 0x5e, 0x06, 0xad, 0xce, 0xfb,
0x18, 0xca, 0x9f, 0x50, 0x36, 0x99, 0x53, 0x63, 0x94, 0xfc, 0x72, 0x97, 0x1a, 0x86, 0x77, 0x6e,
0x4d, 0xc1, 0xd5, 0x09, 0x3f, 0x86, 0x25, 0x39, 0xce, 0x1b, 0xac, 0xa9, 0xa7, 0x82, 0xc1, 0x9a,
0x99, 0xfb, 0x0f, 0xa1, 0x98, 0xb4, 0x48, 0x33, 0x8c, 0xa6, 0x7a, 0xb4, 0xe1, 0xb5, 0x9c, 0x3e,
0xcc, 0x13, 0xd0, 0xd4, 0x2e, 0x46, 0x33, 0xd4, 0x8e, 0x73, 0x12, 0x30, 0x83, 0x97, 0x47, 0x36,
0xde, 0xfe, 0xfc, 0xcd, 0x33, 0x9f, 0x9d, 0x8f, 0x7b, 0x8f, 0xfa, 0xe1, 0xf0, 0xf1, 0xc0, 0x3f,
0x3b, 0x67, 0x81, 0x1f, 0x9c, 0x0d, 0x48, 0x2f, 0x7e, 0xcc, 0x59, 0x1f, 0x2b, 0xfe, 0xde, 0x92,
0xf8, 0xd7, 0x83, 0x1f, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0x4c, 0x3a, 0x88, 0x58, 0xa5, 0x20,
0x00, 0x00,
0x2c, 0x44, 0xcb, 0xa3, 0x30, 0x1c, 0x44, 0xa3, 0xfe, 0xce, 0x1b, 0x64, 0xdc, 0x67, 0x7e, 0x18,
0x50, 0x1a, 0x45, 0xa3, 0xfe, 0xe3, 0xe4, 0x4b, 0x12, 0xda, 0x5f, 0x59, 0x80, 0x5a, 0x81, 0xcf,
0xea, 0xfd, 0x7e, 0x38, 0x0e, 0x18, 0xa6, 0xbf, 0x1a, 0xd3, 0x98, 0xa1, 0xff, 0x83, 0x32, 0x91,
0x10, 0xf7, 0x92, 0x0c, 0xc6, 0x74, 0xdb, 0xba, 0x6b, 0xdd, 0x5f, 0xc0, 0x25, 0x05, 0x7c, 0xc5,
0x61, 0xe8, 0x01, 0xac, 0x91, 0x5e, 0x1c, 0x0e, 0xc6, 0x8c, 0xba, 0xe7, 0xd4, 0x3f, 0x3b, 0x67,
0xdb, 0x85, 0xbb, 0xd6, 0xfd, 0x72, 0x73, 0x0e, 0x57, 0x34, 0xa2, 0x29, 0xe0, 0x9c, 0x34, 0xa2,
0x03, 0xc2, 0xfc, 0xcb, 0x09, 0xe9, 0xbc, 0x26, 0xd5, 0x08, 0x45, 0x7a, 0x0f, 0x8a, 0xfd, 0x30,
0x38, 0x75, 0x19, 0x89, 0xce, 0x28, 0xdb, 0x5e, 0x10, 0x64, 0x16, 0x06, 0x0e, 0xec, 0x0a, 0x58,
0xa3, 0x0a, 0x15, 0x2d, 0x1d, 0xbd, 0x1e, 0xf9, 0xd1, 0x4d, 0x63, 0x09, 0x16, 0x4e, 0x29, 0x8d,
0x6d, 0x0a, 0xb5, 0x4f, 0xc7, 0x21, 0xa3, 0xdf, 0x47, 0x9d, 0xcc, 0xc5, 0x5a, 0x15, 0xf3, 0x62,
0x7d, 0xcd, 0x15, 0x6c, 0xa4, 0xaf, 0x89, 0x47, 0x61, 0x10, 0x53, 0xf4, 0x23, 0x78, 0x6d, 0xe8,
0x07, 0x34, 0x72, 0x4f, 0x29, 0x75, 0x23, 0xc2, 0xa8, 0x1b, 0x13, 0xe6, 0x8e, 0x68, 0xe4, 0x5e,
0x5c, 0xa9, 0x3b, 0x37, 0x04, 0xc1, 0x21, 0xa5, 0x98, 0x30, 0x7a, 0x42, 0x58, 0x87, 0x46, 0xcf,
0xaf, 0xd0, 0x5b, 0xb0, 0x96, 0x30, 0xb2, 0x90, 0x91, 0x81, 0xb8, 0x7f, 0x01, 0x97, 0x35, 0x79,
0x97, 0x03, 0xed, 0xa7, 0x50, 0x3b, 0xf2, 0x63, 0xed, 0xad, 0x58, 0xeb, 0x77, 0x07, 0x8a, 0xa4,
0x2f, 0x8c, 0x1b, 0x06, 0x83, 0x1b, 0x71, 0xd3, 0x0a, 0x06, 0x09, 0x3a, 0x0e, 0x06, 0x37, 0xf6,
0x01, 0x6c, 0xa4, 0xf9, 0x94, 0xc0, 0xef, 0xc2, 0x8a, 0xb2, 0x41, 0xbc, 0x6d, 0xdd, 0x9d, 0xbf,
0x5f, 0xdc, 0xab, 0x3e, 0x52, 0xa1, 0xf3, 0x48, 0x2b, 0x37, 0xa1, 0xb0, 0x3f, 0x82, 0xa5, 0xe3,
0x31, 0x1b, 0x8d, 0x19, 0xba, 0x0d, 0xab, 0xc2, 0x90, 0x5c, 0x3f, 0xa5, 0xd8, 0x8a, 0x00, 0x9c,
0x10, 0x86, 0xb6, 0x61, 0x99, 0x78, 0x5e, 0x44, 0xe3, 0x58, 0x28, 0xb1, 0x8a, 0xf5, 0xa7, 0xfd,
0x5b, 0x0b, 0xca, 0xf2, 0x84, 0x5f, 0xf8, 0xec, 0xfc, 0x90, 0x52, 0x93, 0xd6, 0x4a, 0xd1, 0x7e,
0x0b, 0x77, 0xa0, 0x47, 0x50, 0xcb, 0x33, 0x34, 0x8f, 0xac, 0x85, 0xe6, 0x1c, 0x5e, 0x3b, 0x4d,
0x5b, 0x79, 0xe2, 0xbe, 0x7d, 0xd8, 0x92, 0x52, 0xc4, 0x5c, 0x8c, 0xd6, 0x70, 0x34, 0xf0, 0xfb,
0x3e, 0xe3, 0xe2, 0x3c, 0x80, 0xe5, 0x50, 0x62, 0x94, 0x39, 0xd6, 0x26, 0xe6, 0x90, 0x1c, 0x58,
0xe3, 0xed, 0x7f, 0x58, 0x50, 0xdb, 0x1f, 0x84, 0x71, 0x36, 0xd6, 0x76, 0x01, 0x64, 0x2a, 0xba,
0x17, 0x54, 0xba, 0xa2, 0x84, 0x57, 0x25, 0xe4, 0x39, 0xbd, 0x41, 0x1f, 0xc3, 0x9a, 0x3c, 0xc1,
0xbd, 0xf2, 0xd9, 0x39, 0xf7, 0xb7, 0x50, 0xad, 0xb8, 0xb7, 0x95, 0xb9, 0x49, 0x59, 0xa8, 0x39,
0x87, 0xcb, 0x61, 0xca, 0x64, 0x3f, 0x49, 0x64, 0x9c, 0x17, 0x9c, 0x77, 0x32, 0x9c, 0x59, 0xad,
0x9a, 0x73, 0x13, 0xa9, 0x1b, 0x35, 0x58, 0x3f, 0x1d, 0x07, 0x5e, 0xec, 0x7a, 0x34, 0x66, 0x7e,
0x40, 0x78, 0x35, 0xb0, 0x9f, 0xc0, 0x46, 0x5a, 0x13, 0x15, 0x1d, 0xbb, 0x00, 0x7d, 0x0e, 0x77,
0xd9, 0xb5, 0xef, 0x69, 0x55, 0x04, 0xa4, 0x7b, 0xed, 0x7b, 0xf6, 0xef, 0x2d, 0xd8, 0xe2, 0x57,
0x79, 0x11, 0xb9, 0xfa, 0x6e, 0x46, 0x30, 0xcc, 0x5c, 0xf8, 0x7a, 0x33, 0xa3, 0x77, 0xbf, 0xc6,
0xc7, 0x53, 0x1e, 0xb6, 0xbf, 0x80, 0x5b, 0x53, 0x12, 0x29, 0x65, 0x1e, 0xc2, 0xb2, 0x0a, 0x64,
0x21, 0x4f, 0x5e, 0xa4, 0x6b, 0x02, 0x5e, 0x2f, 0xae, 0xd4, 0x31, 0x52, 0xf7, 0x82, 0xd0, 0xa0,
0xa4, 0x81, 0x42, 0xfd, 0xdf, 0x58, 0xb0, 0x79, 0x40, 0x47, 0x61, 0x3c, 0x55, 0x3d, 0xbf, 0x41,
0xfb, 0x5d, 0x00, 0x32, 0x14, 0xc5, 0x88, 0x67, 0x8f, 0xcc, 0xf3, 0x55, 0x09, 0xe1, 0xe9, 0xf3,
0xdd, 0x34, 0x3e, 0x83, 0xad, 0xac, 0x10, 0xdf, 0x43, 0xe1, 0x7b, 0x50, 0xf2, 0xe4, 0x29, 0xa6,
0xbe, 0x45, 0x05, 0x13, 0xea, 0x7e, 0x65, 0x41, 0x0d, 0xd3, 0x80, 0x66, 0x5d, 0x2d, 0x6a, 0x8f,
0xac, 0xad, 0x89, 0xb6, 0xa0, 0x40, 0xd2, 0xd9, 0x49, 0x9b, 0x90, 0xe5, 0x7a, 0xba, 0x4d, 0x38,
0x02, 0x9e, 0x6a, 0x13, 0x8a, 0x74, 0xaa, 0x4d, 0x28, 0xd2, 0x19, 0x56, 0x5a, 0xc8, 0xb5, 0xd2,
0x74, 0xc7, 0xb0, 0x29, 0x6c, 0xa4, 0xb5, 0xf9, 0x7e, 0x56, 0x8b, 0xf8, 0x19, 0x64, 0x90, 0xb2,
0x9a, 0x82, 0x09, 0xab, 0x79, 0xb0, 0xd9, 0x18, 0x0f, 0x47, 0x8a, 0x95, 0x97, 0xfd, 0x6f, 0x17,
0x23, 0x33, 0xd4, 0x2b, 0xe4, 0x07, 0xc1, 0x36, 0x6c, 0x65, 0x6f, 0x91, 0xea, 0xd8, 0x7f, 0x2c,
0xc0, 0xb2, 0x02, 0x7f, 0xd3, 0x95, 0xff, 0x0f, 0x2b, 0x3c, 0xe9, 0x42, 0x3f, 0x60, 0xaa, 0x24,
0xad, 0x9b, 0x59, 0xd9, 0xe1, 0x08, 0x3c, 0x21, 0x41, 0x1b, 0xb0, 0x28, 0x7b, 0xa9, 0x0c, 0x4c,
0xf9, 0x81, 0xde, 0x81, 0x75, 0x72, 0x49, 0xfc, 0x01, 0xe9, 0x0d, 0xa8, 0xdb, 0x23, 0x03, 0x12,
0xf4, 0xa9, 0x72, 0x4a, 0x75, 0x82, 0x68, 0x48, 0x38, 0x27, 0x16, 0xde, 0x10, 0x55, 0x48, 0xcf,
0x05, 0x8b, 0xdc, 0xe1, 0xb8, 0x9a, 0x20, 0xd4, 0x5c, 0xf0, 0x0e, 0x2c, 0xc6, 0x8c, 0x30, 0xba,
0xbd, 0x74, 0xd7, 0xba, 0x5f, 0xd9, 0xdb, 0xcc, 0xba, 0xe5, 0x84, 0x23, 0xb1, 0xa4, 0xe1, 0x41,
0x39, 0x20, 0x8c, 0xc6, 0x2a, 0x9c, 0x97, 0x65, 0x50, 0x4a, 0x90, 0xf0, 0x4b, 0x1f, 0xd0, 0xc9,
0xb8, 0x37, 0xf4, 0xd9, 0x71, 0xe4, 0xd1, 0x48, 0x3b, 0xe5, 0x2e, 0xcc, 0x93, 0xf8, 0x42, 0x39,
0xbe, 0x94, 0xdc, 0x10, 0x5f, 0x34, 0xe7, 0x30, 0x47, 0x71, 0x8a, 0x9e, 0xf2, 0xb4, 0x49, 0xd1,
0xf0, 0x3d, 0x4e, 0xd1, 0xf3, 0xbd, 0xc6, 0x2a, 0x2c, 0x7b, 0x94, 0x11, 0x7f, 0x10, 0xdb, 0x5f,
0x5a, 0x50, 0x4b, 0xdd, 0xa2, 0x62, 0xec, 0x43, 0x28, 0xfb, 0xc1, 0x25, 0x19, 0xf8, 0x9e, 0x1b,
0x72, 0x84, 0xba, 0x30, 0x51, 0xa9, 0x25, 0xb1, 0x82, 0xab, 0x39, 0x87, 0x4b, 0xbe, 0xf1, 0x8d,
0xf6, 0x60, 0x83, 0xf4, 0xfb, 0x74, 0xc4, 0xa8, 0x62, 0x77, 0x83, 0x90, 0x5b, 0x59, 0x44, 0x5f,
0x73, 0x0e, 0x23, 0x8d, 0x15, 0xe4, 0x6d, 0x8e, 0x33, 0x85, 0x6a, 0xc3, 0x3a, 0x1f, 0x05, 0x04,
0x72, 0x32, 0x40, 0x6c, 0xc3, 0xf2, 0x25, 0x8d, 0x7a, 0x61, 0x4c, 0xd5, 0xf0, 0xa0, 0x3f, 0xb3,
0xa3, 0x45, 0x61, 0x6a, 0xb4, 0xf8, 0x0c, 0x90, 0x79, 0x9e, 0x52, 0xf1, 0x2e, 0x2c, 0x90, 0xf8,
0x42, 0x77, 0xd1, 0x94, 0x29, 0xb1, 0xc0, 0x70, 0x8a, 0x9e, 0xef, 0xe9, 0x06, 0x90, 0x32, 0x25,
0x16, 0x18, 0xfb, 0x09, 0xa0, 0x7d, 0x1e, 0x27, 0x83, 0x94, 0x8f, 0xee, 0x40, 0xd1, 0xd4, 0x5a,
0xd5, 0x9b, 0x70, 0xa2, 0xab, 0xbd, 0x09, 0xb5, 0x14, 0x9b, 0xca, 0x84, 0x7f, 0xcf, 0xc3, 0xa2,
0x34, 0xe0, 0x37, 0x97, 0x67, 0x91, 0x76, 0xa7, 0xfe, 0x35, 0x95, 0x9e, 0x2e, 0xe3, 0x55, 0x0e,
0x39, 0xe4, 0x00, 0x54, 0x85, 0x79, 0x32, 0x64, 0x2a, 0xea, 0xf9, 0x9f, 0xe8, 0x67, 0xb0, 0x3b,
0x24, 0xd7, 0x6e, 0x8f, 0xb0, 0xfe, 0xb9, 0x3b, 0xbb, 0x28, 0xdd, 0x1a, 0x92, 0xeb, 0x06, 0xa7,
0xc9, 0x0e, 0x7f, 0x19, 0x8d, 0x16, 0xb3, 0x1a, 0xa1, 0x07, 0xe9, 0xd0, 0xaf, 0x25, 0x69, 0xc9,
0x69, 0x52, 0x81, 0xbf, 0x01, 0x8b, 0xe3, 0xc0, 0x67, 0xb1, 0x08, 0xf9, 0x32, 0x96, 0x1f, 0x3c,
0xd1, 0xc4, 0x1f, 0xee, 0x38, 0x38, 0x1d, 0x0f, 0x4e, 0xfd, 0xc1, 0x80, 0x7a, 0xdb, 0x2b, 0x32,
0xd1, 0x04, 0xe2, 0x65, 0x02, 0x47, 0xef, 0x02, 0x8a, 0x68, 0x4c, 0xa3, 0x4b, 0xea, 0xb9, 0xc9,
0x90, 0xb7, 0x2a, 0x73, 0x58, 0x63, 0x5e, 0xe9, 0x61, 0x6f, 0x0f, 0x36, 0xfb, 0x11, 0x95, 0x19,
0xcc, 0xfc, 0x21, 0x8d, 0x19, 0x19, 0x8e, 0xdc, 0x20, 0xde, 0x06, 0xc1, 0x50, 0xd3, 0xc8, 0xae,
0xc6, 0xb5, 0xb9, 0x38, 0x4b, 0xf4, 0x92, 0xf2, 0x99, 0xb3, 0x28, 0x9c, 0x9f, 0x51, 0xc8, 0xe1,
0x38, 0xac, 0x48, 0xd4, 0x68, 0xec, 0x4a, 0xf9, 0x87, 0xdc, 0x7e, 0xdb, 0x25, 0x21, 0x39, 0x1f,
0x8d, 0x5f, 0x72, 0xe8, 0x0b, 0x0e, 0xb4, 0xff, 0x62, 0xc1, 0x7c, 0xc3, 0xf7, 0xd0, 0xfd, 0x49,
0xa8, 0xab, 0xb4, 0xaa, 0xa4, 0x4f, 0xc7, 0x1a, 0xcd, 0x45, 0x1f, 0x50, 0x12, 0x53, 0xd7, 0x1b,
0xab, 0x12, 0xd4, 0x1b, 0x84, 0xfd, 0x8b, 0x58, 0xf9, 0xbc, 0x26, 0x90, 0x07, 0x0a, 0xd7, 0x10,
0x28, 0x95, 0x28, 0xb1, 0x1f, 0x06, 0xb2, 0x33, 0x61, 0xfd, 0x89, 0x9e, 0x00, 0x17, 0xc8, 0x0d,
0x42, 0x8f, 0xba, 0xcc, 0xa7, 0x91, 0xf0, 0x7a, 0xc5, 0xa8, 0xa1, 0xed, 0xd0, 0xa3, 0x5d, 0x9f,
0x46, 0xb8, 0x38, 0xf4, 0x03, 0xfd, 0x61, 0xff, 0x1a, 0xe6, 0xeb, 0xf1, 0xc5, 0xff, 0x4a, 0x6a,
0xfb, 0xef, 0x16, 0x40, 0x62, 0x74, 0xde, 0xd1, 0x52, 0x4e, 0xe4, 0xb2, 0xcc, 0xe3, 0x22, 0x33,
0x9c, 0x77, 0x1b, 0x56, 0x85, 0x67, 0xdc, 0x98, 0x45, 0x6a, 0xbe, 0x5f, 0x11, 0x80, 0x13, 0x16,
0xa1, 0x67, 0x50, 0x12, 0x71, 0xe8, 0xf6, 0xcf, 0x49, 0x70, 0x46, 0xd5, 0x80, 0x9a, 0x14, 0xb6,
0x97, 0x23, 0x8f, 0x30, 0xea, 0x89, 0xcb, 0x9a, 0x73, 0xb8, 0x28, 0x88, 0xf7, 0x05, 0x2d, 0x7a,
0x0c, 0xcb, 0xc2, 0xbd, 0xd4, 0x13, 0xa6, 0x33, 0xc3, 0x42, 0x78, 0x58, 0x33, 0x69, 0xaa, 0xc6,
0x32, 0x2c, 0x8a, 0x8b, 0xed, 0x3f, 0x5b, 0x50, 0x32, 0x4f, 0x46, 0xcf, 0xa0, 0x32, 0x8a, 0xe8,
0xa5, 0x1f, 0x8e, 0x63, 0x57, 0x66, 0x8e, 0x35, 0x3b, 0x73, 0xca, 0x9a, 0x54, 0x7c, 0xa2, 0xf7,
0x60, 0x35, 0xa0, 0x57, 0x8a, 0xad, 0x30, 0x9b, 0x6d, 0x25, 0xa0, 0x57, 0x92, 0xe3, 0x1e, 0x94,
0x64, 0x74, 0xaa, 0xc4, 0x92, 0x26, 0x2e, 0x0a, 0xd8, 0xa1, 0x00, 0xd9, 0xff, 0xb4, 0x00, 0x12,
0x25, 0xd0, 0xfb, 0x50, 0x14, 0x4a, 0xcc, 0x10, 0x4e, 0x50, 0xca, 0x5b, 0x60, 0x38, 0xf9, 0x7b,
0xea, 0x9e, 0xc2, 0xd4, 0x3d, 0x7c, 0x70, 0x55, 0xd6, 0x51, 0x9d, 0x65, 0x5e, 0x0e, 0xae, 0x0a,
0x28, 0xeb, 0xdf, 0x47, 0x50, 0x8e, 0xe8, 0x17, 0xb4, 0xcf, 0xdc, 0x88, 0x92, 0x38, 0x0c, 0x54,
0xa4, 0xee, 0xa4, 0xef, 0xc7, 0x82, 0x04, 0x0b, 0x0a, 0x5c, 0x8a, 0x8c, 0x2f, 0x3e, 0x6e, 0x60,
0xda, 0x0f, 0x2f, 0x69, 0x94, 0x79, 0x88, 0xda, 0xc7, 0x70, 0x6b, 0x0a, 0xa3, 0x3a, 0xc2, 0xfb,
0xb0, 0x15, 0x8c, 0x87, 0x6e, 0x24, 0xd1, 0xd4, 0x73, 0x8d, 0x87, 0x27, 0xd7, 0x63, 0x23, 0x18,
0x0f, 0xb1, 0x46, 0x6a, 0x6e, 0xbb, 0x06, 0xeb, 0x75, 0xb9, 0xb3, 0x48, 0x66, 0x27, 0xbb, 0x03,
0xc8, 0x04, 0xaa, 0x0b, 0x9e, 0x41, 0x99, 0x5e, 0xd3, 0xfe, 0x58, 0xe4, 0x04, 0x7f, 0x57, 0x65,
0xbb, 0xaa, 0xa3, 0xb1, 0x9c, 0xab, 0x44, 0x8d, 0x2f, 0xfb, 0x5f, 0x0b, 0xb0, 0x78, 0xc4, 0x13,
0x07, 0x3d, 0x85, 0x32, 0x8f, 0xdd, 0x80, 0x0e, 0x5c, 0x39, 0x0a, 0x59, 0xb3, 0x46, 0xa1, 0x92,
0xa2, 0x13, 0x5f, 0xbc, 0x4c, 0x69, 0x3e, 0x32, 0x34, 0x27, 0x7b, 0x7d, 0x5c, 0x7d, 0x28, 0xa6,
0xfb, 0xa7, 0x70, 0x4b, 0xd3, 0x65, 0x13, 0x58, 0xc6, 0xcd, 0xa6, 0x42, 0x67, 0x52, 0xf8, 0x3d,
0xd8, 0xd0, 0x7c, 0x32, 0xfd, 0xd5, 0x7c, 0x2c, 0xf6, 0x23, 0x18, 0x29, 0x9c, 0xd0, 0x41, 0x4d,
0xc8, 0x77, 0xa0, 0x38, 0x8a, 0xe8, 0xd0, 0x1f, 0x0f, 0x85, 0x34, 0x8b, 0x42, 0x1a, 0x50, 0x20,
0x2e, 0xca, 0x43, 0x3e, 0x7e, 0x19, 0x06, 0x13, 0x64, 0x4b, 0x72, 0xc2, 0x34, 0xad, 0xc3, 0x69,
0x6d, 0x61, 0x16, 0x3f, 0xa1, 0x5b, 0x16, 0x74, 0x45, 0x01, 0x54, 0x34, 0x8f, 0xa0, 0xd6, 0x1f,
0x50, 0x12, 0xf9, 0xc1, 0x99, 0x6c, 0x81, 0xa3, 0xc8, 0xef, 0x53, 0xd1, 0x67, 0x16, 0xf0, 0xba,
0x46, 0xf1, 0xd6, 0xd7, 0xe1, 0x08, 0x74, 0x1f, 0xaa, 0xb2, 0xef, 0x89, 0x4e, 0x2b, 0x58, 0x54,
0x9b, 0xa9, 0x08, 0xb8, 0xe8, 0xb7, 0x58, 0x8d, 0x73, 0x66, 0x87, 0x84, 0xa9, 0x0e, 0xf9, 0x3a,
0xac, 0x8e, 0xc6, 0x51, 0xff, 0x9c, 0xc4, 0xd4, 0xdb, 0x2e, 0x8a, 0x19, 0x25, 0x01, 0xa0, 0x27,
0x89, 0xcd, 0x23, 0x3a, 0x0c, 0x19, 0x95, 0x55, 0x9a, 0x77, 0xff, 0x92, 0x38, 0x4a, 0x9b, 0x16,
0x0b, 0x2c, 0xaf, 0xcd, 0x7c, 0x10, 0xf8, 0x29, 0xac, 0x6b, 0xb6, 0xa4, 0xaa, 0x97, 0x67, 0x55,
0x75, 0xed, 0xfe, 0x49, 0x65, 0x6f, 0x42, 0x59, 0xb8, 0x63, 0x32, 0x64, 0xdd, 0x86, 0x55, 0x39,
0x23, 0xf0, 0xb1, 0x87, 0x0f, 0x46, 0x25, 0xbc, 0x22, 0x00, 0x2d, 0x2f, 0x46, 0x3b, 0xc6, 0x26,
0xa6, 0x20, 0x71, 0x93, 0xbd, 0xcb, 0x9f, 0x2c, 0xa8, 0xe8, 0xa3, 0x54, 0xb0, 0xbf, 0x05, 0x4b,
0x22, 0x0c, 0xf4, 0x84, 0x95, 0xb4, 0x0b, 0x41, 0x88, 0x15, 0x16, 0x3d, 0x86, 0x0d, 0xb1, 0x4e,
0x12, 0x41, 0x49, 0x49, 0x14, 0x50, 0xcf, 0x88, 0xcd, 0x75, 0x81, 0xab, 0x0f, 0x99, 0x23, 0x30,
0xdc, 0x89, 0xef, 0x00, 0x4a, 0x18, 0x46, 0xc4, 0x97, 0xe4, 0xea, 0xf1, 0xa9, 0xc9, 0x3b, 0xc4,
0xe7, 0xc4, 0xf6, 0x1a, 0x94, 0xbb, 0xe1, 0x05, 0x0d, 0x26, 0xf9, 0xff, 0x21, 0x54, 0x34, 0x60,
0xf2, 0x9e, 0x5a, 0x62, 0x02, 0xa2, 0x04, 0x45, 0x89, 0xa0, 0x31, 0x61, 0x82, 0x18, 0x2b, 0x0a,
0xfb, 0xaf, 0x05, 0x58, 0x9d, 0x40, 0x79, 0x2d, 0xeb, 0xf1, 0x40, 0x1f, 0x92, 0x3e, 0x89, 0xc2,
0x30, 0x50, 0x93, 0x5a, 0x89, 0x03, 0x5f, 0x28, 0x18, 0xaf, 0x89, 0x23, 0x72, 0x33, 0xe4, 0xfd,
0xe8, 0x9c, 0xc4, 0xe7, 0xfa, 0x09, 0xa6, 0x60, 0x4d, 0x12, 0x9f, 0xa3, 0x07, 0x50, 0xd5, 0x24,
0xa3, 0x88, 0xfa, 0x43, 0xa2, 0xfa, 0x52, 0x09, 0xaf, 0x29, 0x78, 0x47, 0x81, 0x79, 0x44, 0xaa,
0x97, 0xb9, 0xd0, 0x7c, 0xc8, 0x55, 0x5f, 0x10, 0x2d, 0xb0, 0x22, 0xe1, 0x5c, 0xf1, 0x17, 0x31,
0x61, 0xe8, 0x07, 0xb0, 0x19, 0x85, 0x63, 0xc6, 0x43, 0x9d, 0x67, 0x44, 0x42, 0xbe, 0x28, 0xc8,
0x91, 0x42, 0x1e, 0x52, 0x3a, 0x61, 0x51, 0xbd, 0xd5, 0x15, 0x13, 0x11, 0xf5, 0x44, 0xa6, 0xa9,
0xde, 0xba, 0x2f, 0x41, 0xbc, 0x4f, 0x8b, 0xb4, 0xa6, 0xf2, 0xc9, 0xb2, 0x82, 0xf5, 0x27, 0x67,
0x8e, 0x59, 0x18, 0x91, 0x33, 0xea, 0x06, 0x64, 0x28, 0x93, 0x6a, 0x95, 0xf7, 0x4f, 0x01, 0x6b,
0x93, 0x21, 0xb5, 0xb7, 0x60, 0xe3, 0xc8, 0xec, 0xfd, 0xda, 0x27, 0x5f, 0xce, 0xc3, 0x66, 0x06,
0xa1, 0x7c, 0xe3, 0xc2, 0x5a, 0x7a, 0x94, 0xd0, 0x4e, 0xda, 0x4b, 0x47, 0x53, 0x96, 0x31, 0x0d,
0x8d, 0x9d, 0x80, 0x45, 0x37, 0x8d, 0xc2, 0xb6, 0x85, 0x2b, 0xa9, 0xe1, 0x23, 0x46, 0x01, 0x6c,
0x65, 0x67, 0x95, 0x71, 0xff, 0x82, 0x4e, 0xd6, 0x3e, 0x1f, 0x7c, 0x97, 0x7b, 0x1a, 0x92, 0x55,
0xdc, 0x86, 0x37, 0x06, 0x39, 0xa8, 0x9d, 0x3a, 0xd4, 0x72, 0x44, 0xe3, 0x23, 0xbb, 0x9e, 0xf4,
0xcb, 0x98, 0xff, 0x99, 0x3c, 0x5e, 0xe5, 0x7b, 0x46, 0x7e, 0x3c, 0x2b, 0x7c, 0x60, 0xed, 0x50,
0x78, 0x6d, 0xe6, 0xad, 0x39, 0x07, 0xed, 0x99, 0x07, 0x55, 0xf6, 0x5e, 0x9f, 0x28, 0x94, 0xe6,
0x57, 0x33, 0xfa, 0xe4, 0x1a, 0xee, 0xac, 0x36, 0xbd, 0x66, 0xe2, 0x3d, 0xd0, 0x0a, 0x4e, 0x43,
0xed, 0xac, 0xdf, 0x59, 0xb0, 0x99, 0x41, 0x28, 0x67, 0xdd, 0x49, 0xef, 0x43, 0xe5, 0x33, 0xd9,
0xdc, 0x86, 0xce, 0x58, 0x19, 0x2c, 0xe5, 0xae, 0x0c, 0xd0, 0xdb, 0xb0, 0x26, 0x2a, 0x72, 0x32,
0xb4, 0xab, 0x92, 0x5e, 0x11, 0xe0, 0xc9, 0xb8, 0x6e, 0x3f, 0x85, 0x75, 0x5e, 0xd2, 0x30, 0xe1,
0xf1, 0xac, 0x4b, 0xd9, 0x3d, 0x28, 0x89, 0x92, 0x38, 0x1a, 0xf7, 0x2e, 0xe8, 0x8d, 0xae, 0x66,
0x45, 0x0e, 0xeb, 0x48, 0x90, 0x7d, 0x04, 0xc8, 0xe4, 0x53, 0x5a, 0x3c, 0x55, 0x8c, 0x91, 0x00,
0xeb, 0x78, 0xab, 0xa5, 0xca, 0xa9, 0x62, 0x11, 0xa7, 0xc9, 0xbf, 0xe3, 0x87, 0x7f, 0xb0, 0xa0,
0x64, 0x3e, 0xf4, 0x51, 0x15, 0x4a, 0x1d, 0xa7, 0x7d, 0xd0, 0x6a, 0x7f, 0xe2, 0x1e, 0x77, 0x9c,
0x76, 0x75, 0x0e, 0x21, 0xa8, 0x68, 0xc8, 0xcb, 0xce, 0x41, 0xbd, 0xeb, 0x54, 0x2d, 0xb4, 0x02,
0x0b, 0x02, 0x5b, 0x40, 0x45, 0x58, 0x76, 0x3e, 0xeb, 0xb4, 0xb0, 0x73, 0x50, 0x9d, 0x37, 0x49,
0xf7, 0x8f, 0x8e, 0x4f, 0x9c, 0x83, 0xea, 0x02, 0x02, 0x58, 0x52, 0x7f, 0x2f, 0xa2, 0x1a, 0xac,
0x61, 0x67, 0xff, 0xf8, 0x95, 0x83, 0x7f, 0xe9, 0x1e, 0xd6, 0x5b, 0x47, 0xce, 0x41, 0x75, 0x09,
0xad, 0x43, 0x59, 0x33, 0x35, 0xea, 0xdd, 0xfd, 0x66, 0x75, 0xf9, 0x61, 0x47, 0x4d, 0x75, 0x52,
0xa4, 0x22, 0x2c, 0x77, 0xb0, 0xd3, 0xa9, 0x63, 0xa7, 0x3a, 0x87, 0x4a, 0xb0, 0x52, 0xdf, 0xdf,
0x77, 0x3a, 0x5d, 0xe7, 0xa0, 0x6a, 0xf1, 0x2f, 0xec, 0xfc, 0xdc, 0xd9, 0xe7, 0x5f, 0x05, 0x7e,
0xd5, 0x49, 0xeb, 0x93, 0xb6, 0x10, 0xa5, 0x0c, 0xab, 0x87, 0xad, 0x76, 0xfd, 0xa8, 0xf5, 0x39,
0x97, 0xe2, 0xe1, 0xdf, 0x2c, 0x58, 0x9f, 0x1a, 0xbf, 0xb8, 0x1a, 0xed, 0xe3, 0x36, 0x3f, 0x76,
0x0b, 0xd0, 0x89, 0x83, 0x5f, 0x39, 0xd8, 0x7d, 0xd1, 0x3a, 0x69, 0x38, 0xcd, 0xfa, 0xab, 0xd6,
0x31, 0xae, 0x5a, 0x68, 0x07, 0xb6, 0x84, 0x50, 0xee, 0x2b, 0x07, 0x9f, 0xb4, 0x8e, 0xdb, 0x1c,
0xfd, 0x42, 0x48, 0x59, 0x40, 0xbb, 0xf0, 0x5a, 0xa7, 0x8e, 0xbb, 0xad, 0xfa, 0x91, 0x2b, 0x85,
0x70, 0xf7, 0x8f, 0x8f, 0x8e, 0xea, 0x5d, 0x07, 0xd7, 0x8f, 0xaa, 0xf3, 0xe8, 0x1e, 0xec, 0x66,
0xd0, 0x07, 0x2f, 0x3b, 0x47, 0xad, 0xfd, 0x7a, 0xd7, 0x71, 0x3b, 0x8e, 0x83, 0xab, 0x0b, 0xe8,
0x01, 0xbc, 0x99, 0x3d, 0xa1, 0x59, 0x6f, 0xb7, 0x9d, 0x23, 0xf7, 0xf0, 0xa5, 0xb4, 0x88, 0xb2,
0xd2, 0xe2, 0xde, 0x7f, 0x8a, 0xb0, 0xd4, 0x15, 0x6f, 0x69, 0xf4, 0x1c, 0x4a, 0xe6, 0xaf, 0x24,
0x28, 0x49, 0x8e, 0x9c, 0xdf, 0x68, 0x76, 0x76, 0x67, 0x60, 0x27, 0x3b, 0x93, 0xa2, 0xf1, 0x3b,
0x15, 0xba, 0x6d, 0xec, 0x4a, 0xb2, 0xfb, 0xd7, 0x9d, 0xa9, 0x95, 0x1d, 0x17, 0xc5, 0xfc, 0xfd,
0xc3, 0x10, 0x25, 0xe7, 0xe7, 0x14, 0x43, 0x94, 0xdc, 0x1f, 0x4d, 0x9e, 0x43, 0xc9, 0x5c, 0x97,
0x1b, 0x87, 0xe5, 0xfc, 0x1e, 0x60, 0x1c, 0x96, 0xbb, 0x63, 0xef, 0xc2, 0x5a, 0x66, 0x63, 0x8d,
0x92, 0x7d, 0x7e, 0xfe, 0x76, 0x7d, 0xe7, 0xee, 0x6c, 0x02, 0x75, 0xea, 0xa7, 0x50, 0x49, 0x6f,
0x85, 0xd1, 0x1b, 0x49, 0x65, 0xca, 0xdb, 0x59, 0xef, 0xdc, 0x99, 0x89, 0x4f, 0xb4, 0x36, 0x17,
0xa6, 0x86, 0xd6, 0x39, 0x5b, 0x61, 0x43, 0xeb, 0xdc, 0x2d, 0xeb, 0xa7, 0x50, 0x49, 0x2f, 0x2c,
0x0d, 0xf9, 0x72, 0xf7, 0xa5, 0x86, 0x7c, 0xf9, 0x9b, 0x4e, 0x6e, 0xc8, 0xcc, 0xd3, 0xc3, 0x30,
0x64, 0xfe, 0x73, 0xc5, 0x30, 0xe4, 0xac, 0x57, 0x4b, 0x13, 0x8a, 0xc6, 0x06, 0xcf, 0x08, 0xbb,
0xe9, 0xed, 0xe1, 0xce, 0xeb, 0xf9, 0x48, 0x75, 0x92, 0x03, 0x90, 0xec, 0xc9, 0xd0, 0x4e, 0x2a,
0xc4, 0x52, 0xcb, 0xb8, 0x9d, 0xdb, 0xb9, 0xb8, 0x44, 0x20, 0x63, 0xbb, 0x65, 0x08, 0x34, 0xbd,
0x2a, 0x33, 0x04, 0xca, 0x59, 0x88, 0x71, 0x81, 0x92, 0x57, 0x94, 0x21, 0xd0, 0xd4, 0x7b, 0xcb,
0x10, 0x28, 0xe7, 0xd9, 0x75, 0xac, 0x66, 0xd3, 0xa4, 0xeb, 0xef, 0xce, 0xea, 0xea, 0xf2, 0xb4,
0x37, 0xbe, 0xbe, 0xe9, 0xa3, 0x36, 0x94, 0x53, 0x1d, 0xd0, 0x38, 0x2f, 0xaf, 0x65, 0x1a, 0xe7,
0xe5, 0x37, 0xce, 0x36, 0x94, 0x05, 0xf0, 0x24, 0x20, 0xa3, 0xf8, 0x3c, 0x64, 0xc6, 0x79, 0x29,
0xf8, 0xf4, 0x79, 0x19, 0xb4, 0x3a, 0xef, 0x63, 0x28, 0x7f, 0x42, 0xd9, 0x64, 0x4e, 0x8d, 0x51,
0xf2, 0xcb, 0x5d, 0x6a, 0x18, 0xde, 0xb9, 0x35, 0x05, 0x57, 0x27, 0xfc, 0x18, 0x96, 0xe4, 0x38,
0x6f, 0xb0, 0xa6, 0x9e, 0x0a, 0x06, 0x6b, 0x66, 0xee, 0x3f, 0x84, 0x62, 0xd2, 0x22, 0xcd, 0x30,
0x9a, 0xea, 0xd1, 0x86, 0xd7, 0x72, 0xfa, 0x30, 0x4f, 0x40, 0x53, 0xbb, 0x18, 0xcd, 0x50, 0x3b,
0xce, 0x49, 0xc0, 0x0c, 0x5e, 0x1e, 0xd9, 0x78, 0xfb, 0xf3, 0x37, 0xcf, 0x7c, 0x76, 0x3e, 0xee,
0x3d, 0xea, 0x87, 0xc3, 0xc7, 0x03, 0xff, 0xec, 0x9c, 0x05, 0x7e, 0x70, 0x36, 0x20, 0xbd, 0xf8,
0x31, 0x67, 0x7d, 0xac, 0xf8, 0x7b, 0x4b, 0xe2, 0x5f, 0x0f, 0x7e, 0xf8, 0xdf, 0x00, 0x00, 0x00,
0xff, 0xff, 0x6c, 0x39, 0x4b, 0xb1, 0xb3, 0x20, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -3402,7 +3403,7 @@ type TraderClient interface {
//BatchSnapshot returns the snapshot of a past batch identified by its ID.
//If no ID is provided, the snapshot of the last finalized batch is returned.
//Deprecated, use BatchSnapshots instead.
BatchSnapshot(ctx context.Context, in *BatchSnapshotRequest, opts ...grpc.CallOption) (*BatchSnapshotResponse, error)
BatchSnapshot(ctx context.Context, in *auctioneerrpc.BatchSnapshotRequest, opts ...grpc.CallOption) (*auctioneerrpc.BatchSnapshotResponse, error)
// pool: `listauth`
//GetLsatTokens returns all LSAT tokens the daemon ever paid for.
GetLsatTokens(ctx context.Context, in *TokensRequest, opts ...grpc.CallOption) (*TokensResponse, error)
@ -3420,7 +3421,7 @@ type TraderClient interface {
//number of specified batches. A maximum of 100 snapshots can be queried in
//one call. If no start batch ID is provided, the most recent finalized batch
//is used as the starting point to go back from.
BatchSnapshots(ctx context.Context, in *BatchSnapshotsRequest, opts ...grpc.CallOption) (*BatchSnapshotsResponse, error)
BatchSnapshots(ctx context.Context, in *auctioneerrpc.BatchSnapshotsRequest, opts ...grpc.CallOption) (*auctioneerrpc.BatchSnapshotsResponse, error)
}
type traderClient struct {
@ -3566,8 +3567,8 @@ func (c *traderClient) NextBatchInfo(ctx context.Context, in *NextBatchInfoReque
return out, nil
}
func (c *traderClient) BatchSnapshot(ctx context.Context, in *BatchSnapshotRequest, opts ...grpc.CallOption) (*BatchSnapshotResponse, error) {
out := new(BatchSnapshotResponse)
func (c *traderClient) BatchSnapshot(ctx context.Context, in *auctioneerrpc.BatchSnapshotRequest, opts ...grpc.CallOption) (*auctioneerrpc.BatchSnapshotResponse, error) {
out := new(auctioneerrpc.BatchSnapshotResponse)
err := c.cc.Invoke(ctx, "/poolrpc.Trader/BatchSnapshot", in, out, opts...)
if err != nil {
return nil, err
@ -3602,8 +3603,8 @@ func (c *traderClient) NodeRatings(ctx context.Context, in *NodeRatingRequest, o
return out, nil
}
func (c *traderClient) BatchSnapshots(ctx context.Context, in *BatchSnapshotsRequest, opts ...grpc.CallOption) (*BatchSnapshotsResponse, error) {
out := new(BatchSnapshotsResponse)
func (c *traderClient) BatchSnapshots(ctx context.Context, in *auctioneerrpc.BatchSnapshotsRequest, opts ...grpc.CallOption) (*auctioneerrpc.BatchSnapshotsResponse, error) {
out := new(auctioneerrpc.BatchSnapshotsResponse)
err := c.cc.Invoke(ctx, "/poolrpc.Trader/BatchSnapshots", in, out, opts...)
if err != nil {
return nil, err
@ -3681,7 +3682,7 @@ type TraderServer interface {
//BatchSnapshot returns the snapshot of a past batch identified by its ID.
//If no ID is provided, the snapshot of the last finalized batch is returned.
//Deprecated, use BatchSnapshots instead.
BatchSnapshot(context.Context, *BatchSnapshotRequest) (*BatchSnapshotResponse, error)
BatchSnapshot(context.Context, *auctioneerrpc.BatchSnapshotRequest) (*auctioneerrpc.BatchSnapshotResponse, error)
// pool: `listauth`
//GetLsatTokens returns all LSAT tokens the daemon ever paid for.
GetLsatTokens(context.Context, *TokensRequest) (*TokensResponse, error)
@ -3699,7 +3700,7 @@ type TraderServer interface {
//number of specified batches. A maximum of 100 snapshots can be queried in
//one call. If no start batch ID is provided, the most recent finalized batch
//is used as the starting point to go back from.
BatchSnapshots(context.Context, *BatchSnapshotsRequest) (*BatchSnapshotsResponse, error)
BatchSnapshots(context.Context, *auctioneerrpc.BatchSnapshotsRequest) (*auctioneerrpc.BatchSnapshotsResponse, error)
}
// UnimplementedTraderServer can be embedded to have forward compatible implementations.
@ -3751,7 +3752,7 @@ func (*UnimplementedTraderServer) LeaseDurations(ctx context.Context, req *Lease
func (*UnimplementedTraderServer) NextBatchInfo(ctx context.Context, req *NextBatchInfoRequest) (*NextBatchInfoResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method NextBatchInfo not implemented")
}
func (*UnimplementedTraderServer) BatchSnapshot(ctx context.Context, req *BatchSnapshotRequest) (*BatchSnapshotResponse, error) {
func (*UnimplementedTraderServer) BatchSnapshot(ctx context.Context, req *auctioneerrpc.BatchSnapshotRequest) (*auctioneerrpc.BatchSnapshotResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BatchSnapshot not implemented")
}
func (*UnimplementedTraderServer) GetLsatTokens(ctx context.Context, req *TokensRequest) (*TokensResponse, error) {
@ -3763,7 +3764,7 @@ func (*UnimplementedTraderServer) Leases(ctx context.Context, req *LeasesRequest
func (*UnimplementedTraderServer) NodeRatings(ctx context.Context, req *NodeRatingRequest) (*NodeRatingResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method NodeRatings not implemented")
}
func (*UnimplementedTraderServer) BatchSnapshots(ctx context.Context, req *BatchSnapshotsRequest) (*BatchSnapshotsResponse, error) {
func (*UnimplementedTraderServer) BatchSnapshots(ctx context.Context, req *auctioneerrpc.BatchSnapshotsRequest) (*auctioneerrpc.BatchSnapshotsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BatchSnapshots not implemented")
}
@ -4042,7 +4043,7 @@ func _Trader_NextBatchInfo_Handler(srv interface{}, ctx context.Context, dec fun
}
func _Trader_BatchSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BatchSnapshotRequest)
in := new(auctioneerrpc.BatchSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -4054,7 +4055,7 @@ func _Trader_BatchSnapshot_Handler(srv interface{}, ctx context.Context, dec fun
FullMethod: "/poolrpc.Trader/BatchSnapshot",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TraderServer).BatchSnapshot(ctx, req.(*BatchSnapshotRequest))
return srv.(TraderServer).BatchSnapshot(ctx, req.(*auctioneerrpc.BatchSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
@ -4114,7 +4115,7 @@ func _Trader_NodeRatings_Handler(srv interface{}, ctx context.Context, dec func(
}
func _Trader_BatchSnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BatchSnapshotsRequest)
in := new(auctioneerrpc.BatchSnapshotsRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -4126,7 +4127,7 @@ func _Trader_BatchSnapshots_Handler(srv interface{}, ctx context.Context, dec fu
FullMethod: "/poolrpc.Trader/BatchSnapshots",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TraderServer).BatchSnapshots(ctx, req.(*BatchSnapshotsRequest))
return srv.(TraderServer).BatchSnapshots(ctx, req.(*auctioneerrpc.BatchSnapshotsRequest))
}
return interceptor(ctx, in, info, handler)
}

9
poolrpc/trader.pb.gw.go
View file

@ -17,6 +17,7 @@ import (
"github.com/golang/protobuf/proto"
"github.com/grpc-ecosystem/grpc-gateway/runtime"
"github.com/grpc-ecosystem/grpc-gateway/utilities"
"github.com/lightninglabs/pool/auctioneerrpc"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/grpclog"
@ -515,7 +516,7 @@ var (
)
func request_Trader_BatchSnapshot_0(ctx context.Context, marshaler runtime.Marshaler, client TraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq BatchSnapshotRequest
var protoReq auctioneerrpc.BatchSnapshotRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
@ -531,7 +532,7 @@ func request_Trader_BatchSnapshot_0(ctx context.Context, marshaler runtime.Marsh
}
func local_request_Trader_BatchSnapshot_0(ctx context.Context, marshaler runtime.Marshaler, server TraderServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq BatchSnapshotRequest
var protoReq auctioneerrpc.BatchSnapshotRequest
var metadata runtime.ServerMetadata
if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Trader_BatchSnapshot_0); err != nil {
@ -628,7 +629,7 @@ func local_request_Trader_NodeRatings_0(ctx context.Context, marshaler runtime.M
}
func request_Trader_BatchSnapshots_0(ctx context.Context, marshaler runtime.Marshaler, client TraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq BatchSnapshotsRequest
var protoReq auctioneerrpc.BatchSnapshotsRequest
var metadata runtime.ServerMetadata
var (
@ -666,7 +667,7 @@ func request_Trader_BatchSnapshots_0(ctx context.Context, marshaler runtime.Mars
}
func local_request_Trader_BatchSnapshots_0(ctx context.Context, marshaler runtime.Marshaler, server TraderServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq BatchSnapshotsRequest
var protoReq auctioneerrpc.BatchSnapshotsRequest
var metadata runtime.ServerMetadata
var (

2
poolrpc/trader.proto
View file

@ -1,6 +1,6 @@
syntax = "proto3";
import "auctioneer.proto";
import "auctioneerrpc/auctioneer.proto";
package poolrpc;

117
rpcserver.go
View file

@ -21,6 +21,7 @@ import (
"github.com/lightninglabs/lndclient"
"github.com/lightninglabs/pool/account"
"github.com/lightninglabs/pool/auctioneer"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightninglabs/pool/chaninfo"
"github.com/lightninglabs/pool/clientdb"
"github.com/lightninglabs/pool/event"
@ -345,10 +346,12 @@ func (s *rpcServer) updateHeight(height int32) {
// handleServerMessage reads a gRPC message received in the stream from the
// auctioneer server and passes it to the correct manager.
func (s *rpcServer) handleServerMessage(rpcMsg *poolrpc.ServerAuctionMessage) error {
func (s *rpcServer) handleServerMessage(
rpcMsg *auctioneerrpc.ServerAuctionMessage) error {
switch msg := rpcMsg.Msg.(type) {
// A new batch has been assembled with some of our orders.
case *poolrpc.ServerAuctionMessage_Prepare:
case *auctioneerrpc.ServerAuctionMessage_Prepare:
// Parse and formally validate what we got from the server.
rpcLog.Tracef("Received prepare msg from server, batch_id=%x: %v",
msg.Prepare.BatchId, spew.Sdump(msg))
@ -440,7 +443,7 @@ func (s *rpcServer) handleServerMessage(rpcMsg *poolrpc.ServerAuctionMessage) er
return s.sendRejectBatch(batch, err)
}
case *poolrpc.ServerAuctionMessage_Sign:
case *auctioneerrpc.ServerAuctionMessage_Sign:
// We were able to accept the batch. Inform the auctioneer,
// then start negotiating with the remote peers. We'll sign
// once all channel partners have responded.
@ -471,7 +474,7 @@ func (s *rpcServer) handleServerMessage(rpcMsg *poolrpc.ServerAuctionMessage) er
// The previously prepared batch has been executed and we can finalize
// it by opening the channel and persisting the account and order diffs.
case *poolrpc.ServerAuctionMessage_Finalize:
case *auctioneerrpc.ServerAuctionMessage_Finalize:
rpcLog.Tracef("Received finalize msg from server, batch_id=%x: %v",
msg.Finalize.BatchId, spew.Sdump(msg))
@ -703,7 +706,7 @@ func MarshallAccount(a *account.Account) (*poolrpc.Account, error) {
return &poolrpc.Account{
TraderKey: a.TraderKey.PubKey.SerializeCompressed(),
Outpoint: &poolrpc.OutPoint{
Outpoint: &auctioneerrpc.OutPoint{
Txid: a.OutPoint.Hash[:],
OutputIndex: a.OutPoint.Index,
},
@ -1447,8 +1450,8 @@ func (s *rpcServer) sendRejectBatch(batch *order.Batch, failure error) error {
return err
}
msg := &poolrpc.ClientAuctionMessage_Reject{
Reject: &poolrpc.OrderMatchReject{
msg := &auctioneerrpc.ClientAuctionMessage_Reject{
Reject: &auctioneerrpc.OrderMatchReject{
BatchId: batch.ID[:],
Reason: failure.Error(),
},
@ -1458,7 +1461,7 @@ func (s *rpcServer) sendRejectBatch(batch *order.Batch, failure error) error {
var partialReject *funding.MatchRejectErr
switch {
case errors.Is(failure, order.ErrVersionMismatch):
msg.Reject.ReasonCode = poolrpc.OrderMatchReject_BATCH_VERSION_MISMATCH
msg.Reject.ReasonCode = auctioneerrpc.OrderMatchReject_BATCH_VERSION_MISMATCH
// Track this reject by adding an event to our orders.
err := s.server.db.StoreBatchEvents(
@ -1470,7 +1473,7 @@ func (s *rpcServer) sendRejectBatch(batch *order.Batch, failure error) error {
}
case errors.Is(failure, order.ErrMismatchErr):
msg.Reject.ReasonCode = poolrpc.OrderMatchReject_SERVER_MISBEHAVIOR
msg.Reject.ReasonCode = auctioneerrpc.OrderMatchReject_SERVER_MISBEHAVIOR
// Track this reject by adding an event to our orders.
err := s.server.db.StoreBatchEvents(
@ -1482,8 +1485,8 @@ func (s *rpcServer) sendRejectBatch(batch *order.Batch, failure error) error {
}
case errors.As(failure, &partialReject):
msg.Reject.ReasonCode = poolrpc.OrderMatchReject_PARTIAL_REJECT
msg.Reject.RejectedOrders = make(map[string]*poolrpc.OrderReject)
msg.Reject.ReasonCode = auctioneerrpc.OrderMatchReject_PARTIAL_REJECT
msg.Reject.RejectedOrders = make(map[string]*auctioneerrpc.OrderReject)
for nonce, reject := range partialReject.RejectedOrders {
msg.Reject.RejectedOrders[nonce.String()] = reject
}
@ -1498,7 +1501,7 @@ func (s *rpcServer) sendRejectBatch(batch *order.Batch, failure error) error {
}
default:
msg.Reject.ReasonCode = poolrpc.OrderMatchReject_UNKNOWN
msg.Reject.ReasonCode = auctioneerrpc.OrderMatchReject_UNKNOWN
}
rpcLog.Infof("Sending batch rejection message for batch %x with "+
@ -1508,7 +1511,7 @@ func (s *rpcServer) sendRejectBatch(batch *order.Batch, failure error) error {
// Send the message to the server. If a new error happens we return that
// one because we know the causing error has at least been logged at
// some point before.
err = s.auctioneer.SendAuctionMessage(&poolrpc.ClientAuctionMessage{
err = s.auctioneer.SendAuctionMessage(&auctioneerrpc.ClientAuctionMessage{
Msg: msg,
})
if err != nil {
@ -1534,9 +1537,9 @@ func (s *rpcServer) sendAcceptBatch(batch *order.Batch) error {
}
// Send the message to the server.
return s.auctioneer.SendAuctionMessage(&poolrpc.ClientAuctionMessage{
Msg: &poolrpc.ClientAuctionMessage_Accept{
Accept: &poolrpc.OrderMatchAccept{
return s.auctioneer.SendAuctionMessage(&auctioneerrpc.ClientAuctionMessage{
Msg: &auctioneerrpc.ClientAuctionMessage_Accept{
Accept: &auctioneerrpc.OrderMatchAccept{
BatchId: batch.ID[:],
},
},
@ -1590,12 +1593,12 @@ func (s *rpcServer) sendSignBatch(batch *order.Batch, sigs order.BatchSignature,
rpcSigs[key] = sig.Serialize()
}
rpcChannelInfos := make(map[string]*poolrpc.ChannelInfo, len(chanInfos))
rpcChannelInfos := make(map[string]*auctioneerrpc.ChannelInfo, len(chanInfos))
for chanPoint, chanInfo := range chanInfos {
var channelType poolrpc.ChannelType
var channelType auctioneerrpc.ChannelType
switch chanInfo.Version {
case chanbackup.TweaklessCommitVersion:
channelType = poolrpc.ChannelType_TWEAKLESS
channelType = auctioneerrpc.ChannelType_TWEAKLESS
// The AnchorsCommitVersion was never widely deployed (at least
// in mainnet) because the lnd version that included it guarded
@ -1606,12 +1609,12 @@ func (s *rpcServer) sendSignBatch(batch *order.Batch, sigs order.BatchSignature,
case chanbackup.AnchorsCommitVersion,
chanbackup.AnchorsZeroFeeHtlcTxCommitVersion:
channelType = poolrpc.ChannelType_ANCHORS
channelType = auctioneerrpc.ChannelType_ANCHORS
default:
return fmt.Errorf("unknown channel type: %v",
chanInfo.Version)
}
rpcChannelInfos[chanPoint.String()] = &poolrpc.ChannelInfo{
rpcChannelInfos[chanPoint.String()] = &auctioneerrpc.ChannelInfo{
Type: channelType,
LocalNodeKey: chanInfo.LocalNodeKey.
SerializeCompressed(),
@ -1634,9 +1637,9 @@ func (s *rpcServer) sendSignBatch(batch *order.Batch, sigs order.BatchSignature,
rpcLog.Errorf("Unable to store order events: %v", err)
}
return s.auctioneer.SendAuctionMessage(&poolrpc.ClientAuctionMessage{
Msg: &poolrpc.ClientAuctionMessage_Sign{
Sign: &poolrpc.OrderMatchSign{
return s.auctioneer.SendAuctionMessage(&auctioneerrpc.ClientAuctionMessage{
Msg: &auctioneerrpc.ClientAuctionMessage_Sign{
Sign: &auctioneerrpc.OrderMatchSign{
BatchId: batch.ID[:],
AccountSigs: rpcSigs,
ChannelInfos: rpcChannelInfos,
@ -1658,7 +1661,7 @@ func (s *rpcServer) AuctionFee(ctx context.Context,
// TODO(roasbeef): accept the amt of order instead?
return &poolrpc.AuctionFeeResponse{
ExecutionFee: &poolrpc.ExecutionFee{
ExecutionFee: &auctioneerrpc.ExecutionFee{
BaseFee: uint64(auctionTerms.OrderExecBaseFee),
FeeRate: uint64(auctionTerms.OrderExecFeeRate),
},
@ -1748,13 +1751,14 @@ func (s *rpcServer) Leases(ctx context.Context,
// fetchNodeRatings returns an up to date set of ratings for each of the nodes
// we matched with in the passed batch.
func fetchNodeRatings(ctx context.Context, batches []*clientdb.LocalBatchSnapshot,
auctioneer *auctioneer.Client) (map[[33]byte]poolrpc.NodeTier, error) {
auctioneer *auctioneer.Client) (map[[33]byte]auctioneerrpc.NodeTier,
error) {
// As the node ratings call is batched, we'll first do a single query
// to fetch all the ratings that we'll want to populate below.
//
// TODO(roasbeef): capture rating at time of lease? also cache
nodeRatings := make(map[[33]byte]poolrpc.NodeTier)
nodeRatings := make(map[[33]byte]auctioneerrpc.NodeTier)
for _, batch := range batches {
for _, matches := range batch.MatchedOrders {
for _, match := range matches {
@ -1913,7 +1917,7 @@ func (s *rpcServer) prepareLeasesResponse(ctx context.Context,
purchased := ourOrder.Type() == order.TypeBid
nodeTier := nodeRatings[match.NodeKey]
rpcLeases = append(rpcLeases, &poolrpc.Lease{
ChannelPoint: &poolrpc.OutPoint{
ChannelPoint: &auctioneerrpc.OutPoint{
Txid: batchTxHash[:],
OutputIndex: chanOutputIdx,
},
@ -1968,7 +1972,8 @@ func (s *rpcServer) prepareLeasesResponse(ctx context.Context,
// BatchSnapshot returns information about a target batch including the
// clearing price of the batch, and the set of orders matched within the batch.
func (s *rpcServer) BatchSnapshot(ctx context.Context,
req *poolrpc.BatchSnapshotRequest) (*poolrpc.BatchSnapshotResponse, error) {
req *auctioneerrpc.BatchSnapshotRequest) (
*auctioneerrpc.BatchSnapshotResponse, error) {
// THe current version of this call just proxies the request to the
// auctioneer, as we may only have information about the batch if we
@ -1984,8 +1989,8 @@ func (s *rpcServer) BatchSnapshot(ctx context.Context,
// one call. If no start batch ID is provided, the most recent finalized batch
// is used as the starting point to go back from.
func (s *rpcServer) BatchSnapshots(ctx context.Context,
req *poolrpc.BatchSnapshotsRequest) (*poolrpc.BatchSnapshotsResponse,
error) {
req *auctioneerrpc.BatchSnapshotsRequest) (
*auctioneerrpc.BatchSnapshotsResponse, error) {
return s.auctioneer.BatchSnapshots(ctx, req)
}
@ -2004,8 +2009,8 @@ func (s *rpcServer) LeaseDurations(ctx context.Context,
map[uint32]bool, len(auctionTerms.LeaseDurationBuckets),
)
for duration, market := range auctionTerms.LeaseDurationBuckets {
const accept = poolrpc.DurationBucketState_ACCEPTING_ORDERS
const open = poolrpc.DurationBucketState_MARKET_OPEN
const accept = auctioneerrpc.DurationBucketState_ACCEPTING_ORDERS
const open = auctioneerrpc.DurationBucketState_MARKET_OPEN
legacyDurations[duration] = market == accept || market == open
}
@ -2059,27 +2064,29 @@ func (s *rpcServer) NodeRatings(ctx context.Context,
// rpcOrderStateToDBState maps the order state as received over the RPC
// protocol to the local state that we use in the database.
func rpcOrderStateToDBState(state poolrpc.OrderState) (order.State, error) {
func rpcOrderStateToDBState(state auctioneerrpc.OrderState) (order.State,
error) {
switch state {
case poolrpc.OrderState_ORDER_SUBMITTED:
case auctioneerrpc.OrderState_ORDER_SUBMITTED:
return order.StateSubmitted, nil
case poolrpc.OrderState_ORDER_CLEARED:
case auctioneerrpc.OrderState_ORDER_CLEARED:
return order.StateCleared, nil
case poolrpc.OrderState_ORDER_PARTIALLY_FILLED:
case auctioneerrpc.OrderState_ORDER_PARTIALLY_FILLED:
return order.StatePartiallyFilled, nil
case poolrpc.OrderState_ORDER_EXECUTED:
case auctioneerrpc.OrderState_ORDER_EXECUTED:
return order.StateExecuted, nil
case poolrpc.OrderState_ORDER_CANCELED:
case auctioneerrpc.OrderState_ORDER_CANCELED:
return order.StateCanceled, nil
case poolrpc.OrderState_ORDER_EXPIRED:
case auctioneerrpc.OrderState_ORDER_EXPIRED:
return order.StateExpired, nil
case poolrpc.OrderState_ORDER_FAILED:
case auctioneerrpc.OrderState_ORDER_FAILED:
return order.StateFailed, nil
default:
@ -2089,28 +2096,30 @@ func rpcOrderStateToDBState(state poolrpc.OrderState) (order.State, error) {
// DBOrderStateToRPCState maps the order state as stored in the database to the
// corresponding RPC enum type.
func DBOrderStateToRPCState(state order.State) (poolrpc.OrderState, error) {
func DBOrderStateToRPCState(state order.State) (auctioneerrpc.OrderState,
error) {
switch state {
case order.StateSubmitted:
return poolrpc.OrderState_ORDER_SUBMITTED, nil
return auctioneerrpc.OrderState_ORDER_SUBMITTED, nil
case order.StateCleared:
return poolrpc.OrderState_ORDER_CLEARED, nil
return auctioneerrpc.OrderState_ORDER_CLEARED, nil
case order.StatePartiallyFilled:
return poolrpc.OrderState_ORDER_PARTIALLY_FILLED, nil
return auctioneerrpc.OrderState_ORDER_PARTIALLY_FILLED, nil
case order.StateExecuted:
return poolrpc.OrderState_ORDER_EXECUTED, nil
return auctioneerrpc.OrderState_ORDER_EXECUTED, nil
case order.StateCanceled:
return poolrpc.OrderState_ORDER_CANCELED, nil
return auctioneerrpc.OrderState_ORDER_CANCELED, nil
case order.StateExpired:
return poolrpc.OrderState_ORDER_EXPIRED, nil
return auctioneerrpc.OrderState_ORDER_EXPIRED, nil
case order.StateFailed:
return poolrpc.OrderState_ORDER_FAILED, nil
return auctioneerrpc.OrderState_ORDER_FAILED, nil
default:
return 0, fmt.Errorf("unknown state: %v", state)
@ -2226,15 +2235,17 @@ func nodeHasTorAddrs(nodeAddrs []string) bool {
// unmarshallNodeTier maps the RPC node tier enum to the node tier used in
// memory.
func unmarshallNodeTier(nodeTier poolrpc.NodeTier) (order.NodeTier, error) {
func unmarshallNodeTier(nodeTier auctioneerrpc.NodeTier) (order.NodeTier,
error) {
switch nodeTier {
case poolrpc.NodeTier_TIER_DEFAULT:
case auctioneerrpc.NodeTier_TIER_DEFAULT:
return order.DefaultMinNodeTier, nil
case poolrpc.NodeTier_TIER_0:
case auctioneerrpc.NodeTier_TIER_0:
return order.NodeTier0, nil
case poolrpc.NodeTier_TIER_1:
case auctioneerrpc.NodeTier_TIER_1:
return order.NodeTier1, nil
default:

4
terms/terms.go
View file

@ -4,7 +4,7 @@ import (
"time"
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/pool/poolrpc"
"github.com/lightninglabs/pool/auctioneerrpc"
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
)
@ -22,7 +22,7 @@ type AuctioneerTerms struct {
// LeaseDurationBuckets lists the current set of lease durations and
// maps them to their current market state.
LeaseDurationBuckets map[uint32]poolrpc.DurationBucketState
LeaseDurationBuckets map[uint32]auctioneerrpc.DurationBucketState
// NextBatchConfTarget is the confirmation target the auctioneer will
// use to estimate the fee rate of the next batch.