SubscribeBatchAuction

Source: auctioneerrpc/auctioneer.proto

gRPC

info

This is a bidirectional-streaming RPC

rpc SubscribeBatchAuction (stream ClientAuctionMessage) returns (stream ServerAuctionMessage);

Code Samples

gRPC

Javascript

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const GRPC_HOST = 'localhost:12010'
const MACAROON_PATH = 'POOL_DIR/regtest/pool.macaroon'
const TLS_PATH = 'POOL_DIR/tls.cert'

const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};
const packageDefinition = protoLoader.loadSync('auctioneerrpc/auctioneer.proto', loaderOptions);
const poolrpc = grpc.loadPackageDefinition(packageDefinition).poolrpc;
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const tlsCert = fs.readFileSync(TLS_PATH);
const sslCreds = grpc.credentials.createSsl(tlsCert);
const macaroon = fs.readFileSync(MACAROON_PATH).toString('hex');
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let client = new poolrpc.ChannelAuctioneer(GRPC_HOST, creds);
let request = {
  commit: <AccountCommitment>,
  subscribe: <AccountSubscription>,
  accept: <OrderMatchAccept>,
  reject: <OrderMatchReject>,
  sign: <OrderMatchSign>,
  recover: <AccountRecovery>,
};
let call = client.subscribeBatchAuction({});
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
call.write(request);
// Console output:
//  {
//    "challenge": <ServerChallenge>,
//    "success": <SubscribeSuccess>,
//    "error": <SubscribeError>,
//    "prepare": <OrderMatchPrepare>,
//    "sign": <OrderMatchSignBegin>,
//    "finalize": <OrderMatchFinalize>,
//    "account": <AuctionAccount>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the auctioneerrpc/auctioneer.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import auctioneer_pb2 as poolrpc, auctioneer_pb2_grpc as auctioneerstub

GRPC_HOST = 'localhost:12010'
MACAROON_PATH = 'POOL_DIR/regtest/pool.macaroon'
TLS_PATH = 'POOL_DIR/tls.cert'

# create macaroon credentials
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
def metadata_callback(context, callback):
  callback([('macaroon', macaroon)], None)
auth_creds = grpc.metadata_call_credentials(metadata_callback)
# create SSL credentials
os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
cert = open(TLS_PATH, 'rb').read()
ssl_creds = grpc.ssl_channel_credentials(cert)
# combine macaroon and SSL credentials
combined_creds = grpc.composite_channel_credentials(ssl_creds, auth_creds)
# make the request
channel = grpc.secure_channel(GRPC_HOST, combined_creds)
stub = auctioneerstub.ChannelAuctioneerStub(channel)
# Define a generator that returns an Iterable of ClientAuctionMessage objects.
def request_generator():
    # Initialization code here.
    while True:
        # Parameters here can be set as arguments to the generator.
        request = poolrpc.ClientAuctionMessage(
            commit=<AccountCommitment>,
            subscribe=<AccountSubscription>,
            accept=<OrderMatchAccept>,
            reject=<OrderMatchReject>,
            sign=<OrderMatchSign>,
            recover=<AccountRecovery>,
        )
        yield request
        # Do things between iterations here.
request_iterable = request_generator()
for response in stub.SubscribeBatchAuction(request_iterable):
  print(response)
# {
#    "challenge": <ServerChallenge>,
#    "success": <SubscribeSuccess>,
#    "error": <SubscribeError>,
#    "prepare": <OrderMatchPrepare>,
#    "sign": <OrderMatchSignBegin>,
#    "finalize": <OrderMatchFinalize>,
#    "account": <AuctionAccount>,
# }

Shell

# There is no CLI command for this RPC

Messages

poolrpc.ClientAuctionMessage

Source: auctioneerrpc/auctioneer.proto

Field	gRPC Type	REST Type	REST Placement
commit Signal the intent to receive updates about a certain account and start by sending the commitment part of the authentication handshake. This is step 1 of the 3-way handshake.	AccountCommitment	unknown	unknown
subscribe Subscribe to update and interactive order execution events for account given and all its orders. Contains the final signature and is step 3 of the 3-way authentication handshake.	AccountSubscription	unknown	unknown
accept Accept the orders to be matched.	OrderMatchAccept	unknown	unknown
reject Reject a whole batch.	OrderMatchReject	unknown	unknown
sign The channel funding negotiations with the matched peer were successful and the inputs to spend from the accounts are now signed.	OrderMatchSign	unknown	unknown
recover The trader has lost its database and is trying to recover their accounts. This message can be sent after the successful completion of the 3-way authentication handshake where it will be established if the account exists on the auctioneer's side. This message must only be sent if the auctioneer knows of the account, otherwise it will regard it as a critical error and terminate the connection.	AccountRecovery	unknown	unknown

poolrpc.ServerAuctionMessage

Source: auctioneerrpc/auctioneer.proto

Field	gRPC Type	REST Type
challenge Step 2 of the 3-way authentication handshake. Contains the authentication challenge. Subscriptions sent by the trader must sign the message SHA256(SHA256(accountPubKey || nonce) || challenge) with their account key to prove ownership of said key.	ServerChallenge	unknown
success The trader has subscribed to account updates successfully, the 3-way authentication handshake completed normally.	SubscribeSuccess	unknown
error An error occurred during any part of the communication. The trader should inspect the error code and act accordingly.	SubscribeError	unknown
prepare The auctioneer has matched a set of orders into a batch and now instructs the traders to validate the batch and prepare for order execution. Because traders have the possibility of backing out of a batch, multiple of these messages with the SAME batch_id can be sent.	OrderMatchPrepare	unknown
sign This message is sent after all traders send back an OrderMatchAccept method. It signals that the traders should execute their local funding protocol, then send signatures for their account inputs.	OrderMatchSignBegin	unknown
finalize All traders have accepted and signed the batch and the final transaction was broadcast.	OrderMatchFinalize	unknown
account The answer to a trader's request for account recovery. This message contains all information that is needed to restore the account to working order on the trader side.	AuctionAccount	unknown

Nested Messages

poolrpc.AccountCommitment

Field	gRPC Type	REST Type
commit_hash The SHA256 hash of the trader's account key and a 32 byte random nonce. commit_hash = SHA256(accountPubKey || nonce)	bytes	unknown
batch_version The batch verification protocol version the client is using. Clients that don't use the latest version will be declined to connect and participate in an auction. The user should then be informed that a software update is required.	uint32	unknown

poolrpc.AccountDiff

Field	gRPC Type	REST Type
ending_balance The final balance of the account after the executed batch.	uint64	unknown
ending_state Depending on the amount of the final balance of the account, the remainder is either sent to a new on-chain output, extended off-chain or fully consumed by the batch and its fees.	AccountState	unknown
outpoint_index If the account was re-created on-chain then the new account's index in the transaction is set here. If the account was fully spent or the remainder was extended off-chain then no new account outpoint is created and -1 is returned here.	int32	unknown
trader_key The trader's account key this diff is referring to.	bytes	unknown
new_expiry The new account expiry height used to verify the batch. If the batch is successfully executed the account must update its expiry height to this value.	uint32	unknown
new_version The new account version used to verify the batch. If this is non-zero, it means the account was automatically upgraded to the given version during the batch execution.	uint32	unknown

poolrpc.AccountRecovery

Field	gRPC Type	REST Type
trader_key The trader's account key of the account to recover.	bytes	unknown

poolrpc.AccountSubscription

Field	gRPC Type	REST Type
trader_key The trader's account key of the account to subscribe to.	bytes	unknown
commit_nonce The random 32 byte nonce the trader used to create the commitment hash.	bytes	unknown
auth_sig The signature over the auth_hash which is the hash of the commitment and challenge. The signature is created with the trader's account key they committed to. auth_hash = SHA256(SHA256(accountPubKey || nonce) || challenge)	bytes	unknown

poolrpc.AuctionAccount

Field	gRPC Type	REST Type
value The value of the account in satoshis. Must match the amount of the account_point output.	uint64	unknown
expiry The block height at which the account should expire.	uint32	unknown
trader_key The trader's account key.	bytes	unknown
auctioneer_key The long term auctioneer's account key.	bytes	unknown
batch_key The current batch key used to create the account output.	bytes	unknown
state The current state of the account as the auctioneer sees it.	AuctionAccountState	unknown
height_hint The block height of the last change to the account's output. Can be used to scan the chain for the output's spend state more efficiently.	uint32	unknown
outpoint Transaction output of the account. Depending on the state of the account, this output might have been spent.	OutPoint	unknown
latest_tx The latest transaction of an account. This is only known by the auctioneer after the account has met its initial funding confirmation.	bytes	unknown
version The account version. Will be set to 0 for legacy (non-taproot) accounts.	uint32	unknown

poolrpc.ChannelInfo

Field	gRPC Type	REST Type
type The identifying type of the channel.	ChannelType	unknown
local_node_key The node's identifying public key.	bytes	unknown
remote_node_key The remote node's identifying public key.	bytes	unknown
local_payment_base_point The node's base public key used within the non-delayed pay-to-self output on the commitment transaction.	bytes	unknown
remote_payment_base_point RemotePaymentBasePoint is the remote node's base public key used within the non-delayed pay-to-self output on the commitment transaction.	bytes	unknown

poolrpc.ExecutionFee

Field	gRPC Type	REST Type
base_fee The base fee in satoshis charged per order, regardless of the matched size.	uint64	string
fee_rate The fee rate in parts per million.	uint64	string

poolrpc.MatchedAsk

Field	gRPC Type	REST Type
ask The ask order that was matched against.	ServerAsk	unknown
units_filled The number of units that were filled from/by this matched order.	uint32	unknown

poolrpc.MatchedBid

Field	gRPC Type	REST Type
bid The ask order that was matched against.	ServerBid	unknown
units_filled The number of units that were filled from/by this matched order.	uint32	unknown

poolrpc.MatchedMarket

Field	gRPC Type	REST Type
matched_orders Maps a user's own order_nonce to the opposite order type they were matched with. The order_nonce is a 32 byte hex encoded string because bytes is not allowed as a map key data type in protobuf.	MatchedOrdersEntry[]	unknown
clearing_price_rate The uniform clearing price rate in parts per billion that was used for this batch.	uint32	unknown

poolrpc.MatchedMarket.MatchedOrdersEntry

Field	gRPC Type	REST Type
key	string	unknown
value	MatchedOrder	unknown

poolrpc.MatchedOrder

Field	gRPC Type	REST Type
matched_bids The bids the trader's own order was matched against. This list is empty if the trader's order was a bid order itself.	MatchedBid[]	unknown
matched_asks The asks the trader's own order was matched against. This list is empty if the trader's order was an ask order itself.	MatchedAsk[]	unknown

poolrpc.NodeAddress

Field	gRPC Type	REST Type
network	string	unknown
addr	string	unknown

poolrpc.OrderMatchAccept

Field	gRPC Type	REST Type
batch_id The batch ID this acceptance message refers to. Must be set to avoid out-of- order responses from disrupting the batching process.	bytes	unknown

poolrpc.OrderMatchFinalize

Field	gRPC Type	REST Type
batch_id The unique identifier of the finalized batch.	bytes	unknown
batch_txid The final transaction ID of the published batch transaction.	bytes	unknown

poolrpc.OrderMatchPrepare

Field	gRPC Type	REST Type
matched_ordersdeprecated Deprecated, use matched_markets.	MatchedOrdersEntry[]	unknown
clearing_price_ratedeprecated Deprecated, use matched_markets.	uint32	unknown
charged_accounts A list of the user's own accounts that are being spent by the matched orders. The list contains the differences that would be applied by the server when executing the orders.	AccountDiff[]	unknown
execution_fee The fee parameters used to calculate the execution fees.	ExecutionFee	unknown
batch_transaction The batch transaction with all non-witness data.	bytes	unknown
fee_rate_sat_per_kw Fee rate of the batch transaction, expressed in satoshis per 1000 weight units (sat/kW).	uint64	unknown
fee_rebate_sat Fee rebate in satoshis, offered if another batch participant wants to pay more fees for a faster confirmation.	uint64	unknown
batch_id The 32 byte unique identifier of this batch.	bytes	unknown
batch_version The batch verification protocol version the server is using. Clients that don't support this version MUST return an `OrderMatchAccept` message with an empty list of orders so the batch can continue. The user should then be informed that a software update is required.	uint32	unknown
matched_markets Maps the distinct lease duration markets to the orders that were matched within and the discovered market clearing price.	MatchedMarketsEntry[]	unknown
batch_height_hint The earliest absolute height in the chain in which the batch transaction can be found within. This will be used by traders to base off their absolute channel lease maturity height.	uint32	unknown

poolrpc.OrderMatchPrepare.MatchedMarketsEntry

Field	gRPC Type	REST Type
key	uint32	unknown
value	MatchedMarket	unknown

poolrpc.OrderMatchPrepare.MatchedOrdersEntry

Field	gRPC Type	REST Type
key	string	unknown
value	MatchedOrder	unknown

poolrpc.OrderMatchReject

Field	gRPC Type	REST Type
batch_id The ID of the batch to reject.	bytes	unknown
reason The reason/error string for the rejection.	string	unknown
reason_code The reason as a code.	RejectReason	unknown
rejected_orders The map of order nonces the trader was matched with but doesn't accept. The map contains the other trader's order nonces and the reason for rejecting them. This can be a subset of the whole list of orders presented as matches if the trader only wants to reject some of them. This map is only considered by the auctioneer if the main reason_code is set to PARTIAL_REJECT. Otherwise it is assumed that the whole batch was faulty for some reason and that the trader rejects all orders contained. The auctioneer will only accept a certain number of these partial rejects before a trader's account is removed completely from the current batch. Abusing this functionality can also lead to a ban of the trader. The order nonces are hex encoded strings because the protobuf map doesn't allow raw bytes to be the map key type.	RejectedOrdersEntry[]	unknown

poolrpc.OrderMatchReject.RejectedOrdersEntry

Field	gRPC Type	REST Type
key	string	unknown
value	OrderReject	unknown

poolrpc.OrderMatchSign

Field	gRPC Type	REST Type
batch_id The ID of the batch that the signatures are meant for.	bytes	unknown
account_sigs A map with the signatures to spend the accounts being spent in a batch transaction. The map key corresponds to the trader's account key of the account in the batch transaction. The account key/ID has to be hex encoded into a string because protobuf doesn't allow bytes as a map key data type. For version 1 (Taproot enabled) accounts, this merely represents a partial MuSig2 signature that can be combined into a full signature by the auction server by adding its own partial signature. A set of nonces will be provided by the trader for each v1 account to allow finalizing the MuSig2 signing session.	AccountSigsEntry[]	unknown
channel_infos The information for each channel created as part of a batch that's submitted to the auctioneer to ensure they can properly enforce a channel's service lifetime. Entries are indexed by the string representation of a channel's outpoint.	ChannelInfosEntry[]	unknown
trader_nonces A set of 66-byte nonces for each version 1 (Taproot enabled) account. The nonces can be used to produce a MuSig2 partial signature to spend the account using the key spend path, which is a MuSig2 combined key of the auctioneer key and the trader key.	TraderNoncesEntry[]	unknown

poolrpc.OrderMatchSign.AccountSigsEntry

Field	gRPC Type	REST Type
key	string	unknown
value	bytes	unknown

poolrpc.OrderMatchSign.ChannelInfosEntry

Field	gRPC Type	REST Type
key	string	unknown
value	ChannelInfo	unknown

poolrpc.OrderMatchSign.TraderNoncesEntry

Field	gRPC Type	REST Type
key	string	unknown
value	bytes	unknown

poolrpc.OrderMatchSignBegin

Field	gRPC Type	REST Type
batch_id The 32 byte unique identifier of this batch.	bytes	unknown
server_nonces A set of 66-byte nonces for each version 1 (Taproot enabled) account. The nonces can be used to produce a MuSig2 partial signature to spend the account using the key spend path, which is a MuSig2 combined key of the auctioneer key and the trader key.	ServerNoncesEntry[]	unknown
prev_outputs The full list of UTXO information for each of the inputs being spent. This is required when spending one or more Taproot enabled (account version 1) outputs.	TxOut[]	unknown

poolrpc.OrderMatchSignBegin.ServerNoncesEntry

Field	gRPC Type	REST Type
key	string	unknown
value	bytes	unknown

poolrpc.OrderReject

Field	gRPC Type	REST Type
reason The reason/error string for the rejection.	string	unknown
reason_code The reason as a code.	OrderRejectReason	unknown

poolrpc.OutPoint

Field	gRPC Type	REST Type
txid Raw bytes representing the transaction id.	bytes	string
output_index The index of the output on the transaction.	uint32	integer

poolrpc.ServerAsk

Field	gRPC Type	REST Type
details The common fields shared between both ask and bid order types.	ServerOrder	unknown
lease_duration_blocks The number of blocks the liquidity provider is willing to provide the channel funds for.	uint32	unknown
version The version of the order format that is used. Will be increased once new features are added.	uint32	unknown
announcement_constraints The constraints for selling the liquidity based on channel discoverability.	ChannelAnnouncementConstraints	unknown
confirmation_constraints The constraints for selling the liquidity based on the number of blocks before considering the channel confirmed.	ChannelConfirmationConstraints	unknown

poolrpc.ServerBid

Field	gRPC Type	REST Type
details The common fields shared between both ask and bid order types.	ServerOrder	unknown
lease_duration_blocks Required number of blocks that a channel opened as a result of this bid should be kept open.	uint32	unknown
version The version of the order format that is used. Will be increased once new features are added.	uint32	unknown
min_node_tier The minimum 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.	NodeTier	unknown
self_chan_balance Give the incoming channel that results from this bid being matched an initial outbound balance by adding additional funds from the taker's account into the channel. As a simplification for the execution protocol and the channel reserve calculations the min_chan_amt must be set to the full order amount. For the inbound liquidity market the self_chan_balance can be at most the same as the order amount.	uint64	unknown
is_sidecar_channel If this bid order is meant to lease a channel for another node (which is dubbed a "sidecar channel") then this boolean needs to be set to true. The multi_sig_key, node_pub and node_addr fields of the order details must then correspond to the recipient node's details.	bool	unknown
unannounced_channel Signals if this bid is interested in an announced or unannounced channel.	bool	unknown
zero_conf_channel Signals if this bid is interested in a zero conf channel or not.	bool	unknown

poolrpc.ServerChallenge

Field	gRPC Type	REST Type
challenge The unique challenge for each stream that has to be signed with the trader's account key for each account subscription.	bytes	unknown
commit_hash The commit hash the challenge was created for.	bytes	unknown

poolrpc.ServerOrder

Field	gRPC Type	REST Type
trader_key The trader's account key of the account to use for the order.	bytes	unknown
rate_fixed Fixed order rate in parts per billion.	uint32	unknown
amt Order amount in satoshis.	uint64	unknown
min_chan_amt	uint64	unknown
order_nonce Order nonce of 32 byte length, acts as unique order identifier.	bytes	unknown
order_sig Signature of the order's digest, signed with the user's account key. The signature must be fixed-size LN wire format encoded. Version 0 includes the fields version, rate_fixed, amt, max_batch_fee_rate_sat_per_kw and lease_duration_blocks in the order digest.	bytes	unknown
multi_sig_key The multi signature key of the node creating the order, will be used for the target channel's funding TX 2-of-2 multi signature output.	bytes	unknown
node_pub The pubkey of the node creating the order.	bytes	unknown
node_addr The network addresses of the node creating the order.	NodeAddress[]	unknown
channel_type The type of the channel that should be opened.	OrderChannelType	unknown
max_batch_fee_rate_sat_per_kw Maximum fee rate the trader is willing to pay for the batch transaction, expressed in satoshis per 1000 weight units (sat/kW).	uint64	unknown
allowed_node_ids List of nodes that will be allowed to match with our order. Incompatible with the `not_allowed_node_ids` field.	bytes[]	unknown
not_allowed_node_ids List of nodes that won't be allowed to match with our order. Incompatible with the `allowed_node_ids` field.	bytes[]	unknown
auction_type Auction type where this order must be considered during the matching.	AuctionType	unknown
is_public Flag used to signal that this order can be shared in public market places.	bool	unknown

poolrpc.SubscribeError

Field	gRPC Type	REST Type
error The string representation of the subscription error.	string	unknown
error_code The error code of the subscription error.	Error	unknown
trader_key The trader's account key this error is referring to. This is not set if the error code is SERVER_SHUTDOWN as that error is only sent once per connection and not per individual subscription.	bytes	unknown
account_reservation The auctioneer's partial account information as it was stored when creating the reservation. This is only set if the error code is INCOMPLETE_ACCOUNT_RESERVATION. Only the fields value, expiry, trader_key, auctioneer_key, batch_key and height_hint will be set in that case.	AuctionAccount	unknown

poolrpc.SubscribeSuccess

Field	gRPC Type	REST Type
trader_key The trader's account key this message is referring to.	bytes	unknown

poolrpc.TxOut

Field	gRPC Type	REST Type
value The value of the transaction output in satoshis.	uint64	unknown
pk_script The public key script of the output.	bytes	unknown

Enums

poolrpc.AccountDiff.AccountState

Name	Number
OUTPUT_RECREATED	0
OUTPUT_DUST_EXTENDED_OFFCHAIN	1
OUTPUT_DUST_ADDED_TO_FEES	2
OUTPUT_FULLY_SPENT	3

poolrpc.AuctionAccountState

Name	Number
STATE_PENDING_OPEN The account's funding transaction is not yet confirmed on-chain.	0
STATE_OPEN The account is fully open and confirmed on-chain.	1
STATE_EXPIRED The account is still open but the CLTV expiry has passed and the trader can close it without the auctioneer's key. Orders for accounts in this state won't be accepted.	2
STATE_PENDING_UPDATE The account was modified by a deposit or withdrawal and is currently waiting for the modifying transaction to confirm.	3
STATE_CLOSED The account is closed. The auctioneer doesn't track whether the closing transaction is already confirmed on-chain or not.	4
STATE_PENDING_BATCH The account has recently participated in a batch and is not yet confirmed.	5
STATE_EXPIRED_PENDING_UPDATE The account has reached the expiration height while it had a pending update that hasn't yet confirmed. This allows accounts to be renewed once confirmed and expired.	6

poolrpc.AuctionType

Name	Number
AUCTION_TYPE_BTC_INBOUND_LIQUIDITY Default auction type where the bidder is paying for getting bitcoin inbound liqiudity from the asker.	0
AUCTION_TYPE_BTC_OUTBOUND_LIQUIDITY Auction type where the bidder is paying the asker to accept a channel (bitcoin outbound liquidity) from the bidder.	1

poolrpc.ChannelAnnouncementConstraints

Name	Number
ANNOUNCEMENT_NO_PREFERENCE	0
ONLY_ANNOUNCED	1
ONLY_UNANNOUNCED	2

poolrpc.ChannelConfirmationConstraints

Name	Number
CONFIRMATION_NO_PREFERENCE	0
ONLY_CONFIRMED	1
ONLY_ZEROCONF	2

poolrpc.ChannelType

Name	Number
TWEAKLESS The channel supports static to_remote keys.	0
ANCHORS The channel uses an anchor-based commitment.	1
SCRIPT_ENFORCED_LEASE The channel build upon the anchor-based commitment and requires an additional CLTV of the channel lease maturity on any commitment and HTLC outputs that pay directly to the channel initiator (the seller).	2
SIMPLE_TAPROOT A channel type that uses a Pay-to-Taproot output for the funding output.	3

poolrpc.NodeTier

Name	Number
TIER_DEFAULT The default node tier. This value will be determined at run-time by the current order version.	0
TIER_0 Tier 0, bid with this tier are opting out of the smaller "higher quality" pool of nodes to match their bids. Nodes in this tier are considered to have "no rating".	1
TIER_1 Tier 1, the "base" node tier. Nodes in this tier are shown to have a higher degree of up time and route-ability compared to the rest of the nodes in the network. This is the current default node tier when submitting bid orders.	2

poolrpc.OrderChannelType

Name	Number
ORDER_CHANNEL_TYPE_UNKNOWN Used to set defaults when a trader doesn't specify a channel type.	0
ORDER_CHANNEL_TYPE_PEER_DEPENDENT The channel type will vary per matched channel based on the features shared between its participants.	1
ORDER_CHANNEL_TYPE_SCRIPT_ENFORCED A channel type that builds upon the anchors commitment format to enforce channel lease maturities in the commitment and HTLC outputs that pay to the channel initiator/seller.	2
ORDER_CHANNEL_TYPE_SIMPLE_TAPROOT A channel type that uses a Pay-to-Taproot output for the funding output.	3

poolrpc.OrderMatchReject.RejectReason

Name	Number
UNKNOWN The reason cannot be mapped to a specific code.	0
SERVER_MISBEHAVIOR The client didn't come up with the same result as the server and is rejecting the batch because of that.	1
BATCH_VERSION_MISMATCH The client doesn't support the current batch verification version the server is using.	2
PARTIAL_REJECT The client rejects some of the orders, not the full batch. When this code is set, the rejected_orders map must be set.	3

poolrpc.OrderReject.OrderRejectReason

Name	Number
DUPLICATE_PEER The trader's client has a preference to only match orders with peers it doesn't already have channels with. The order that is rejected with this reason type comes from a peer that the trader already has channels with.	0
CHANNEL_FUNDING_FAILED The trader's client couldn't connect to the remote node of the matched order or the channel funding could not be initialized for another reason. This could also be the rejecting node's fault if their connection is not stable. Using this code can have a negative impact on the reputation score of both nodes, depending on the number of errors recorded.	1

poolrpc.SubscribeError.Error

Name	Number
UNKNOWN The error cannot be mapped to a specific code.	0
SERVER_SHUTDOWN The server is shutting down for maintenance. Traders should close the long-lived stream/connection and try to connect again after some time.	1
ACCOUNT_DOES_NOT_EXIST The account the trader tried to subscribe to does not exist in the auctioneer's database.	2
INCOMPLETE_ACCOUNT_RESERVATION The account the trader tried to subscribe to was never completed and a reservation for it is still pending.	3