walletrpc

type Account struct {

	// The name used to identify the account.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The type of addresses the account supports.
	AddressType AddressType `protobuf:"varint,2,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	// The public key backing the account that all keys are derived from
	// represented as an extended key. This will always be empty for the default
	// imported account in which single public keys are imported into.
	ExtendedPublicKey string `protobuf:"bytes,3,opt,name=extended_public_key,json=extendedPublicKey,proto3" json:"extended_public_key,omitempty"`
	// The fingerprint of the root key from which the account public key was
	// derived from. This will always be zero for the default imported account in
	// which single public keys are imported into. The bytes are in big-endian
	// order.
	MasterKeyFingerprint []byte `protobuf:"bytes,4,opt,name=master_key_fingerprint,json=masterKeyFingerprint,proto3" json:"master_key_fingerprint,omitempty"`
	// The derivation path corresponding to the account public key. This will
	// always be empty for the default imported account in which single public keys
	// are imported into.
	DerivationPath string `protobuf:"bytes,5,opt,name=derivation_path,json=derivationPath,proto3" json:"derivation_path,omitempty"`
	// The number of keys derived from the external branch of the account public
	// key. This will always be zero for the default imported account in which
	// single public keys are imported into.
	ExternalKeyCount uint32 `protobuf:"varint,6,opt,name=external_key_count,json=externalKeyCount,proto3" json:"external_key_count,omitempty"`
	// The number of keys derived from the internal branch of the account public
	// key. This will always be zero for the default imported account in which
	// single public keys are imported into.
	InternalKeyCount uint32 `protobuf:"varint,7,opt,name=internal_key_count,json=internalKeyCount,proto3" json:"internal_key_count,omitempty"`
	// Whether the wallet stores private keys for the account.
	WatchOnly bool `protobuf:"varint,8,opt,name=watch_only,json=watchOnly,proto3" json:"watch_only,omitempty"`
	// contains filtered or unexported fields
}

type AccountWithAddresses struct {

	// The name used to identify the account.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The type of addresses the account supports.
	AddressType AddressType `protobuf:"varint,2,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	// The derivation path corresponding to the account public key. This will
	// always be empty for the default imported account in which single public keys
	// are imported into.
	DerivationPath string `protobuf:"bytes,3,opt,name=derivation_path,json=derivationPath,proto3" json:"derivation_path,omitempty"`
	// List of address, its type internal/external & balance.
	// Note that the order of addresses will be random and not according to the
	// derivation index, since that information is not stored by the underlying
	// wallet.
	Addresses []*AddressProperty `protobuf:"bytes,4,rep,name=addresses,proto3" json:"addresses,omitempty"`
	// contains filtered or unexported fields
}

type AddrRequest struct {

	// The name of the account to retrieve the next address of. If empty, the
	// default wallet account is used.
	Account string `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	// The type of address to derive.
	Type AddressType `protobuf:"varint,2,opt,name=type,proto3,enum=walletrpc.AddressType" json:"type,omitempty"`
	// Whether a change address should be derived.
	Change bool `protobuf:"varint,3,opt,name=change,proto3" json:"change,omitempty"`
	// contains filtered or unexported fields
}

type AddrResponse struct {

	// The address encoded using a bech32 format.
	Addr string `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	// contains filtered or unexported fields
}

type AddressProperty struct {

	// The address encoded using the appropriate format depending on the
	// address type (base58, bech32, bech32m).
	//
	// Note that lnd's internal/custom keys for channels and other
	// functionality are derived from the same scope. Since they
	// aren't really used as addresses and will never have an
	// on-chain balance, we'll show the public key instead (only if
	// the show_custom_accounts flag is provided).
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// Denotes if the address is a change address.
	IsInternal bool `protobuf:"varint,2,opt,name=is_internal,json=isInternal,proto3" json:"is_internal,omitempty"`
	// The balance of the address.
	Balance int64 `protobuf:"varint,3,opt,name=balance,proto3" json:"balance,omitempty"`
	// contains filtered or unexported fields
}

type AddressType int32

type BumpFeeRequest struct {

	// The input we're attempting to bump the fee of.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The target number of blocks that the input should be spent within.
	TargetConf uint32 `protobuf:"varint,2,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"`
	// Deprecated, use sat_per_vbyte.
	// The fee rate, expressed in sat/vbyte, that should be used to spend the input
	// with.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	SatPerByte uint32 `protobuf:"varint,3,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"`
	// Whether this input must be force-swept. This means that it is swept even
	// if it has a negative yield.
	Force bool `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
	// The fee rate, expressed in sat/vbyte, that should be used to spend the input
	// with.
	SatPerVbyte uint64 `protobuf:"varint,5,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"`
	// contains filtered or unexported fields
}

type BumpFeeResponse struct {
	// contains filtered or unexported fields
}

type ChangeAddressType int32

type Config struct{}

type EstimateFeeRequest struct {

	// The number of confirmations to shoot for when estimating the fee.
	ConfTarget int32 `protobuf:"varint,1,opt,name=conf_target,json=confTarget,proto3" json:"conf_target,omitempty"`
	// contains filtered or unexported fields
}

type EstimateFeeResponse struct {

	// The amount of satoshis per kw that should be used in order to reach the
	// confirmation target in the request.
	SatPerKw int64 `protobuf:"varint,1,opt,name=sat_per_kw,json=satPerKw,proto3" json:"sat_per_kw,omitempty"`
	// contains filtered or unexported fields
}

type FinalizePsbtRequest struct {

	// A PSBT that should be signed and finalized. The PSBT must contain all
	// required inputs, outputs, UTXO data and partial signatures of all other
	// signers.
	FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"`
	// The name of the account to finalize the PSBT with. If empty, the default
	// wallet account is used.
	Account string `protobuf:"bytes,5,opt,name=account,proto3" json:"account,omitempty"`
	// contains filtered or unexported fields
}

type FinalizePsbtResponse struct {

	// The fully signed and finalized transaction in PSBT format.
	SignedPsbt []byte `protobuf:"bytes,1,opt,name=signed_psbt,json=signedPsbt,proto3" json:"signed_psbt,omitempty"`
	// The fully signed and finalized transaction in the raw wire format.
	RawFinalTx []byte `protobuf:"bytes,2,opt,name=raw_final_tx,json=rawFinalTx,proto3" json:"raw_final_tx,omitempty"`
	// contains filtered or unexported fields
}

type FundPsbtRequest struct {

	// Types that are assignable to Template:
	//
	//	*FundPsbtRequest_Psbt
	//	*FundPsbtRequest_Raw
	Template isFundPsbtRequest_Template `protobuf_oneof:"template"`
	// Types that are assignable to Fees:
	//
	//	*FundPsbtRequest_TargetConf
	//	*FundPsbtRequest_SatPerVbyte
	Fees isFundPsbtRequest_Fees `protobuf_oneof:"fees"`
	// The name of the account to fund the PSBT with. If empty, the default wallet
	// account is used.
	Account string `protobuf:"bytes,5,opt,name=account,proto3" json:"account,omitempty"`
	// The minimum number of confirmations each one of your outputs used for
	// the transaction must satisfy.
	MinConfs int32 `protobuf:"varint,6,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"`
	// Whether unconfirmed outputs should be used as inputs for the transaction.
	SpendUnconfirmed bool `protobuf:"varint,7,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"`
	// The address type for the change. If empty, P2WPKH addresses will be used
	// for default accounts and single imported public keys. For custom
	// accounts, no change type should be provided as the coin selection key
	// scope will always be used to generate the change address.
	ChangeType ChangeAddressType `protobuf:"varint,8,opt,name=change_type,json=changeType,proto3,enum=walletrpc.ChangeAddressType" json:"change_type,omitempty"`
	// contains filtered or unexported fields
}

type FundPsbtRequest_Psbt struct {
	// Use an existing PSBT packet as the template for the funded PSBT.
	//
	// The packet must contain at least one non-dust output. If one or more
	// inputs are specified, no coin selection is performed. In that case every
	// input must be an UTXO known to the wallet that has not been locked
	// before. The sum of all inputs must be sufficiently greater than the sum
	// of all outputs to pay a miner fee with the specified fee rate. A change
	// output is added to the PSBT if necessary.
	Psbt []byte `protobuf:"bytes,1,opt,name=psbt,proto3,oneof"`
}

type FundPsbtRequest_Raw struct {
	// Use the outputs and optional inputs from this raw template.
	Raw *TxTemplate `protobuf:"bytes,2,opt,name=raw,proto3,oneof"`
}

type FundPsbtRequest_SatPerVbyte struct {
	// The fee rate, expressed in sat/vbyte, that should be used to spend the
	// input with.
	SatPerVbyte uint64 `protobuf:"varint,4,opt,name=sat_per_vbyte,json=satPerVbyte,proto3,oneof"`
}

type FundPsbtRequest_TargetConf struct {
	// The target number of blocks that the transaction should be confirmed in.
	TargetConf uint32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3,oneof"`
}

type FundPsbtResponse struct {

	// The funded but not yet signed PSBT packet.
	FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"`
	// The index of the added change output or -1 if no change was left over.
	ChangeOutputIndex int32 `protobuf:"varint,2,opt,name=change_output_index,json=changeOutputIndex,proto3" json:"change_output_index,omitempty"`
	// The list of lock leases that were acquired for the inputs in the funded PSBT
	// packet.
	LockedUtxos []*UtxoLease `protobuf:"bytes,3,rep,name=locked_utxos,json=lockedUtxos,proto3" json:"locked_utxos,omitempty"`
	// contains filtered or unexported fields
}

type ImportAccountRequest struct {

	// A name to identify the account with.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A public key that corresponds to a wallet account represented as an extended
	// key. It must conform to a derivation path of the form
	// m/purpose'/coin_type'/account'.
	ExtendedPublicKey string `protobuf:"bytes,2,opt,name=extended_public_key,json=extendedPublicKey,proto3" json:"extended_public_key,omitempty"`
	// The fingerprint of the root key (also known as the key with derivation path
	// m/) from which the account public key was derived from. This may be required
	// by some hardware wallets for proper identification and signing. The bytes
	// must be in big-endian order.
	MasterKeyFingerprint []byte `protobuf:"bytes,3,opt,name=master_key_fingerprint,json=masterKeyFingerprint,proto3" json:"master_key_fingerprint,omitempty"`
	// An address type is only required when the extended account public key has a
	// legacy version (xpub, tpub, etc.), such that the wallet cannot detect what
	// address scheme it belongs to.
	AddressType AddressType `protobuf:"varint,4,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	// Whether a dry run should be attempted when importing the account. This
	// serves as a way to confirm whether the account is being imported correctly
	// by returning the first N addresses for the external and internal branches of
	// the account. If these addresses match as expected, then it should be safe to
	// import the account as is.
	DryRun bool `protobuf:"varint,5,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
	// contains filtered or unexported fields
}

type ImportAccountResponse struct {

	// The details of the imported account.
	Account *Account `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	// The first N addresses that belong to the external branch of the account.
	// The external branch is typically used for external non-change addresses.
	// These are only returned if a dry run was specified within the request.
	DryRunExternalAddrs []string `protobuf:"bytes,2,rep,name=dry_run_external_addrs,json=dryRunExternalAddrs,proto3" json:"dry_run_external_addrs,omitempty"`
	// The first N addresses that belong to the internal branch of the account.
	// The internal branch is typically used for change addresses. These are only
	// returned if a dry run was specified within the request.
	DryRunInternalAddrs []string `protobuf:"bytes,3,rep,name=dry_run_internal_addrs,json=dryRunInternalAddrs,proto3" json:"dry_run_internal_addrs,omitempty"`
	// contains filtered or unexported fields
}

type ImportPublicKeyRequest struct {

	// A compressed public key represented as raw bytes.
	PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// The type of address that will be generated from the public key.
	AddressType AddressType `protobuf:"varint,2,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	// contains filtered or unexported fields
}

type ImportPublicKeyResponse struct {
	// contains filtered or unexported fields
}

type ImportTapscriptRequest struct {

	// The internal public key, serialized as 32-byte x-only public key.
	InternalPublicKey []byte `protobuf:"bytes,1,opt,name=internal_public_key,json=internalPublicKey,proto3" json:"internal_public_key,omitempty"`
	// Types that are assignable to Script:
	//
	//	*ImportTapscriptRequest_FullTree
	//	*ImportTapscriptRequest_PartialReveal
	//	*ImportTapscriptRequest_RootHashOnly
	//	*ImportTapscriptRequest_FullKeyOnly
	Script isImportTapscriptRequest_Script `protobuf_oneof:"script"`
	// contains filtered or unexported fields
}

type ImportTapscriptRequest_FullKeyOnly struct {
	// Only the final, tweaked Taproot key is known and no additional
	// information about the internal key or type of tweak that was used to
	// derive it. When this is set, the wallet treats the key in
	// internal_public_key as the Taproot key directly. This can be useful for
	// tracking arbitrary Taproot outputs without the goal of ever being able
	// to spend from them through the internal wallet.
	FullKeyOnly bool `protobuf:"varint,5,opt,name=full_key_only,json=fullKeyOnly,proto3,oneof"`
}

type ImportTapscriptRequest_FullTree struct {
	// The full script tree with all individual leaves is known and the root
	// hash can be constructed from the full tree directly.
	FullTree *TapscriptFullTree `protobuf:"bytes,2,opt,name=full_tree,json=fullTree,proto3,oneof"`
}

type ImportTapscriptRequest_PartialReveal struct {
	// Only a single script leaf is known. To construct the root hash, the full
	// inclusion proof must also be provided.
	PartialReveal *TapscriptPartialReveal `protobuf:"bytes,3,opt,name=partial_reveal,json=partialReveal,proto3,oneof"`
}

type ImportTapscriptRequest_RootHashOnly struct {
	// Only the root hash of the Taproot script tree (or other form of Taproot
	// commitment) is known.
	RootHashOnly []byte `protobuf:"bytes,4,opt,name=root_hash_only,json=rootHashOnly,proto3,oneof"`
}

type ImportTapscriptResponse struct {

	// The resulting pay-to-Taproot address that represents the imported internal
	// key with the script committed to it.
	P2TrAddress string `protobuf:"bytes,1,opt,name=p2tr_address,json=p2trAddress,proto3" json:"p2tr_address,omitempty"`
	// contains filtered or unexported fields
}

type KeyReq struct {

	// Is the key finger print of the root pubkey that this request is targeting.
	// This allows the WalletKit to possibly serve out keys for multiple HD chains
	// via public derivation.
	KeyFingerPrint int32 `protobuf:"varint,1,opt,name=key_finger_print,json=keyFingerPrint,proto3" json:"key_finger_print,omitempty"`
	// The target key family to derive a key from. In other contexts, this is
	// known as the "account".
	KeyFamily int32 `protobuf:"varint,2,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"`
	// contains filtered or unexported fields
}

type LabelTransactionRequest struct {

	// The txid of the transaction to label. Note: When using gRPC, the bytes
	// must be in little-endian (reverse) order.
	Txid []byte `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`
	// The label to add to the transaction, limited to 500 characters.
	Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	// Whether to overwrite the existing label, if it is present.
	Overwrite bool `protobuf:"varint,3,opt,name=overwrite,proto3" json:"overwrite,omitempty"`
	// contains filtered or unexported fields
}

type LabelTransactionResponse struct {
	// contains filtered or unexported fields
}

type LeaseOutputRequest struct {

	// An ID of 32 random bytes that must be unique for each distinct application
	// using this RPC which will be used to bound the output lease to.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The identifying outpoint of the output being leased.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The time in seconds before the lock expires. If set to zero, the default
	// lock duration is used.
	ExpirationSeconds uint64 `protobuf:"varint,3,opt,name=expiration_seconds,json=expirationSeconds,proto3" json:"expiration_seconds,omitempty"`
	// contains filtered or unexported fields
}

type LeaseOutputResponse struct {

	// The absolute expiration of the output lease represented as a unix timestamp.
	Expiration uint64 `protobuf:"varint,1,opt,name=expiration,proto3" json:"expiration,omitempty"`
	// contains filtered or unexported fields
}

type ListAccountsRequest struct {

	// An optional filter to only return accounts matching this name.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// An optional filter to only return accounts matching this address type.
	AddressType AddressType `protobuf:"varint,2,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	// contains filtered or unexported fields
}

type ListAccountsResponse struct {
	Accounts []*Account `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty"`
	// contains filtered or unexported fields
}

type ListAddressesRequest struct {

	// An optional filter to only return addresses matching this account.
	AccountName string `protobuf:"bytes,1,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"`
	// An optional flag to return LND's custom accounts (Purpose=1017)
	// public key along with other addresses.
	ShowCustomAccounts bool `protobuf:"varint,2,opt,name=show_custom_accounts,json=showCustomAccounts,proto3" json:"show_custom_accounts,omitempty"`
	// contains filtered or unexported fields
}

type ListAddressesResponse struct {

	// A list of all the accounts and their addresses.
	AccountWithAddresses []*AccountWithAddresses `protobuf:"bytes,1,rep,name=account_with_addresses,json=accountWithAddresses,proto3" json:"account_with_addresses,omitempty"`
	// contains filtered or unexported fields
}

type ListLeasesRequest struct {
	// contains filtered or unexported fields
}

type ListLeasesResponse struct {

	// The list of currently leased utxos.
	LockedUtxos []*UtxoLease `protobuf:"bytes,1,rep,name=locked_utxos,json=lockedUtxos,proto3" json:"locked_utxos,omitempty"`
	// contains filtered or unexported fields
}

type ListSweepsRequest struct {

	// Retrieve the full sweep transaction details. If false, only the sweep txids
	// will be returned. Note that some sweeps that LND publishes will have been
	// replaced-by-fee, so will not be included in this output.
	Verbose bool `protobuf:"varint,1,opt,name=verbose,proto3" json:"verbose,omitempty"`
	// The start height to use when fetching sweeps. If not specified (0), the
	// result will start from the earliest sweep. If set to -1 the result will
	// only include unconfirmed sweeps (at the time of the call).
	StartHeight int32 `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
	// contains filtered or unexported fields
}

type ListSweepsResponse struct {

	// Types that are assignable to Sweeps:
	//
	//	*ListSweepsResponse_TransactionDetails
	//	*ListSweepsResponse_TransactionIds
	Sweeps isListSweepsResponse_Sweeps `protobuf_oneof:"sweeps"`
	// contains filtered or unexported fields
}

type ListSweepsResponse_TransactionDetails struct {
	TransactionDetails *lnrpc.TransactionDetails `protobuf:"bytes,1,opt,name=transaction_details,json=transactionDetails,proto3,oneof"`
}

type ListSweepsResponse_TransactionIDs struct {

	// Reversed, hex-encoded string representing the transaction ids of the
	// sweeps that our node has broadcast. Note that these transactions may
	// not have confirmed yet, we record sweeps on broadcast, not confirmation.
	TransactionIds []string `protobuf:"bytes,1,rep,name=transaction_ids,json=transactionIds,proto3" json:"transaction_ids,omitempty"`
	// contains filtered or unexported fields
}

type ListSweepsResponse_TransactionIds struct {
	TransactionIds *ListSweepsResponse_TransactionIDs `protobuf:"bytes,2,opt,name=transaction_ids,json=transactionIds,proto3,oneof"`
}

type ListUnspentRequest struct {

	// The minimum number of confirmations to be included.
	MinConfs int32 `protobuf:"varint,1,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"`
	// The maximum number of confirmations to be included.
	MaxConfs int32 `protobuf:"varint,2,opt,name=max_confs,json=maxConfs,proto3" json:"max_confs,omitempty"`
	// An optional filter to only include outputs belonging to an account.
	Account string `protobuf:"bytes,3,opt,name=account,proto3" json:"account,omitempty"`
	// When min_confs and max_confs are zero, setting false implicitly
	// overrides max_confs to be MaxInt32, otherwise max_confs remains
	// zero. An error is returned if the value is true and both min_confs
	// and max_confs are non-zero. (default: false)
	UnconfirmedOnly bool `protobuf:"varint,4,opt,name=unconfirmed_only,json=unconfirmedOnly,proto3" json:"unconfirmed_only,omitempty"`
	// contains filtered or unexported fields
}

type ListUnspentResponse struct {

	// A list of utxos satisfying the specified number of confirmations.
	Utxos []*lnrpc.Utxo `protobuf:"bytes,1,rep,name=utxos,proto3" json:"utxos,omitempty"`
	// contains filtered or unexported fields
}

type PendingSweep struct {

	// The outpoint of the output we're attempting to sweep.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The witness type of the output we're attempting to sweep.
	WitnessType WitnessType `protobuf:"varint,2,opt,name=witness_type,json=witnessType,proto3,enum=walletrpc.WitnessType" json:"witness_type,omitempty"`
	// The value of the output we're attempting to sweep.
	AmountSat uint32 `protobuf:"varint,3,opt,name=amount_sat,json=amountSat,proto3" json:"amount_sat,omitempty"`
	// Deprecated, use sat_per_vbyte.
	// The fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee
	// rate is only determined once a sweeping transaction for the output is
	// created, so it's possible for this to be 0 before this.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	SatPerByte uint32 `protobuf:"varint,4,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"`
	// The number of broadcast attempts we've made to sweep the output.
	BroadcastAttempts uint32 `protobuf:"varint,5,opt,name=broadcast_attempts,json=broadcastAttempts,proto3" json:"broadcast_attempts,omitempty"`
	// The next height of the chain at which we'll attempt to broadcast the
	// sweep transaction of the output.
	NextBroadcastHeight uint32 `protobuf:"varint,6,opt,name=next_broadcast_height,json=nextBroadcastHeight,proto3" json:"next_broadcast_height,omitempty"`
	// The requested confirmation target for this output.
	RequestedConfTarget uint32 `protobuf:"varint,8,opt,name=requested_conf_target,json=requestedConfTarget,proto3" json:"requested_conf_target,omitempty"`
	// Deprecated, use requested_sat_per_vbyte.
	// The requested fee rate, expressed in sat/vbyte, for this output.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	RequestedSatPerByte uint32 `protobuf:"varint,9,opt,name=requested_sat_per_byte,json=requestedSatPerByte,proto3" json:"requested_sat_per_byte,omitempty"`
	// The fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee
	// rate is only determined once a sweeping transaction for the output is
	// created, so it's possible for this to be 0 before this.
	SatPerVbyte uint64 `protobuf:"varint,10,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"`
	// The requested fee rate, expressed in sat/vbyte, for this output.
	RequestedSatPerVbyte uint64 `` /* 127-byte string literal not displayed */
	// Whether this input must be force-swept. This means that it is swept even
	// if it has a negative yield.
	Force bool `protobuf:"varint,7,opt,name=force,proto3" json:"force,omitempty"`
	// contains filtered or unexported fields
}

type PendingSweepsRequest struct {
	// contains filtered or unexported fields
}

type PendingSweepsResponse struct {

	// The set of outputs currently being swept by lnd's central batching engine.
	PendingSweeps []*PendingSweep `protobuf:"bytes,1,rep,name=pending_sweeps,json=pendingSweeps,proto3" json:"pending_sweeps,omitempty"`
	// contains filtered or unexported fields
}

type PublishResponse struct {

	// If blank, then no error occurred and the transaction was successfully
	// published. If not the empty string, then a string representation of the
	// broadcast error.
	//
	// TODO(roasbeef): map to a proper enum type
	PublishError string `protobuf:"bytes,1,opt,name=publish_error,json=publishError,proto3" json:"publish_error,omitempty"`
	// contains filtered or unexported fields
}

type ReleaseOutputRequest struct {

	// The unique ID that was used to lock the output.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The identifying outpoint of the output being released.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// contains filtered or unexported fields
}

type ReleaseOutputResponse struct {
	// contains filtered or unexported fields
}

type RequiredReserveRequest struct {

	// The number of additional channels the user would like to open.
	AdditionalPublicChannels uint32 `` /* 136-byte string literal not displayed */
	// contains filtered or unexported fields
}

type RequiredReserveResponse struct {

	// The amount of reserve required.
	RequiredReserve int64 `protobuf:"varint,1,opt,name=required_reserve,json=requiredReserve,proto3" json:"required_reserve,omitempty"`
	// contains filtered or unexported fields
}

type SendOutputsRequest struct {

	// The number of satoshis per kilo weight that should be used when crafting
	// this transaction.
	SatPerKw int64 `protobuf:"varint,1,opt,name=sat_per_kw,json=satPerKw,proto3" json:"sat_per_kw,omitempty"`
	// A slice of the outputs that should be created in the transaction produced.
	Outputs []*signrpc.TxOut `protobuf:"bytes,2,rep,name=outputs,proto3" json:"outputs,omitempty"`
	// An optional label for the transaction, limited to 500 characters.
	Label string `protobuf:"bytes,3,opt,name=label,proto3" json:"label,omitempty"`
	// The minimum number of confirmations each one of your outputs used for
	// the transaction must satisfy.
	MinConfs int32 `protobuf:"varint,4,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"`
	// Whether unconfirmed outputs should be used as inputs for the transaction.
	SpendUnconfirmed bool `protobuf:"varint,5,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"`
	// contains filtered or unexported fields
}

type SendOutputsResponse struct {

	// The serialized transaction sent out on the network.
	RawTx []byte `protobuf:"bytes,1,opt,name=raw_tx,json=rawTx,proto3" json:"raw_tx,omitempty"`
	// contains filtered or unexported fields
}

type SignMessageWithAddrRequest struct {

	// The message to be signed. When using REST, this field must be encoded as
	// base64.
	Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	// The address which will be used to look up the private key and sign the
	// corresponding message.
	Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
	// contains filtered or unexported fields
}

type SignMessageWithAddrResponse struct {

	// The compact ECDSA signature for the given message encoded in base64.
	Signature string `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	// contains filtered or unexported fields
}

type SignPsbtRequest struct {

	// The PSBT that should be signed. The PSBT must contain all required inputs,
	// outputs, UTXO data and custom fields required to identify the signing key.
	FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"`
	// contains filtered or unexported fields
}

type SignPsbtResponse struct {

	// The signed transaction in PSBT format.
	SignedPsbt []byte `protobuf:"bytes,1,opt,name=signed_psbt,json=signedPsbt,proto3" json:"signed_psbt,omitempty"`
	// The indices of signed inputs.
	SignedInputs []uint32 `protobuf:"varint,2,rep,packed,name=signed_inputs,json=signedInputs,proto3" json:"signed_inputs,omitempty"`
	// contains filtered or unexported fields
}

type TapLeaf struct {

	// The leaf version. Should be 0xc0 (192) in case of a SegWit v1 script.
	LeafVersion uint32 `protobuf:"varint,1,opt,name=leaf_version,json=leafVersion,proto3" json:"leaf_version,omitempty"`
	// The script of the tap leaf.
	Script []byte `protobuf:"bytes,2,opt,name=script,proto3" json:"script,omitempty"`
	// contains filtered or unexported fields
}

type TapscriptFullTree struct {

	// The complete, ordered list of all tap leaves of the tree.
	AllLeaves []*TapLeaf `protobuf:"bytes,1,rep,name=all_leaves,json=allLeaves,proto3" json:"all_leaves,omitempty"`
	// contains filtered or unexported fields
}

type TapscriptPartialReveal struct {

	// The tap leaf that is known and will be revealed.
	RevealedLeaf *TapLeaf `protobuf:"bytes,1,opt,name=revealed_leaf,json=revealedLeaf,proto3" json:"revealed_leaf,omitempty"`
	// The BIP-0341 serialized inclusion proof that is required to prove that
	// the revealed leaf is part of the tree. This contains 0..n blocks of 32
	// bytes. If the tree only contained a single leaf (which is the revealed
	// leaf), this can be empty.
	FullInclusionProof []byte `protobuf:"bytes,2,opt,name=full_inclusion_proof,json=fullInclusionProof,proto3" json:"full_inclusion_proof,omitempty"`
	// contains filtered or unexported fields
}

type Transaction struct {

	// The raw serialized transaction. Despite the field name, this does need to be
	// specified in raw bytes (or base64 encoded when using REST) and not in hex.
	// To not break existing software, the field can't simply be renamed.
	TxHex []byte `protobuf:"bytes,1,opt,name=tx_hex,json=txHex,proto3" json:"tx_hex,omitempty"`
	// An optional label to save with the transaction. Limited to 500 characters.
	Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	// contains filtered or unexported fields
}

type TxTemplate struct {

	// An optional list of inputs to use. Every input must be an UTXO known to the
	// wallet that has not been locked before. The sum of all inputs must be
	// sufficiently greater than the sum of all outputs to pay a miner fee with the
	// fee rate specified in the parent message.
	//
	// If no inputs are specified, coin selection will be performed instead and
	// inputs of sufficient value will be added to the resulting PSBT.
	Inputs []*lnrpc.OutPoint `protobuf:"bytes,1,rep,name=inputs,proto3" json:"inputs,omitempty"`
	// A map of all addresses and the amounts to send to in the funded PSBT.
	Outputs map[string]uint64 `` /* 156-byte string literal not displayed */
	// contains filtered or unexported fields
}

type UnimplementedWalletKitServer struct {
}

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

type UtxoLease struct {

	// A 32 byte random ID that identifies the lease.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The identifying outpoint of the output being leased.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The absolute expiration of the output lease represented as a unix timestamp.
	Expiration uint64 `protobuf:"varint,3,opt,name=expiration,proto3" json:"expiration,omitempty"`
	// The public key script of the leased output.
	PkScript []byte `protobuf:"bytes,4,opt,name=pk_script,json=pkScript,proto3" json:"pk_script,omitempty"`
	// The value of the leased output in satoshis.
	Value uint64 `protobuf:"varint,5,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type VerifyMessageWithAddrRequest struct {

	// The message to be signed. When using REST, this field must be encoded as
	// base64.
	Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	// The compact ECDSA signature to be verified over the given message
	// ecoded in base64.
	Signature string `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	// The address which will be used to look up the public key and verify the
	// the signature.
	Addr string `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"`
	// contains filtered or unexported fields
}

type VerifyMessageWithAddrResponse struct {

	// Whether the signature was valid over the given message.
	Valid bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
	// The pubkey recovered from the signature.
	Pubkey []byte `protobuf:"bytes,2,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	// contains filtered or unexported fields
}

type WalletKitClient interface {
	// ListUnspent returns a list of all utxos spendable by the wallet with a
	// number of confirmations between the specified minimum and maximum. By
	// default, all utxos are listed. To list only the unconfirmed utxos, set
	// the unconfirmed_only to true.
	ListUnspent(ctx context.Context, in *ListUnspentRequest, opts ...grpc.CallOption) (*ListUnspentResponse, error)
	// LeaseOutput locks an output to the given ID, preventing it from being
	// available for any future coin selection attempts. The absolute time of the
	// lock's expiration is returned. The expiration of the lock can be extended by
	// successive invocations of this RPC. Outputs can be unlocked before their
	// expiration through `ReleaseOutput`.
	LeaseOutput(ctx context.Context, in *LeaseOutputRequest, opts ...grpc.CallOption) (*LeaseOutputResponse, error)
	// ReleaseOutput unlocks an output, allowing it to be available for coin
	// selection if it remains unspent. The ID should match the one used to
	// originally lock the output.
	ReleaseOutput(ctx context.Context, in *ReleaseOutputRequest, opts ...grpc.CallOption) (*ReleaseOutputResponse, error)
	// ListLeases lists all currently locked utxos.
	ListLeases(ctx context.Context, in *ListLeasesRequest, opts ...grpc.CallOption) (*ListLeasesResponse, error)
	// DeriveNextKey attempts to derive the *next* key within the key family
	// (account in BIP43) specified. This method should return the next external
	// child within this branch.
	DeriveNextKey(ctx context.Context, in *KeyReq, opts ...grpc.CallOption) (*signrpc.KeyDescriptor, error)
	// DeriveKey attempts to derive an arbitrary key specified by the passed
	// KeyLocator.
	DeriveKey(ctx context.Context, in *signrpc.KeyLocator, opts ...grpc.CallOption) (*signrpc.KeyDescriptor, error)
	// NextAddr returns the next unused address within the wallet.
	NextAddr(ctx context.Context, in *AddrRequest, opts ...grpc.CallOption) (*AddrResponse, error)
	// ListAccounts retrieves all accounts belonging to the wallet by default. A
	// name and key scope filter can be provided to filter through all of the
	// wallet accounts and return only those matching.
	ListAccounts(ctx context.Context, in *ListAccountsRequest, opts ...grpc.CallOption) (*ListAccountsResponse, error)
	// RequiredReserve returns the minimum amount of satoshis that should be kept
	// in the wallet in order to fee bump anchor channels if necessary. The value
	// scales with the number of public anchor channels but is capped at a maximum.
	RequiredReserve(ctx context.Context, in *RequiredReserveRequest, opts ...grpc.CallOption) (*RequiredReserveResponse, error)
	// ListAddresses retrieves all the addresses along with their balance. An
	// account name filter can be provided to filter through all of the
	// wallet accounts and return the addresses of only those matching.
	ListAddresses(ctx context.Context, in *ListAddressesRequest, opts ...grpc.CallOption) (*ListAddressesResponse, error)
	// SignMessageWithAddr returns the compact signature (base64 encoded) created
	// with the private key of the provided address. This requires the address
	// to be solely based on a public key lock (no scripts). Obviously the internal
	// lnd wallet has to possess the private key of the address otherwise
	// an error is returned.
	//
	// This method aims to provide full compatibility with the bitcoin-core and
	// btcd implementation. Bitcoin-core's algorithm is not specified in a
	// BIP and only applicable for legacy addresses. This method enhances the
	// signing for additional address types: P2WKH, NP2WKH, P2TR.
	// For P2TR addresses this represents a special case. ECDSA is used to create
	// a compact signature which makes the public key of the signature recoverable.
	SignMessageWithAddr(ctx context.Context, in *SignMessageWithAddrRequest, opts ...grpc.CallOption) (*SignMessageWithAddrResponse, error)
	// VerifyMessageWithAddr returns the validity and the recovered public key of
	// the provided compact signature (base64 encoded). The verification is
	// twofold. First the validity of the signature itself is checked and then
	// it is verified that the recovered public key of the signature equals
	// the public key of the provided address. There is no dependence on the
	// private key of the address therefore also external addresses are allowed
	// to verify signatures.
	// Supported address types are P2PKH, P2WKH, NP2WKH, P2TR.
	//
	// This method is the counterpart of the related signing method
	// (SignMessageWithAddr) and aims to provide full compatibility to
	// bitcoin-core's implementation. Although bitcoin-core/btcd only provide
	// this functionality for legacy addresses this function enhances it to
	// the address types: P2PKH, P2WKH, NP2WKH, P2TR.
	//
	// The verification for P2TR addresses is a special case and requires the
	// ECDSA compact signature to compare the reovered public key to the internal
	// taproot key. The compact ECDSA signature format was used because there
	// are still no known compact signature schemes for schnorr signatures.
	VerifyMessageWithAddr(ctx context.Context, in *VerifyMessageWithAddrRequest, opts ...grpc.CallOption) (*VerifyMessageWithAddrResponse, error)
	// ImportAccount imports an account backed by an account extended public key.
	// The master key fingerprint denotes the fingerprint of the root key
	// corresponding to the account public key (also known as the key with
	// derivation path m/). This may be required by some hardware wallets for
	// proper identification and signing.
	//
	// The address type can usually be inferred from the key's version, but may be
	// required for certain keys to map them into the proper scope.
	//
	// For BIP-0044 keys, an address type must be specified as we intend to not
	// support importing BIP-0044 keys into the wallet using the legacy
	// pay-to-pubkey-hash (P2PKH) scheme. A nested witness address type will force
	// the standard BIP-0049 derivation scheme, while a witness address type will
	// force the standard BIP-0084 derivation scheme.
	//
	// For BIP-0049 keys, an address type must also be specified to make a
	// distinction between the standard BIP-0049 address schema (nested witness
	// pubkeys everywhere) and our own BIP-0049Plus address schema (nested pubkeys
	// externally, witness pubkeys internally).
	//
	// NOTE: Events (deposits/spends) for keys derived from an account will only be
	// detected by lnd if they happen after the import. Rescans to detect past
	// events will be supported later on.
	ImportAccount(ctx context.Context, in *ImportAccountRequest, opts ...grpc.CallOption) (*ImportAccountResponse, error)
	// ImportPublicKey imports a public key as watch-only into the wallet. The
	// public key is converted into a simple address of the given type and that
	// address script is watched on chain. For Taproot keys, this will only watch
	// the BIP-0086 style output script. Use ImportTapscript for more advanced key
	// spend or script spend outputs.
	//
	// NOTE: Events (deposits/spends) for a key will only be detected by lnd if
	// they happen after the import. Rescans to detect past events will be
	// supported later on.
	ImportPublicKey(ctx context.Context, in *ImportPublicKeyRequest, opts ...grpc.CallOption) (*ImportPublicKeyResponse, error)
	// ImportTapscript imports a Taproot script and internal key and adds the
	// resulting Taproot output key as a watch-only output script into the wallet.
	// For BIP-0086 style Taproot keys (no root hash commitment and no script spend
	// path) use ImportPublicKey.
	//
	// NOTE: Events (deposits/spends) for a key will only be detected by lnd if
	// they happen after the import. Rescans to detect past events will be
	// supported later on.
	//
	// NOTE: Taproot keys imported through this RPC currently _cannot_ be used for
	// funding PSBTs. Only tracking the balance and UTXOs is currently supported.
	ImportTapscript(ctx context.Context, in *ImportTapscriptRequest, opts ...grpc.CallOption) (*ImportTapscriptResponse, error)
	// PublishTransaction attempts to publish the passed transaction to the
	// network. Once this returns without an error, the wallet will continually
	// attempt to re-broadcast the transaction on start up, until it enters the
	// chain.
	PublishTransaction(ctx context.Context, in *Transaction, opts ...grpc.CallOption) (*PublishResponse, error)
	// SendOutputs is similar to the existing sendmany call in Bitcoind, and
	// allows the caller to create a transaction that sends to several outputs at
	// once. This is ideal when wanting to batch create a set of transactions.
	SendOutputs(ctx context.Context, in *SendOutputsRequest, opts ...grpc.CallOption) (*SendOutputsResponse, error)
	// EstimateFee attempts to query the internal fee estimator of the wallet to
	// determine the fee (in sat/kw) to attach to a transaction in order to
	// achieve the confirmation target.
	EstimateFee(ctx context.Context, in *EstimateFeeRequest, opts ...grpc.CallOption) (*EstimateFeeResponse, error)
	// PendingSweeps returns lists of on-chain outputs that lnd is currently
	// attempting to sweep within its central batching engine. Outputs with similar
	// fee rates are batched together in order to sweep them within a single
	// transaction.
	//
	// NOTE: Some of the fields within PendingSweepsRequest are not guaranteed to
	// remain supported. This is an advanced API that depends on the internals of
	// the UtxoSweeper, so things may change.
	PendingSweeps(ctx context.Context, in *PendingSweepsRequest, opts ...grpc.CallOption) (*PendingSweepsResponse, error)
	// BumpFee bumps the fee of an arbitrary input within a transaction. This RPC
	// takes a different approach than bitcoind's bumpfee command. lnd has a
	// central batching engine in which inputs with similar fee rates are batched
	// together to save on transaction fees. Due to this, we cannot rely on
	// bumping the fee on a specific transaction, since transactions can change at
	// any point with the addition of new inputs. The list of inputs that
	// currently exist within lnd's central batching engine can be retrieved
	// through the PendingSweeps RPC.
	//
	// When bumping the fee of an input that currently exists within lnd's central
	// batching engine, a higher fee transaction will be created that replaces the
	// lower fee transaction through the Replace-By-Fee (RBF) policy. If it
	//
	// This RPC also serves useful when wanting to perform a Child-Pays-For-Parent
	// (CPFP), where the child transaction pays for its parent's fee. This can be
	// done by specifying an outpoint within the low fee transaction that is under
	// the control of the wallet.
	//
	// The fee preference can be expressed either as a specific fee rate or a delta
	// of blocks in which the output should be swept on-chain within. If a fee
	// preference is not explicitly specified, then an error is returned.
	//
	// Note that this RPC currently doesn't perform any validation checks on the
	// fee preference being provided. For now, the responsibility of ensuring that
	// the new fee preference is sufficient is delegated to the user.
	BumpFee(ctx context.Context, in *BumpFeeRequest, opts ...grpc.CallOption) (*BumpFeeResponse, error)
	// ListSweeps returns a list of the sweep transactions our node has produced.
	// Note that these sweeps may not be confirmed yet, as we record sweeps on
	// broadcast, not confirmation.
	ListSweeps(ctx context.Context, in *ListSweepsRequest, opts ...grpc.CallOption) (*ListSweepsResponse, error)
	// LabelTransaction adds a label to a transaction. If the transaction already
	// has a label the call will fail unless the overwrite bool is set. This will
	// overwrite the exiting transaction label. Labels must not be empty, and
	// cannot exceed 500 characters.
	LabelTransaction(ctx context.Context, in *LabelTransactionRequest, opts ...grpc.CallOption) (*LabelTransactionResponse, error)
	// FundPsbt creates a fully populated PSBT that contains enough inputs to fund
	// the outputs specified in the template. There are two ways of specifying a
	// template: Either by passing in a PSBT with at least one output declared or
	// by passing in a raw TxTemplate message.
	//
	// If there are no inputs specified in the template, coin selection is
	// performed automatically. If the template does contain any inputs, it is
	// assumed that full coin selection happened externally and no additional
	// inputs are added. If the specified inputs aren't enough to fund the outputs
	// with the given fee rate, an error is returned.
	//
	// After either selecting or verifying the inputs, all input UTXOs are locked
	// with an internal app ID.
	//
	// NOTE: If this method returns without an error, it is the caller's
	// responsibility to either spend the locked UTXOs (by finalizing and then
	// publishing the transaction) or to unlock/release the locked UTXOs in case of
	// an error on the caller's side.
	FundPsbt(ctx context.Context, in *FundPsbtRequest, opts ...grpc.CallOption) (*FundPsbtResponse, error)
	// SignPsbt expects a partial transaction with all inputs and outputs fully
	// declared and tries to sign all unsigned inputs that have all required fields
	// (UTXO information, BIP32 derivation information, witness or sig scripts)
	// set.
	// If no error is returned, the PSBT is ready to be given to the next signer or
	// to be finalized if lnd was the last signer.
	//
	// NOTE: This RPC only signs inputs (and only those it can sign), it does not
	// perform any other tasks (such as coin selection, UTXO locking or
	// input/output/fee value validation, PSBT finalization). Any input that is
	// incomplete will be skipped.
	SignPsbt(ctx context.Context, in *SignPsbtRequest, opts ...grpc.CallOption) (*SignPsbtResponse, error)
	// FinalizePsbt expects a partial transaction with all inputs and outputs fully
	// declared and tries to sign all inputs that belong to the wallet. Lnd must be
	// the last signer of the transaction. That means, if there are any unsigned
	// non-witness inputs or inputs without UTXO information attached or inputs
	// without witness data that do not belong to lnd's wallet, this method will
	// fail. If no error is returned, the PSBT is ready to be extracted and the
	// final TX within to be broadcast.
	//
	// NOTE: This method does NOT publish the transaction once finalized. It is the
	// caller's responsibility to either publish the transaction on success or
	// unlock/release any locked UTXOs in case of an error in this method.
	FinalizePsbt(ctx context.Context, in *FinalizePsbtRequest, opts ...grpc.CallOption) (*FinalizePsbtResponse, error)
}