Merge pull request #4389 from guggero/psbt-signing
walletrpc: add new PSBT creation+signing RPCs
This commit is contained in:
Oliver Gugger
GitHub
commit
f8e3b41d10
|
|
@ -4,6 +4,9 @@ package main
|
|||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
|
|
@ -14,6 +17,20 @@ import (
|
|||
"github.com/urfave/cli"
|
||||
)
|
||||
|
||||
var (
|
||||
// psbtCommand is a wallet subcommand that is responsible for PSBT
|
||||
// operations.
|
||||
psbtCommand = cli.Command{
|
||||
Name: "psbt",
|
||||
Usage: "Interact with partially signed bitcoin transactions " +
|
||||
"(PSBTs).",
|
||||
Subcommands: []cli.Command{
|
||||
fundPsbtCommand,
|
||||
finalizePsbtCommand,
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
// walletCommands will return the set of commands to enable for walletrpc
|
||||
// builds.
|
||||
func walletCommands() []cli.Command {
|
||||
|
|
@ -29,6 +46,8 @@ func walletCommands() []cli.Command {
|
|||
bumpCloseFeeCommand,
|
||||
listSweepsCommand,
|
||||
labelTxCommand,
|
||||
releaseOutputCommand,
|
||||
psbtCommand,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
|
@ -304,9 +323,8 @@ func getWaitingCloseCommitments(client lnrpc.LightningClient,
|
|||
}
|
||||
|
||||
var listSweepsCommand = cli.Command{
|
||||
Name: "listsweeps",
|
||||
Category: "On-chain",
|
||||
Usage: "Lists all sweeps that have been published by our node.",
|
||||
Name: "listsweeps",
|
||||
Usage: "Lists all sweeps that have been published by our node.",
|
||||
Flags: []cli.Flag{
|
||||
cli.BoolFlag{
|
||||
Name: "verbose",
|
||||
|
|
@ -396,3 +414,330 @@ func labelTransaction(ctx *cli.Context) error {
|
|||
|
||||
return nil
|
||||
}
|
||||
|
||||
// fundPsbtResponse is a struct that contains JSOn annotations for nice result
|
||||
// serialization.
|
||||
type fundPsbtResponse struct {
|
||||
Psbt string `json:"psbt"`
|
||||
ChangeOutputIndex int32 `json:"change_output_index"`
|
||||
Locks []*walletrpc.UtxoLease `json:"locks"`
|
||||
}
|
||||
|
||||
var fundPsbtCommand = cli.Command{
|
||||
Name: "fund",
|
||||
Usage: "Fund a Partially Signed Bitcoin Transaction (PSBT).",
|
||||
ArgsUsage: "[--template_psbt=T | [--outputs=O [--inputs=I]]] " +
|
||||
"[--conf_target=C | --sat_per_vbyte=S]",
|
||||
Description: `
|
||||
The fund command creates a fully populated PSBT that contains enough
|
||||
inputs to fund the outputs specified in either the PSBT or the
|
||||
--outputs flag.
|
||||
|
||||
If there are no inputs specified in the template (or --inputs flag),
|
||||
coin selection is performed automatically. If inputs are specified, the
|
||||
wallet assumes that full coin selection happened externally and it will
|
||||
not add any additional inputs to the PSBT. 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.
|
||||
|
||||
The 'outputs' flag decodes addresses and the amount to send respectively
|
||||
in the following JSON format:
|
||||
|
||||
--outputs='{"ExampleAddr": NumCoinsInSatoshis, "SecondAddr": Sats}'
|
||||
|
||||
The optional 'inputs' flag decodes a JSON list of UTXO outpoints as
|
||||
returned by the listunspent command for example:
|
||||
|
||||
--inputs='["<txid1>:<output-index1>","<txid2>:<output-index2>",...]'
|
||||
`,
|
||||
Flags: []cli.Flag{
|
||||
cli.StringFlag{
|
||||
Name: "template_psbt",
|
||||
Usage: "the outputs to fund and optional inputs to " +
|
||||
"spend provided in the base64 PSBT format",
|
||||
},
|
||||
cli.StringFlag{
|
||||
Name: "outputs",
|
||||
Usage: "a JSON compatible map of destination " +
|
||||
"addresses to amounts to send, must not " +
|
||||
"include a change address as that will be " +
|
||||
"added automatically by the wallet",
|
||||
},
|
||||
cli.StringFlag{
|
||||
Name: "inputs",
|
||||
Usage: "an optional JSON compatible list of UTXO " +
|
||||
"outpoints to use as the PSBT's inputs",
|
||||
},
|
||||
cli.Uint64Flag{
|
||||
Name: "conf_target",
|
||||
Usage: "the number of blocks that the transaction " +
|
||||
"should be confirmed on-chain within",
|
||||
Value: 6,
|
||||
},
|
||||
cli.Uint64Flag{
|
||||
Name: "sat_per_vbyte",
|
||||
Usage: "a manual fee expressed in sat/vbyte that " +
|
||||
"should be used when creating the transaction",
|
||||
},
|
||||
},
|
||||
Action: actionDecorator(fundPsbt),
|
||||
}
|
||||
|
||||
func fundPsbt(ctx *cli.Context) error {
|
||||
// Display the command's help message if there aren't any flags
|
||||
// specified.
|
||||
if ctx.NumFlags() == 0 {
|
||||
return cli.ShowCommandHelp(ctx, "fund")
|
||||
}
|
||||
|
||||
req := &walletrpc.FundPsbtRequest{}
|
||||
|
||||
// Parse template flags.
|
||||
switch {
|
||||
// The PSBT flag is mutally exclusive with the outputs/inputs flags.
|
||||
case ctx.IsSet("template_psbt") &&
|
||||
(ctx.IsSet("inputs") || ctx.IsSet("outputs")):
|
||||
|
||||
return fmt.Errorf("cannot set template_psbt and inputs/" +
|
||||
"outputs flags at the same time")
|
||||
|
||||
// Use a pre-existing PSBT as the transaction template.
|
||||
case len(ctx.String("template_psbt")) > 0:
|
||||
psbtBase64 := ctx.String("template_psbt")
|
||||
psbtBytes, err := base64.StdEncoding.DecodeString(psbtBase64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
req.Template = &walletrpc.FundPsbtRequest_Psbt{
|
||||
Psbt: psbtBytes,
|
||||
}
|
||||
|
||||
// The user manually specified outputs and optional inputs in JSON
|
||||
// format.
|
||||
case len(ctx.String("outputs")) > 0:
|
||||
var (
|
||||
tpl = &walletrpc.TxTemplate{}
|
||||
amountToAddr map[string]uint64
|
||||
)
|
||||
|
||||
// Parse the address to amount map as JSON now. At least one
|
||||
// entry must be present.
|
||||
jsonMap := []byte(ctx.String("outputs"))
|
||||
if err := json.Unmarshal(jsonMap, &amountToAddr); err != nil {
|
||||
return fmt.Errorf("error parsing outputs JSON: %v",
|
||||
err)
|
||||
}
|
||||
if len(amountToAddr) == 0 {
|
||||
return fmt.Errorf("at least one output must be " +
|
||||
"specified")
|
||||
}
|
||||
tpl.Outputs = amountToAddr
|
||||
|
||||
// Inputs are optional.
|
||||
if len(ctx.String("inputs")) > 0 {
|
||||
var inputs []string
|
||||
|
||||
jsonList := []byte(ctx.String("inputs"))
|
||||
if err := json.Unmarshal(jsonList, &inputs); err != nil {
|
||||
return fmt.Errorf("error parsing inputs JSON: "+
|
||||
"%v", err)
|
||||
}
|
||||
|
||||
for idx, input := range inputs {
|
||||
op, err := NewProtoOutPoint(input)
|
||||
if err != nil {
|
||||
return fmt.Errorf("error parsing "+
|
||||
"UTXO outpoint %d: %v", idx,
|
||||
err)
|
||||
}
|
||||
tpl.Inputs = append(tpl.Inputs, op)
|
||||
}
|
||||
}
|
||||
|
||||
req.Template = &walletrpc.FundPsbtRequest_Raw{
|
||||
Raw: tpl,
|
||||
}
|
||||
|
||||
default:
|
||||
return fmt.Errorf("must specify either template_psbt or " +
|
||||
"outputs flag")
|
||||
}
|
||||
|
||||
// Parse fee flags.
|
||||
switch {
|
||||
case ctx.IsSet("conf_target") && ctx.IsSet("sat_per_vbyte"):
|
||||
return fmt.Errorf("cannot set conf_target and sat_per_vbyte " +
|
||||
"at the same time")
|
||||
|
||||
case ctx.Uint64("conf_target") > 0:
|
||||
req.Fees = &walletrpc.FundPsbtRequest_TargetConf{
|
||||
TargetConf: uint32(ctx.Uint64("conf_target")),
|
||||
}
|
||||
|
||||
case ctx.Uint64("sat_per_vbyte") > 0:
|
||||
req.Fees = &walletrpc.FundPsbtRequest_SatPerVbyte{
|
||||
SatPerVbyte: uint32(ctx.Uint64("sat_per_vbyte")),
|
||||
}
|
||||
}
|
||||
|
||||
walletClient, cleanUp := getWalletClient(ctx)
|
||||
defer cleanUp()
|
||||
|
||||
response, err := walletClient.FundPsbt(context.Background(), req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
printJSON(&fundPsbtResponse{
|
||||
Psbt: base64.StdEncoding.EncodeToString(
|
||||
response.FundedPsbt,
|
||||
),
|
||||
ChangeOutputIndex: response.ChangeOutputIndex,
|
||||
Locks: response.LockedUtxos,
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// finalizePsbtResponse is a struct that contains JSON annotations for nice
|
||||
// result serialization.
|
||||
type finalizePsbtResponse struct {
|
||||
Psbt string `json:"psbt"`
|
||||
FinalTx string `json:"final_tx"`
|
||||
}
|
||||
|
||||
var finalizePsbtCommand = cli.Command{
|
||||
Name: "finalize",
|
||||
Usage: "Finalize a Partially Signed Bitcoin Transaction (PSBT).",
|
||||
ArgsUsage: "funded_psbt",
|
||||
Description: `
|
||||
The finalize command 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.
|
||||
|
||||
This method does NOT publish the transaction after it's been finalized
|
||||
successfully.
|
||||
`,
|
||||
Flags: []cli.Flag{
|
||||
cli.StringFlag{
|
||||
Name: "funded_psbt",
|
||||
Usage: "the base64 encoded PSBT to finalize",
|
||||
},
|
||||
},
|
||||
Action: actionDecorator(finalizePsbt),
|
||||
}
|
||||
|
||||
func finalizePsbt(ctx *cli.Context) error {
|
||||
// Display the command's help message if we do not have the expected
|
||||
// number of arguments/flags.
|
||||
if ctx.NArg() != 1 && ctx.NumFlags() != 1 {
|
||||
return cli.ShowCommandHelp(ctx, "finalize")
|
||||
}
|
||||
|
||||
var (
|
||||
args = ctx.Args()
|
||||
psbtBase64 string
|
||||
)
|
||||
switch {
|
||||
case ctx.IsSet("funded_psbt"):
|
||||
psbtBase64 = ctx.String("funded_psbt")
|
||||
case args.Present():
|
||||
psbtBase64 = args.First()
|
||||
default:
|
||||
return fmt.Errorf("funded_psbt argument missing")
|
||||
}
|
||||
|
||||
psbtBytes, err := base64.StdEncoding.DecodeString(psbtBase64)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
req := &walletrpc.FinalizePsbtRequest{
|
||||
FundedPsbt: psbtBytes,
|
||||
}
|
||||
|
||||
walletClient, cleanUp := getWalletClient(ctx)
|
||||
defer cleanUp()
|
||||
|
||||
response, err := walletClient.FinalizePsbt(context.Background(), req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
printJSON(&finalizePsbtResponse{
|
||||
Psbt: base64.StdEncoding.EncodeToString(response.SignedPsbt),
|
||||
FinalTx: hex.EncodeToString(response.RawFinalTx),
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
var releaseOutputCommand = cli.Command{
|
||||
Name: "releaseoutput",
|
||||
Usage: "Release an output previously locked by lnd.",
|
||||
ArgsUsage: "outpoint",
|
||||
Description: `
|
||||
The releaseoutput command unlocks an output, allowing it to be available
|
||||
for coin selection if it remains unspent.
|
||||
|
||||
The internal lnd app lock ID is used when releasing the output.
|
||||
Therefore only UTXOs locked by the fundpsbt command can currently be
|
||||
released with this command.
|
||||
`,
|
||||
Flags: []cli.Flag{
|
||||
cli.StringFlag{
|
||||
Name: "outpoint",
|
||||
Usage: "the output to unlock",
|
||||
},
|
||||
},
|
||||
Action: actionDecorator(releaseOutput),
|
||||
}
|
||||
|
||||
func releaseOutput(ctx *cli.Context) error {
|
||||
// Display the command's help message if we do not have the expected
|
||||
// number of arguments/flags.
|
||||
if ctx.NArg() != 1 && ctx.NumFlags() != 1 {
|
||||
return cli.ShowCommandHelp(ctx, "releaseoutput")
|
||||
}
|
||||
|
||||
var (
|
||||
args = ctx.Args()
|
||||
outpointStr string
|
||||
)
|
||||
switch {
|
||||
case ctx.IsSet("outpoint"):
|
||||
outpointStr = ctx.String("outpoint")
|
||||
case args.Present():
|
||||
outpointStr = args.First()
|
||||
default:
|
||||
return fmt.Errorf("outpoint argument missing")
|
||||
}
|
||||
|
||||
outpoint, err := NewProtoOutPoint(outpointStr)
|
||||
if err != nil {
|
||||
return fmt.Errorf("error parsing outpoint: %v", err)
|
||||
}
|
||||
req := &walletrpc.ReleaseOutputRequest{
|
||||
Outpoint: outpoint,
|
||||
Id: walletrpc.LndInternalLockID[:],
|
||||
}
|
||||
|
||||
walletClient, cleanUp := getWalletClient(ctx)
|
||||
defer cleanUp()
|
||||
|
||||
response, err := walletClient.ReleaseOutput(context.Background(), req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
printRespJSON(response)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
352
docs/psbt.md
352
docs/psbt.md
|
|
@ -1,13 +1,294 @@
|
|||
# PSBT
|
||||
|
||||
This document describes various use cases around the topic of Partially Signed
|
||||
Bitcoin Transactions (PSBTs). Currently only channel funding is possible with
|
||||
PSBTs but more features are planned.
|
||||
Bitcoin Transactions (PSBTs). `lnd`'s wallet now features a full set of PSBT
|
||||
functionality, including creating, signing and funding channels with PSBTs.
|
||||
|
||||
See [BIP174](https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki) for
|
||||
a full description of the PSBT format and the different _roles_ that a
|
||||
participant in a PSBT can have.
|
||||
|
||||
## Creating/funding a PSBT
|
||||
|
||||
The first step for every transaction that is constructed using a PSBT flow is to
|
||||
select inputs (UTXOs) to fund the desired output and to add a change output that
|
||||
sends the remaining funds back to the own wallet.
|
||||
|
||||
This `wallet psbt fund` command is very similar to `bitcoind`'s
|
||||
`walletcreatefundedpsbt` command. One main difference is that you can specify a
|
||||
template PSBT in the `lncli` variant that contains the output(s) and optional
|
||||
inputs. Another difference is that for the `--outputs` flag, `lncli` expects the
|
||||
amounts to be in satoshis instead of fractions of a bitcoin.
|
||||
|
||||
### Simple example: fund PSBT that sends to address
|
||||
|
||||
Let's start with a very simple example and assume we want to send half a coin
|
||||
to the address `bcrt1qjrdns4f5zwkv29ln86plqzs092yd5fg6nsz8re`:
|
||||
|
||||
```shell script
|
||||
$ lncli wallet psbt fund --outputs='{"bcrt1qjrdns4f5zwkv29ln86plqzs092yd5fg6nsz8re":50000000}'
|
||||
|
||||
{
|
||||
"psbt": "cHNidP8BAHECAAAAAeJQY2VLRtutKgQYFUajEKpjFfl0Uyrm6x23OumDpe/4AQAAAAD/////AkxREgEAAAAAFgAUv6pTgbKHN60CZ+RQn5yOuH6c2WiA8PoCAAAAABYAFJDbOFU0E6zFF/M+g/AKDyqI2iUaAAAAAAABAOsCAAAAAAEBbxqXgEf9DlzcqqNM610s5pL1X258ra6+KJ22etb7HAcBAAAAAAAAAAACACT0AAAAAAAiACC7U1W0iJGhQ6o7CexDh5k36V6v3256xpA9/xmB2BybTFZdDQQAAAAAFgAUKp2ThzhswyM2QHlyvmMB6tQB7V0CSDBFAiEA4Md8RIZYqFdUPsgDyomlzMJL9bJ6Ho23JGTihXtEelgCIAeNXRLyt88SOuuWFVn3IodCE4U5D6DojIHesRmikF28ASEDHYFzMEAxfmfq98eSSnZtUwb1w7mAtHG65y8qiRFNnIkAAAAAAQEfVl0NBAAAAAAWABQqnZOHOGzDIzZAeXK+YwHq1AHtXQEDBAEAAAAAAAA=",
|
||||
"change_output_index": 0,
|
||||
"locks": [
|
||||
{
|
||||
"id": "ede19a92ed321a4705f8a1cccc1d4f6182545d4bb4fae08bd5937831b7e38f98",
|
||||
"outpoint": {
|
||||
"txid_bytes": "e25063654b46dbad2a04181546a310aa6315f974532ae6eb1db73ae983a5eff8",
|
||||
"txid_str": "f8efa583e93ab71debe62a5374f91563aa10a3461518042aaddb464b656350e2:1",
|
||||
"output_index": 1
|
||||
},
|
||||
"expiration": 1601553408
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
The first thing we notice in the response is that an outpoint was locked.
|
||||
That means, the UTXO that was chosen to fund the PSBT is currently locked and
|
||||
cannot be used by the internal wallet or any other RPC call. This lock will be
|
||||
released automatically either after 10 minutes (timeout) or once a transaction
|
||||
that spends the UTXO is published.
|
||||
|
||||
If we inspect the PSBT that was created, we see that the locked input was indeed
|
||||
selected, the UTXO information was attached and a change output (at index 0) was
|
||||
created as well:
|
||||
|
||||
```shell script
|
||||
$ bitcoin-cli decodepsbt cHNidP8BAHECAAAAAeJQY2VLRtutKgQYFUajEKpjFfl0Uyrm6x23OumDpe/4AQAAAAD/////AkxREgEAAAAAFgAUv6pTgbKHN60CZ+RQn5yOuH6c2WiA8PoCAAAAABYAFJDbOFU0E6zFF/M+g/AKDyqI2iUaAAAAAAABAOsCAAAAAAEBbxqXgEf9DlzcqqNM610s5pL1X258ra6+KJ22etb7HAcBAAAAAAAAAAACACT0AAAAAAAiACC7U1W0iJGhQ6o7CexDh5k36V6v3256xpA9/xmB2BybTFZdDQQAAAAAFgAUKp2ThzhswyM2QHlyvmMB6tQB7V0CSDBFAiEA4Md8RIZYqFdUPsgDyomlzMJL9bJ6Ho23JGTihXtEelgCIAeNXRLyt88SOuuWFVn3IodCE4U5D6DojIHesRmikF28ASEDHYFzMEAxfmfq98eSSnZtUwb1w7mAtHG65y8qiRFNnIkAAAAAAQEfVl0NBAAAAAAWABQqnZOHOGzDIzZAeXK+YwHq1AHtXQEDBAEAAAAAAAA=
|
||||
{
|
||||
"tx": {
|
||||
"txid": "33a316d62ddf74656967754d26ea83a3cb89e03ae44578d965156d4b71b1fce7",
|
||||
"hash": "33a316d62ddf74656967754d26ea83a3cb89e03ae44578d965156d4b71b1fce7",
|
||||
"version": 2,
|
||||
"size": 113,
|
||||
"vsize": 113,
|
||||
"weight": 452,
|
||||
"locktime": 0,
|
||||
"vin": [
|
||||
{
|
||||
"txid": "f8efa583e93ab71debe62a5374f91563aa10a3461518042aaddb464b656350e2",
|
||||
"vout": 1,
|
||||
"scriptSig": {
|
||||
"asm": "",
|
||||
"hex": ""
|
||||
},
|
||||
"sequence": 4294967295
|
||||
}
|
||||
],
|
||||
"vout": [
|
||||
{
|
||||
"value": 0.17977676,
|
||||
"n": 0,
|
||||
"scriptPubKey": {
|
||||
"asm": "0 bfaa5381b28737ad0267e4509f9c8eb87e9cd968",
|
||||
"hex": "0014bfaa5381b28737ad0267e4509f9c8eb87e9cd968",
|
||||
"reqSigs": 1,
|
||||
"type": "witness_v0_keyhash",
|
||||
"addresses": [
|
||||
"bcrt1qh7498qdjsum66qn8u3gfl8ywhplfektg6mutfs"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"value": 0.50000000,
|
||||
"n": 1,
|
||||
"scriptPubKey": {
|
||||
"asm": "0 90db38553413acc517f33e83f00a0f2a88da251a",
|
||||
"hex": "001490db38553413acc517f33e83f00a0f2a88da251a",
|
||||
"reqSigs": 1,
|
||||
"type": "witness_v0_keyhash",
|
||||
"addresses": [
|
||||
"bcrt1qjrdns4f5zwkv29ln86plqzs092yd5fg6nsz8re"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"unknown": {
|
||||
},
|
||||
"inputs": [
|
||||
{
|
||||
"witness_utxo": {
|
||||
...
|
||||
},
|
||||
"non_witness_utxo": {
|
||||
...
|
||||
},
|
||||
"sighash": "ALL"
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
...
|
||||
],
|
||||
"fee": 0.00007050
|
||||
}
|
||||
```
|
||||
|
||||
### Advanced example: fund PSBT with manual coin selection
|
||||
|
||||
Let's now look at how we can implement manual coin selection by using the `fund`
|
||||
command. We again want to send half a coin to
|
||||
`bcrt1qjrdns4f5zwkv29ln86plqzs092yd5fg6nsz8re` but we want to select our inputs
|
||||
manually.
|
||||
|
||||
The first step is to look at all available UTXOs and choose. To do so, we use
|
||||
the `listunspent` command:
|
||||
|
||||
```shell script
|
||||
$ lncli listunspent
|
||||
|
||||
{
|
||||
"utxos": [
|
||||
{
|
||||
"address_type": 0,
|
||||
"address": "bcrt1qmsq36rtc6ap3m0m6jryu0ez923et6kxrv46t4w",
|
||||
"amount_sat": 100000000,
|
||||
"pk_script": "0014dc011d0d78d7431dbf7a90c9c7e4455472bd58c3",
|
||||
"outpoint": "3597b451ff56bc901eb806e8c644a004e934b4c208679756b4cddc455c768c48:1",
|
||||
"confirmations": 6
|
||||
},
|
||||
{
|
||||
"address_type": 0,
|
||||
"address": "bcrt1q92we8pecdnpjxdjq09etuccpat2qrm2acu4256",
|
||||
"amount_sat": 67984726,
|
||||
"pk_script": "00142a9d9387386cc32336407972be6301ead401ed5d",
|
||||
"outpoint": "f8efa583e93ab71debe62a5374f91563aa10a3461518042aaddb464b656350e2:1",
|
||||
"confirmations": 24
|
||||
},
|
||||
...
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
Next, we choose these two inputs and create the PSBT:
|
||||
|
||||
```shell script
|
||||
$ lncli wallet psbt fund --outputs='{"bcrt1qjrdns4f5zwkv29ln86plqzs092yd5fg6nsz8re":50000000}' \
|
||||
--inputs='["3597b451ff56bc901eb806e8c644a004e934b4c208679756b4cddc455c768c48:1","f8efa583e93ab71debe62a5374f91563aa10a3461518042aaddb464b656350e2:1"]'
|
||||
|
||||
{
|
||||
"psbt": "cHNidP8BAJoCAAAAAkiMdlxF3M20VpdnCMK0NOkEoETG6Aa4HpC8Vv9RtJc1AQAAAAAAAAAA4lBjZUtG260qBBgVRqMQqmMV+XRTKubrHbc66YOl7/gBAAAAAAAAAAACgPD6AgAAAAAWABSQ2zhVNBOsxRfzPoPwCg8qiNolGtIkCAcAAAAAFgAUuvRP5r7qAvj0egDxyX9/FH+vukgAAAAAAAEA3gIAAAAAAQEr9IZcho/gV/6fH8C8P+yhNRZP+l3YuxsyatdYcS0S6AEAAAAA/v///wLI/8+yAAAAABYAFDXoRFwgXNO5VVtVq2WpaENh6blAAOH1BQAAAAAWABTcAR0NeNdDHb96kMnH5EVUcr1YwwJHMEQCIDqugtYLp4ebJAZvOdieshLi1lLuPl2tHQG4jM4ybwEGAiBeMpCkbHBmzYvljxb1JBQyVAMuoco0xIfi+5OQdHuXaAEhAnH96NhTW09X0npE983YBsHUoMPI4U4xBtHenpZVTEqpVwAAAAEBHwDh9QUAAAAAFgAU3AEdDXjXQx2/epDJx+RFVHK9WMMBAwQBAAAAAAEA6wIAAAAAAQFvGpeAR/0OXNyqo0zrXSzmkvVfbnytrr4onbZ61vscBwEAAAAAAAAAAAIAJPQAAAAAACIAILtTVbSIkaFDqjsJ7EOHmTfpXq/fbnrGkD3/GYHYHJtMVl0NBAAAAAAWABQqnZOHOGzDIzZAeXK+YwHq1AHtXQJIMEUCIQDgx3xEhlioV1Q+yAPKiaXMwkv1snoejbckZOKFe0R6WAIgB41dEvK3zxI665YVWfcih0IThTkPoOiMgd6xGaKQXbwBIQMdgXMwQDF+Z+r3x5JKdm1TBvXDuYC0cbrnLyqJEU2ciQAAAAABAR9WXQ0EAAAAABYAFCqdk4c4bMMjNkB5cr5jAerUAe1dAQMEAQAAAAAAAA==",
|
||||
"change_output_index": 1,
|
||||
"locks": [
|
||||
{
|
||||
"id": "ede19a92ed321a4705f8a1cccc1d4f6182545d4bb4fae08bd5937831b7e38f98",
|
||||
"outpoint": {
|
||||
"txid_bytes": "488c765c45dccdb456976708c2b434e904a044c6e806b81e90bc56ff51b49735",
|
||||
"txid_str": "3597b451ff56bc901eb806e8c644a004e934b4c208679756b4cddc455c768c48:1",
|
||||
"output_index": 1
|
||||
},
|
||||
"expiration": 1601560626
|
||||
},
|
||||
{
|
||||
"id": "ede19a92ed321a4705f8a1cccc1d4f6182545d4bb4fae08bd5937831b7e38f98",
|
||||
"outpoint": {
|
||||
"txid_bytes": "e25063654b46dbad2a04181546a310aa6315f974532ae6eb1db73ae983a5eff8",
|
||||
"txid_str": "f8efa583e93ab71debe62a5374f91563aa10a3461518042aaddb464b656350e2:1",
|
||||
"output_index": 1
|
||||
},
|
||||
"expiration": 1601560626
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
Inspecting this PSBT, we notice that the two inputs were chosen and a large
|
||||
change change output was added at index 1:
|
||||
|
||||
```shell script
|
||||
$ bitcoin-cli decodepsbt cHNidP8BAJoCAAAAAkiMdlxF3M20VpdnCMK0NOkEoETG6Aa4HpC8Vv9RtJc1AQAAAAAAAAAA4lBjZUtG260qBBgVRqMQqmMV+XRTKubrHbc66YOl7/gBAAAAAAAAAAACgPD6AgAAAAAWABSQ2zhVNBOsxRfzPoPwCg8qiNolGtIkCAcAAAAAFgAUuvRP5r7qAvj0egDxyX9/FH+vukgAAAAAAAEA3gIAAAAAAQEr9IZcho/gV/6fH8C8P+yhNRZP+l3YuxsyatdYcS0S6AEAAAAA/v///wLI/8+yAAAAABYAFDXoRFwgXNO5VVtVq2WpaENh6blAAOH1BQAAAAAWABTcAR0NeNdDHb96kMnH5EVUcr1YwwJHMEQCIDqugtYLp4ebJAZvOdieshLi1lLuPl2tHQG4jM4ybwEGAiBeMpCkbHBmzYvljxb1JBQyVAMuoco0xIfi+5OQdHuXaAEhAnH96NhTW09X0npE983YBsHUoMPI4U4xBtHenpZVTEqpVwAAAAEBHwDh9QUAAAAAFgAU3AEdDXjXQx2/epDJx+RFVHK9WMMBAwQBAAAAAAEA6wIAAAAAAQFvGpeAR/0OXNyqo0zrXSzmkvVfbnytrr4onbZ61vscBwEAAAAAAAAAAAIAJPQAAAAAACIAILtTVbSIkaFDqjsJ7EOHmTfpXq/fbnrGkD3/GYHYHJtMVl0NBAAAAAAWABQqnZOHOGzDIzZAeXK+YwHq1AHtXQJIMEUCIQDgx3xEhlioV1Q+yAPKiaXMwkv1snoejbckZOKFe0R6WAIgB41dEvK3zxI665YVWfcih0IThTkPoOiMgd6xGaKQXbwBIQMdgXMwQDF+Z+r3x5JKdm1TBvXDuYC0cbrnLyqJEU2ciQAAAAABAR9WXQ0EAAAAABYAFCqdk4c4bMMjNkB5cr5jAerUAe1dAQMEAQAAAAAAAA==
|
||||
|
||||
{
|
||||
"tx": {
|
||||
"txid": "e62356b99c3097eaa1241ff8e39b996917e66b13e4c0ccba3698982d746c3b76",
|
||||
"hash": "e62356b99c3097eaa1241ff8e39b996917e66b13e4c0ccba3698982d746c3b76",
|
||||
"version": 2,
|
||||
"size": 154,
|
||||
"vsize": 154,
|
||||
"weight": 616,
|
||||
"locktime": 0,
|
||||
"vin": [
|
||||
{
|
||||
"txid": "3597b451ff56bc901eb806e8c644a004e934b4c208679756b4cddc455c768c48",
|
||||
"vout": 1,
|
||||
"scriptSig": {
|
||||
"asm": "",
|
||||
"hex": ""
|
||||
},
|
||||
"sequence": 0
|
||||
},
|
||||
{
|
||||
"txid": "f8efa583e93ab71debe62a5374f91563aa10a3461518042aaddb464b656350e2",
|
||||
"vout": 1,
|
||||
"scriptSig": {
|
||||
"asm": "",
|
||||
"hex": ""
|
||||
},
|
||||
"sequence": 0
|
||||
}
|
||||
],
|
||||
"vout": [
|
||||
{
|
||||
"value": 0.50000000,
|
||||
"n": 0,
|
||||
"scriptPubKey": {
|
||||
"asm": "0 90db38553413acc517f33e83f00a0f2a88da251a",
|
||||
"hex": "001490db38553413acc517f33e83f00a0f2a88da251a",
|
||||
"reqSigs": 1,
|
||||
"type": "witness_v0_keyhash",
|
||||
"addresses": [
|
||||
"bcrt1qjrdns4f5zwkv29ln86plqzs092yd5fg6nsz8re"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"value": 1.17974226,
|
||||
"n": 1,
|
||||
"scriptPubKey": {
|
||||
"asm": "0 baf44fe6beea02f8f47a00f1c97f7f147fafba48",
|
||||
"hex": "0014baf44fe6beea02f8f47a00f1c97f7f147fafba48",
|
||||
"reqSigs": 1,
|
||||
"type": "witness_v0_keyhash",
|
||||
"addresses": [
|
||||
"bcrt1qht6yle47agp03ar6qrcujlmlz3l6lwjgjv36zl"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"unknown": {
|
||||
},
|
||||
"inputs": [
|
||||
...
|
||||
],
|
||||
"outputs": [
|
||||
...
|
||||
],
|
||||
"fee": 0.00010500
|
||||
}
|
||||
```
|
||||
|
||||
## Signing and finalizing a PSBT
|
||||
|
||||
Assuming we now want to sign the transaction that we created in the previous
|
||||
example, we simply pass it to the `finalize` sub command of the wallet:
|
||||
|
||||
```shell script
|
||||
$ lncli wallet psbt finalize cHNidP8BAJoCAAAAAkiMdlxF3M20VpdnCMK0NOkEoETG6Aa4HpC8Vv9RtJc1AQAAAAAAAAAA4lBjZUtG260qBBgVRqMQqmMV+XRTKubrHbc66YOl7/gBAAAAAAAAAAACgPD6AgAAAAAWABSQ2zhVNBOsxRfzPoPwCg8qiNolGtIkCAcAAAAAFgAUuvRP5r7qAvj0egDxyX9/FH+vukgAAAAAAAEA3gIAAAAAAQEr9IZcho/gV/6fH8C8P+yhNRZP+l3YuxsyatdYcS0S6AEAAAAA/v///wLI/8+yAAAAABYAFDXoRFwgXNO5VVtVq2WpaENh6blAAOH1BQAAAAAWABTcAR0NeNdDHb96kMnH5EVUcr1YwwJHMEQCIDqugtYLp4ebJAZvOdieshLi1lLuPl2tHQG4jM4ybwEGAiBeMpCkbHBmzYvljxb1JBQyVAMuoco0xIfi+5OQdHuXaAEhAnH96NhTW09X0npE983YBsHUoMPI4U4xBtHenpZVTEqpVwAAAAEBHwDh9QUAAAAAFgAU3AEdDXjXQx2/epDJx+RFVHK9WMMBAwQBAAAAAAEA6wIAAAAAAQFvGpeAR/0OXNyqo0zrXSzmkvVfbnytrr4onbZ61vscBwEAAAAAAAAAAAIAJPQAAAAAACIAILtTVbSIkaFDqjsJ7EOHmTfpXq/fbnrGkD3/GYHYHJtMVl0NBAAAAAAWABQqnZOHOGzDIzZAeXK+YwHq1AHtXQJIMEUCIQDgx3xEhlioV1Q+yAPKiaXMwkv1snoejbckZOKFe0R6WAIgB41dEvK3zxI665YVWfcih0IThTkPoOiMgd6xGaKQXbwBIQMdgXMwQDF+Z+r3x5JKdm1TBvXDuYC0cbrnLyqJEU2ciQAAAAABAR9WXQ0EAAAAABYAFCqdk4c4bMMjNkB5cr5jAerUAe1dAQMEAQAAAAAAAA==
|
||||
|
||||
{
|
||||
"psbt": "cHNidP8BAJoCAAAAAkiMdlxF3M20VpdnCMK0NOkEoETG6Aa4HpC8Vv9RtJc1AQAAAAAAAAAA4lBjZUtG260qBBgVRqMQqmMV+XRTKubrHbc66YOl7/gBAAAAAAAAAAACgPD6AgAAAAAWABSQ2zhVNBOsxRfzPoPwCg8qiNolGtIkCAcAAAAAFgAUuvRP5r7qAvj0egDxyX9/FH+vukgAAAAAAAEA3gIAAAAAAQEr9IZcho/gV/6fH8C8P+yhNRZP+l3YuxsyatdYcS0S6AEAAAAA/v///wLI/8+yAAAAABYAFDXoRFwgXNO5VVtVq2WpaENh6blAAOH1BQAAAAAWABTcAR0NeNdDHb96kMnH5EVUcr1YwwJHMEQCIDqugtYLp4ebJAZvOdieshLi1lLuPl2tHQG4jM4ybwEGAiBeMpCkbHBmzYvljxb1JBQyVAMuoco0xIfi+5OQdHuXaAEhAnH96NhTW09X0npE983YBsHUoMPI4U4xBtHenpZVTEqpVwAAAAEBHwDh9QUAAAAAFgAU3AEdDXjXQx2/epDJx+RFVHK9WMMBCGwCSDBFAiEAuiv52IX5wZlYJqqVGsQPfeQ/kneCNRD34v5yplNpuMYCIECHVUhjHPKSiWSsYEKD4JWGAyUwQHgDytA1whFOyLclASECg7PDfGE/uURta5/R42Vso6QKmVAgYMhjWlXENkE/x+QAAQDrAgAAAAABAW8al4BH/Q5c3KqjTOtdLOaS9V9ufK2uviidtnrW+xwHAQAAAAAAAAAAAgAk9AAAAAAAIgAgu1NVtIiRoUOqOwnsQ4eZN+ler99uesaQPf8Zgdgcm0xWXQ0EAAAAABYAFCqdk4c4bMMjNkB5cr5jAerUAe1dAkgwRQIhAODHfESGWKhXVD7IA8qJpczCS/Wyeh6NtyRk4oV7RHpYAiAHjV0S8rfPEjrrlhVZ9yKHQhOFOQ+g6IyB3rEZopBdvAEhAx2BczBAMX5n6vfHkkp2bVMG9cO5gLRxuucvKokRTZyJAAAAAAEBH1ZdDQQAAAAAFgAUKp2ThzhswyM2QHlyvmMB6tQB7V0BCGwCSDBFAiEAqK7FSrqWe2non0kl96yu2+gSXGPYPC7ZjzVZEMMWtpYCIGTzCDHZhJYGPrsnBWU8o0Eyd4nBa+6d037xGFcGUYJLASECORgkj75Xu8+DTh8bqYBIvNx1hSxV7VSJOwY6jam6LY8AAAA=",
|
||||
"final_tx": "02000000000102488c765c45dccdb456976708c2b434e904a044c6e806b81e90bc56ff51b49735010000000000000000e25063654b46dbad2a04181546a310aa6315f974532ae6eb1db73ae983a5eff80100000000000000000280f0fa020000000016001490db38553413acc517f33e83f00a0f2a88da251ad224080700000000160014baf44fe6beea02f8f47a00f1c97f7f147fafba4802483045022100ba2bf9d885f9c1995826aa951ac40f7de43f9277823510f7e2fe72a65369b8c6022040875548631cf2928964ac604283e09586032530407803cad035c2114ec8b72501210283b3c37c613fb9446d6b9fd1e3656ca3a40a99502060c8635a55c436413fc7e402483045022100a8aec54aba967b69e89f4925f7acaedbe8125c63d83c2ed98f355910c316b696022064f30831d98496063ebb2705653ca341327789c16bee9dd37ef118570651824b0121023918248fbe57bbcf834e1f1ba98048bcdc75852c55ed54893b063a8da9ba2d8f00000000"
|
||||
}
|
||||
```
|
||||
|
||||
That final transaction can now, in theory, be broadcast. But **it is very
|
||||
important** that you **do not** publish it manually if any of the involved
|
||||
outputs are used to fund a channel. See
|
||||
[the safety warning below](#safety-warning) to learn the reason for this.
|
||||
|
||||
## Opening a channel by using a PSBT
|
||||
|
||||
This is a step-by-step guide on how to open a channel with `lnd` by using a PSBT
|
||||
|
|
@ -49,7 +330,7 @@ The new `--psbt` flag in the `openchannel` command starts an interactive dialog
|
|||
between `lncli` and the user. Below the command you see an example output from
|
||||
a regtest setup. Of course all values will be different.
|
||||
|
||||
```bash
|
||||
```shell script
|
||||
$ lncli openchannel --node_key 03db1e56e5f76bc4018cf6f03d1bb98a7ae96e3f18535e929034f85e7f1ca2b8ac --local_amt 1234567 --psbt
|
||||
|
||||
Starting PSBT funding flow with pending channel ID fc7853889a04d33b8115bd79ebc99c5eea80d894a0bead40fae5a06bcbdccd3d.
|
||||
|
|
@ -71,14 +352,14 @@ The command line now waits until a PSBT is entered. We'll create one in the next
|
|||
step. Make sure to use a new shell window/tab for the next commands and leave
|
||||
the prompt from the `openchannel` running as is.
|
||||
|
||||
### 2. Use `bitcoind` to create a funding transaction
|
||||
### 2a. Use `bitcoind` to create a funding transaction
|
||||
|
||||
The output of the last command already gave us an example command to use with
|
||||
`bitcoind`. We'll go ahead and execute it now. The meaning of this command is
|
||||
something like "bitcoind, give me a PSBT that sends the given amount to the
|
||||
given address, choose any input you see fit":
|
||||
|
||||
```bash
|
||||
```shell script
|
||||
$ bitcoin-cli walletcreatefundedpsbt [] '[{"bcrt1qh33ghvgjj3ef625nl9jxz6nnrz2z9e65vsdey7w5msrklgr6rc0sv0s08q":0.01234567}]'
|
||||
|
||||
{
|
||||
|
|
@ -96,7 +377,7 @@ in fees. Fee estimation/calculation can be changed with parameters of the
|
|||
If we want to know what exactly is in this PSBT, we can look at it with the
|
||||
`decodepsbt` command:
|
||||
|
||||
```bash
|
||||
```shell script
|
||||
$ bitcoin-cli decodepsbt cHNidP8BAH0CAAAAAbxLLf9+AYfqfF69QAQuETnL6cas7GDiWBZF+3xxc/Y/AAAAAAD+////AofWEgAAAAAAIgAgvGKLsRKUcp0qk/lkYWpzGJQi51RkG5J51NwHb6B6Hh+1If0jAQAAABYAFL+6THEGhybJnOkFGSRFbtCcPOG8AAAAAAABAR8wBBAkAQAAABYAFHemJ11XF7CU7WXBIJLD/qZF+6jrAAAA
|
||||
|
||||
{
|
||||
|
|
@ -177,13 +458,41 @@ This tells us that we got a PSBT with a big input, the channel output and a
|
|||
change output for the rest. Everything is there but the signatures/witness data,
|
||||
which is exactly what we need.
|
||||
|
||||
### 2b. Use `lnd` to create a funding transaction
|
||||
|
||||
Starting with version `v0.12.0`, `lnd` can also create PSBTs. This assumes a
|
||||
scenario where one instance of `lnd` only has public keys (watch only mode) and
|
||||
a secondary, hardened and firewalled `lnd` instance has the corresponding
|
||||
private keys. On the watching only mode, the following command can be used to
|
||||
create the funding PSBT:
|
||||
|
||||
```shell script
|
||||
$ lncli wallet psbt fund --outputs='{"bcrt1qh33ghvgjj3ef625nl9jxz6nnrz2z9e65vsdey7w5msrklgr6rc0sv0s08q":1234567}'
|
||||
|
||||
{
|
||||
"psbt": "cHNidP8BAH0CAAAAAUiMdlxF3M20VpdnCMK0NOkEoETG6Aa4HpC8Vv9RtJc1AQAAAAD/////AofWEgAAAAAAIgAgvGKLsRKUcp0qk/lkYWpzGJQi51RkG5J51NwHb6B6Hh+X7OIFAAAAABYAFNigOB6EbCLRi+Evlv4r2yJx63NxAAAAAAABAN4CAAAAAAEBK/SGXIaP4Ff+nx/AvD/soTUWT/pd2LsbMmrXWHEtEugBAAAAAP7///8CyP/PsgAAAAAWABQ16ERcIFzTuVVbVatlqWhDYem5QADh9QUAAAAAFgAU3AEdDXjXQx2/epDJx+RFVHK9WMMCRzBEAiA6roLWC6eHmyQGbznYnrIS4tZS7j5drR0BuIzOMm8BBgIgXjKQpGxwZs2L5Y8W9SQUMlQDLqHKNMSH4vuTkHR7l2gBIQJx/ejYU1tPV9J6RPfN2AbB1KDDyOFOMQbR3p6WVUxKqVcAAAABAR8A4fUFAAAAABYAFNwBHQ1410Mdv3qQycfkRVRyvVjDAQMEAQAAAAAAAA==",
|
||||
"change_output_index": 1,
|
||||
"locks": [
|
||||
{
|
||||
"id": "ede19a92ed321a4705f8a1cccc1d4f6182545d4bb4fae08bd5937831b7e38f98",
|
||||
"outpoint": {
|
||||
"txid_bytes": "488c765c45dccdb456976708c2b434e904a044c6e806b81e90bc56ff51b49735",
|
||||
"txid_str": "3597b451ff56bc901eb806e8c644a004e934b4c208679756b4cddc455c768c48:1",
|
||||
"output_index": 1
|
||||
},
|
||||
"expiration": 1601562037
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### 3. Verify and sign the PSBT
|
||||
|
||||
Now that we have a valid PSBT that has everything but the final
|
||||
signatures/witness data, we can paste it into the prompt in `lncli` that is
|
||||
still waiting for our input.
|
||||
|
||||
```bash
|
||||
```shell script
|
||||
...
|
||||
Base64 encoded PSBT: cHNidP8BAH0CAAAAAbxLLf9+AYfqfF69QAQuETnL6cas7GDiWBZF+3xxc/Y/AAAAAAD+////AofWEgAAAAAAIgAgvGKLsRKUcp0qk/lkYWpzGJQi51RkG5J51NwHb6B6Hh+1If0jAQAAABYAFL+6THEGhybJnOkFGSRFbtCcPOG8AAAAAAABAR8wBBAkAQAAABYAFHemJ11XF7CU7WXBIJLD/qZF+6jrAAAA
|
||||
|
||||
|
|
@ -200,7 +509,7 @@ perhaps `bitcoind` would only know the public keys and couldn't sign for the
|
|||
transaction itself. Again, this is only an example and can't reflect all
|
||||
real-world use cases.
|
||||
|
||||
```bash
|
||||
```shell script
|
||||
$ bitcoin-cli walletprocesspsbt cHNidP8BAH0CAAAAAbxLLf9+AYfqfF69QAQuETnL6cas7GDiWBZF+3xxc/Y/AAAAAAD+////AofWEgAAAAAAIgAgvGKLsRKUcp0qk/lkYWpzGJQi51RkG5J51NwHb6B6Hh+1If0jAQAAABYAFL+6THEGhybJnOkFGSRFbtCcPOG8AAAAAAABAR8wBBAkAQAAABYAFHemJ11XF7CU7WXBIJLD/qZF+6jrAAAA
|
||||
|
||||
{
|
||||
|
|
@ -209,6 +518,19 @@ $ bitcoin-cli walletprocesspsbt cHNidP8BAH0CAAAAAbxLLf9+AYfqfF69QAQuETnL6cas7GDi
|
|||
}
|
||||
```
|
||||
|
||||
If you are using the two `lnd` node model as described in
|
||||
[2b](#2b-use-lnd-to-create-a-funding-transaction), you can achieve the same
|
||||
result with the following command:
|
||||
|
||||
```shell script
|
||||
$ lncli wallet psbt finalize cHNidP8BAH0CAAAAAUiMdlxF3M20VpdnCMK0NOkEoETG6Aa4HpC8Vv9RtJc1AQAAAAD/////AofWEgAAAAAAIgAgvGKLsRKUcp0qk/lkYWpzGJQi51RkG5J51NwHb6B6Hh+X7OIFAAAAABYAFNigOB6EbCLRi+Evlv4r2yJx63NxAAAAAAABAN4CAAAAAAEBK/SGXIaP4Ff+nx/AvD/soTUWT/pd2LsbMmrXWHEtEugBAAAAAP7///8CyP/PsgAAAAAWABQ16ERcIFzTuVVbVatlqWhDYem5QADh9QUAAAAAFgAU3AEdDXjXQx2/epDJx+RFVHK9WMMCRzBEAiA6roLWC6eHmyQGbznYnrIS4tZS7j5drR0BuIzOMm8BBgIgXjKQpGxwZs2L5Y8W9SQUMlQDLqHKNMSH4vuTkHR7l2gBIQJx/ejYU1tPV9J6RPfN2AbB1KDDyOFOMQbR3p6WVUxKqVcAAAABAR8A4fUFAAAAABYAFNwBHQ1410Mdv3qQycfkRVRyvVjDAQMEAQAAAAAAAA==
|
||||
|
||||
{
|
||||
"psbt": "cHNidP8BAH0CAAAAAUiMdlxF3M20VpdnCMK0NOkEoETG6Aa4HpC8Vv9RtJc1AQAAAAD/////AofWEgAAAAAAIgAgvGKLsRKUcp0qk/lkYWpzGJQi51RkG5J51NwHb6B6Hh+X7OIFAAAAABYAFNigOB6EbCLRi+Evlv4r2yJx63NxAAAAAAABAN4CAAAAAAEBK/SGXIaP4Ff+nx/AvD/soTUWT/pd2LsbMmrXWHEtEugBAAAAAP7///8CyP/PsgAAAAAWABQ16ERcIFzTuVVbVatlqWhDYem5QADh9QUAAAAAFgAU3AEdDXjXQx2/epDJx+RFVHK9WMMCRzBEAiA6roLWC6eHmyQGbznYnrIS4tZS7j5drR0BuIzOMm8BBgIgXjKQpGxwZs2L5Y8W9SQUMlQDLqHKNMSH4vuTkHR7l2gBIQJx/ejYU1tPV9J6RPfN2AbB1KDDyOFOMQbR3p6WVUxKqVcAAAABAR8A4fUFAAAAABYAFNwBHQ1410Mdv3qQycfkRVRyvVjDAQhrAkcwRAIgU3Ow7cLkKrg8BJe0U0n9qFLPizqEzY0JtjVlpWOEk14CID/4AFNfgwNENN2LoOs0C6uHgt4sk8rNoZG+VMGzOC/HASECg7PDfGE/uURta5/R42Vso6QKmVAgYMhjWlXENkE/x+QAAAA=",
|
||||
"final_tx": "02000000000101488c765c45dccdb456976708c2b434e904a044c6e806b81e90bc56ff51b497350100000000ffffffff0287d6120000000000220020bc628bb11294729d2a93f964616a73189422e754641b9279d4dc076fa07a1e1f97ece20500000000160014d8a0381e846c22d18be12f96fe2bdb2271eb73710247304402205373b0edc2e42ab83c0497b45349fda852cf8b3a84cd8d09b63565a56384935e02203ff800535f83034434dd8ba0eb340bab8782de2c93cacda191be54c1b3382fc701210283b3c37c613fb9446d6b9fd1e3656ca3a40a99502060c8635a55c436413fc7e400000000"
|
||||
}
|
||||
```
|
||||
|
||||
Interpreting the output, we now have a complete, final, and signed transaction
|
||||
inside the PSBT.
|
||||
|
||||
|
|
@ -220,7 +542,7 @@ LOST**!
|
|||
|
||||
Let's give it to `lncli` to continue:
|
||||
|
||||
```bash
|
||||
```shell script
|
||||
...
|
||||
Base64 encoded PSBT: cHNidP8BAH0CAAAAAbxLLf9+AYfqfF69QAQuETnL6cas7GDiWBZF+3xxc/Y/AAAAAAD+////AofWEgAAAAAAIgAgvGKLsRKUcp0qk/lkYWpzGJQi51RkG5J51NwHb6B6Hh+1If0jAQAAABYAFL+6THEGhybJnOkFGSRFbtCcPOG8AAAAAAABAR8wBBAkAQAAABYAFHemJ11XF7CU7WXBIJLD/qZF+6jrAQhrAkcwRAIgHKQbenZYvgADRd9TKGVO36NnaIgW3S12OUg8XGtSrE8CICmeaYoJ/U7Ecm+/GneY8i2hu2QCaQnuomJgzn+JAnrDASEDUBmCLcsybA5qXSRBBdZ0Uk/FQiay9NgOpv4D26yeJpAAAAA=
|
||||
{
|
||||
|
|
@ -244,18 +566,18 @@ However, the `bitcoin-cli` examples from the command line can be combined into
|
|||
a single command. For example:
|
||||
|
||||
Channel 1:
|
||||
```bash
|
||||
bitcoin-cli walletcreatefundedpsbt [] '[{"tb1qywvazres587w9wyy8uw03q8j9ek6gc9crwx4jvhqcmew4xzsvqcq3jjdja":0.01000000}]'
|
||||
```shell script
|
||||
$ bitcoin-cli walletcreatefundedpsbt [] '[{"tb1qywvazres587w9wyy8uw03q8j9ek6gc9crwx4jvhqcmew4xzsvqcq3jjdja":0.01000000}]'
|
||||
```
|
||||
|
||||
Channel 2:
|
||||
```bash
|
||||
bitcoin-cli walletcreatefundedpsbt [] '[{"tb1q53626fcwwtcdc942zaf4laqnr3vg5gv4g0hakd2h7fw2pmz6428sk3ezcx":0.01000000}]'
|
||||
```shell script
|
||||
$ bitcoin-cli walletcreatefundedpsbt [] '[{"tb1q53626fcwwtcdc942zaf4laqnr3vg5gv4g0hakd2h7fw2pmz6428sk3ezcx":0.01000000}]'
|
||||
```
|
||||
|
||||
Combined command to get batch PSBT:
|
||||
```bash
|
||||
bitcoin-cli walletcreatefundedpsbt [] '[{"tb1q53626fcwwtcdc942zaf4laqnr3vg5gv4g0hakd2h7fw2pmz6428sk3ezcx":0.01000000},{"tb1qywvazres587w9wyy8uw03q8j9ek6gc9crwx4jvhqcmew4xzsvqcq3jjdja":0.01000000}]'
|
||||
```shell script
|
||||
$ bitcoin-cli walletcreatefundedpsbt [] '[{"tb1q53626fcwwtcdc942zaf4laqnr3vg5gv4g0hakd2h7fw2pmz6428sk3ezcx":0.01000000},{"tb1qywvazres587w9wyy8uw03q8j9ek6gc9crwx4jvhqcmew4xzsvqcq3jjdja":0.01000000}]'
|
||||
```
|
||||
|
||||
### Safety warning about batch transactions
|
||||
|
|
|
|||
2
go.mod
2
go.mod
|
|
@ -9,7 +9,7 @@ require (
|
|||
github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f
|
||||
github.com/btcsuite/btcutil v1.0.2
|
||||
github.com/btcsuite/btcutil/psbt v1.0.3-0.20200826194809-5f93e33af2b0
|
||||
github.com/btcsuite/btcwallet v0.11.1-0.20200904022754-2c5947a45222
|
||||
github.com/btcsuite/btcwallet v0.11.1-0.20201002003944-e6d01202cb6b
|
||||
github.com/btcsuite/btcwallet/wallet/txauthor v1.0.0
|
||||
github.com/btcsuite/btcwallet/wallet/txrules v1.0.0
|
||||
github.com/btcsuite/btcwallet/walletdb v1.3.3
|
||||
|
|
|
|||
4
go.sum
4
go.sum
|
|
@ -37,8 +37,8 @@ github.com/btcsuite/btcutil v1.0.2 h1:9iZ1Terx9fMIOtq1VrwdqfsATL9MC2l8ZrUY6YZ2ut
|
|||
github.com/btcsuite/btcutil v1.0.2/go.mod h1:j9HUFwoQRsZL3V4n+qG+CUnEGHOarIxfC3Le2Yhbcts=
|
||||
github.com/btcsuite/btcutil/psbt v1.0.3-0.20200826194809-5f93e33af2b0 h1:3Zumkyl6PWyHuVJ04me0xeD9CnPOhNgeGpapFbzy7O4=
|
||||
github.com/btcsuite/btcutil/psbt v1.0.3-0.20200826194809-5f93e33af2b0/go.mod h1:LVveMu4VaNSkIRTZu2+ut0HDBRuYjqGocxDMNS1KuGQ=
|
||||
github.com/btcsuite/btcwallet v0.11.1-0.20200904022754-2c5947a45222 h1:rh1FQAhh+BeR29twIFDM0RLOFpDK62tsABtUkWctTXw=
|
||||
github.com/btcsuite/btcwallet v0.11.1-0.20200904022754-2c5947a45222/go.mod h1:owv9oZqM0HnUW+ByF7VqOgfs2eb0ooiePW/+Tl/i/Nk=
|
||||
github.com/btcsuite/btcwallet v0.11.1-0.20201002003944-e6d01202cb6b h1:gblgCqJNcFulA2eiQLweSbfB8H/0SgviQ0Bkx7ADLwE=
|
||||
github.com/btcsuite/btcwallet v0.11.1-0.20201002003944-e6d01202cb6b/go.mod h1:owv9oZqM0HnUW+ByF7VqOgfs2eb0ooiePW/+Tl/i/Nk=
|
||||
github.com/btcsuite/btcwallet/wallet/txauthor v1.0.0 h1:KGHMW5sd7yDdDMkCZ/JpP0KltolFsQcB973brBnfj4c=
|
||||
github.com/btcsuite/btcwallet/wallet/txauthor v1.0.0/go.mod h1:VufDts7bd/zs3GV13f/lXc/0lXrPnvxD/NvmpG/FEKU=
|
||||
github.com/btcsuite/btcwallet/wallet/txrules v1.0.0 h1:2VsfS0sBedcM5KmDzRMT3+b6xobqWveZGvjb+jFez5w=
|
||||
|
|
|
|||
|
|
@ -279,6 +279,12 @@ http:
|
|||
- selector: walletrpc.WalletKit.LabelTransaction
|
||||
post: "/v2/wallet/tx/label"
|
||||
body: "*"
|
||||
- selector: walletrpc.WalletKit.FundPsbt
|
||||
post: "/v2/wallet/psbt/fund"
|
||||
body: "*"
|
||||
- selector: walletrpc.WalletKit.FinalizePsbt
|
||||
post: "/v2/wallet/psbt/finalize"
|
||||
body: "*"
|
||||
|
||||
# watchtowerrpc/watchtower.proto
|
||||
- selector: watchtowerrpc.Watchtower.GetInfo
|
||||
|
|
|
|||
89
lnrpc/walletrpc/psbt.go
Normal file
89
lnrpc/walletrpc/psbt.go
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
// +build walletrpc
|
||||
|
||||
package walletrpc
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"time"
|
||||
|
||||
"github.com/btcsuite/btcd/wire"
|
||||
"github.com/btcsuite/btcutil/psbt"
|
||||
"github.com/btcsuite/btcwallet/wtxmgr"
|
||||
"github.com/lightningnetwork/lnd/lnwallet"
|
||||
)
|
||||
|
||||
const (
|
||||
defaultMinConf = 1
|
||||
defaultMaxConf = math.MaxInt32
|
||||
)
|
||||
|
||||
// utxoLock is a type that contains an outpoint of an UTXO and its lock lease
|
||||
// information.
|
||||
type utxoLock struct {
|
||||
lockID wtxmgr.LockID
|
||||
outpoint wire.OutPoint
|
||||
expiration time.Time
|
||||
}
|
||||
|
||||
// verifyInputsUnspent checks that all inputs are contained in the list of
|
||||
// known, non-locked UTXOs given.
|
||||
func verifyInputsUnspent(inputs []*wire.TxIn, utxos []*lnwallet.Utxo) error {
|
||||
// TODO(guggero): Pass in UTXOs as a map to make lookup more efficient.
|
||||
for idx, txIn := range inputs {
|
||||
found := false
|
||||
for _, u := range utxos {
|
||||
if u.OutPoint == txIn.PreviousOutPoint {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if !found {
|
||||
return fmt.Errorf("input %d not found in list of non-"+
|
||||
"locked UTXO", idx)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// lockInputs requests a lock lease for all inputs specified in a PSBT packet
|
||||
// by using the internal, static lock ID of lnd's wallet.
|
||||
func lockInputs(w lnwallet.WalletController, packet *psbt.Packet) ([]*utxoLock,
|
||||
error) {
|
||||
|
||||
locks := make([]*utxoLock, len(packet.UnsignedTx.TxIn))
|
||||
for idx, rawInput := range packet.UnsignedTx.TxIn {
|
||||
lock := &utxoLock{
|
||||
lockID: LndInternalLockID,
|
||||
outpoint: rawInput.PreviousOutPoint,
|
||||
}
|
||||
|
||||
expiration, err := w.LeaseOutput(lock.lockID, lock.outpoint)
|
||||
if err != nil {
|
||||
// If we run into a problem with locking one output, we
|
||||
// should try to unlock those that we successfully
|
||||
// locked so far. If that fails as well, there's not
|
||||
// much we can do.
|
||||
for i := 0; i < idx; i++ {
|
||||
op := locks[i].outpoint
|
||||
if err := w.ReleaseOutput(
|
||||
LndInternalLockID, op,
|
||||
); err != nil {
|
||||
|
||||
log.Errorf("could not release the "+
|
||||
"lock on %v: %v", op, err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("could not lease a lock on "+
|
||||
"UTXO: %v", err)
|
||||
}
|
||||
|
||||
lock.expiration = expiration
|
||||
locks[idx] = lock
|
||||
}
|
||||
|
||||
return locks, nil
|
||||
}
|
||||
|
|
@ -1368,6 +1368,400 @@ func (m *LabelTransactionResponse) XXX_DiscardUnknown() {
|
|||
|
||||
var xxx_messageInfo_LabelTransactionResponse proto.InternalMessageInfo
|
||||
|
||||
type FundPsbtRequest struct {
|
||||
// Types that are valid to be assigned to Template:
|
||||
// *FundPsbtRequest_Psbt
|
||||
// *FundPsbtRequest_Raw
|
||||
Template isFundPsbtRequest_Template `protobuf_oneof:"template"`
|
||||
// Types that are valid to be assigned to Fees:
|
||||
// *FundPsbtRequest_TargetConf
|
||||
// *FundPsbtRequest_SatPerVbyte
|
||||
Fees isFundPsbtRequest_Fees `protobuf_oneof:"fees"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *FundPsbtRequest) Reset() { *m = FundPsbtRequest{} }
|
||||
func (m *FundPsbtRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*FundPsbtRequest) ProtoMessage() {}
|
||||
func (*FundPsbtRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_6cc6942ac78249e5, []int{24}
|
||||
}
|
||||
|
||||
func (m *FundPsbtRequest) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_FundPsbtRequest.Unmarshal(m, b)
|
||||
}
|
||||
func (m *FundPsbtRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_FundPsbtRequest.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *FundPsbtRequest) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_FundPsbtRequest.Merge(m, src)
|
||||
}
|
||||
func (m *FundPsbtRequest) XXX_Size() int {
|
||||
return xxx_messageInfo_FundPsbtRequest.Size(m)
|
||||
}
|
||||
func (m *FundPsbtRequest) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_FundPsbtRequest.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_FundPsbtRequest proto.InternalMessageInfo
|
||||
|
||||
type isFundPsbtRequest_Template interface {
|
||||
isFundPsbtRequest_Template()
|
||||
}
|
||||
|
||||
type FundPsbtRequest_Psbt struct {
|
||||
Psbt []byte `protobuf:"bytes,1,opt,name=psbt,proto3,oneof"`
|
||||
}
|
||||
|
||||
type FundPsbtRequest_Raw struct {
|
||||
Raw *TxTemplate `protobuf:"bytes,2,opt,name=raw,proto3,oneof"`
|
||||
}
|
||||
|
||||
func (*FundPsbtRequest_Psbt) isFundPsbtRequest_Template() {}
|
||||
|
||||
func (*FundPsbtRequest_Raw) isFundPsbtRequest_Template() {}
|
||||
|
||||
func (m *FundPsbtRequest) GetTemplate() isFundPsbtRequest_Template {
|
||||
if m != nil {
|
||||
return m.Template
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *FundPsbtRequest) GetPsbt() []byte {
|
||||
if x, ok := m.GetTemplate().(*FundPsbtRequest_Psbt); ok {
|
||||
return x.Psbt
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *FundPsbtRequest) GetRaw() *TxTemplate {
|
||||
if x, ok := m.GetTemplate().(*FundPsbtRequest_Raw); ok {
|
||||
return x.Raw
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type isFundPsbtRequest_Fees interface {
|
||||
isFundPsbtRequest_Fees()
|
||||
}
|
||||
|
||||
type FundPsbtRequest_TargetConf struct {
|
||||
TargetConf uint32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3,oneof"`
|
||||
}
|
||||
|
||||
type FundPsbtRequest_SatPerVbyte struct {
|
||||
SatPerVbyte uint32 `protobuf:"varint,4,opt,name=sat_per_vbyte,json=satPerVbyte,proto3,oneof"`
|
||||
}
|
||||
|
||||
func (*FundPsbtRequest_TargetConf) isFundPsbtRequest_Fees() {}
|
||||
|
||||
func (*FundPsbtRequest_SatPerVbyte) isFundPsbtRequest_Fees() {}
|
||||
|
||||
func (m *FundPsbtRequest) GetFees() isFundPsbtRequest_Fees {
|
||||
if m != nil {
|
||||
return m.Fees
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *FundPsbtRequest) GetTargetConf() uint32 {
|
||||
if x, ok := m.GetFees().(*FundPsbtRequest_TargetConf); ok {
|
||||
return x.TargetConf
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *FundPsbtRequest) GetSatPerVbyte() uint32 {
|
||||
if x, ok := m.GetFees().(*FundPsbtRequest_SatPerVbyte); ok {
|
||||
return x.SatPerVbyte
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// XXX_OneofWrappers is for the internal use of the proto package.
|
||||
func (*FundPsbtRequest) XXX_OneofWrappers() []interface{} {
|
||||
return []interface{}{
|
||||
(*FundPsbtRequest_Psbt)(nil),
|
||||
(*FundPsbtRequest_Raw)(nil),
|
||||
(*FundPsbtRequest_TargetConf)(nil),
|
||||
(*FundPsbtRequest_SatPerVbyte)(nil),
|
||||
}
|
||||
}
|
||||
|
||||
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"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *FundPsbtResponse) Reset() { *m = FundPsbtResponse{} }
|
||||
func (m *FundPsbtResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*FundPsbtResponse) ProtoMessage() {}
|
||||
func (*FundPsbtResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_6cc6942ac78249e5, []int{25}
|
||||
}
|
||||
|
||||
func (m *FundPsbtResponse) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_FundPsbtResponse.Unmarshal(m, b)
|
||||
}
|
||||
func (m *FundPsbtResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_FundPsbtResponse.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *FundPsbtResponse) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_FundPsbtResponse.Merge(m, src)
|
||||
}
|
||||
func (m *FundPsbtResponse) XXX_Size() int {
|
||||
return xxx_messageInfo_FundPsbtResponse.Size(m)
|
||||
}
|
||||
func (m *FundPsbtResponse) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_FundPsbtResponse.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_FundPsbtResponse proto.InternalMessageInfo
|
||||
|
||||
func (m *FundPsbtResponse) GetFundedPsbt() []byte {
|
||||
if m != nil {
|
||||
return m.FundedPsbt
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *FundPsbtResponse) GetChangeOutputIndex() int32 {
|
||||
if m != nil {
|
||||
return m.ChangeOutputIndex
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *FundPsbtResponse) GetLockedUtxos() []*UtxoLease {
|
||||
if m != nil {
|
||||
return m.LockedUtxos
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
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 `protobuf:"bytes,2,rep,name=outputs,proto3" json:"outputs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *TxTemplate) Reset() { *m = TxTemplate{} }
|
||||
func (m *TxTemplate) String() string { return proto.CompactTextString(m) }
|
||||
func (*TxTemplate) ProtoMessage() {}
|
||||
func (*TxTemplate) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_6cc6942ac78249e5, []int{26}
|
||||
}
|
||||
|
||||
func (m *TxTemplate) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_TxTemplate.Unmarshal(m, b)
|
||||
}
|
||||
func (m *TxTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_TxTemplate.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *TxTemplate) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_TxTemplate.Merge(m, src)
|
||||
}
|
||||
func (m *TxTemplate) XXX_Size() int {
|
||||
return xxx_messageInfo_TxTemplate.Size(m)
|
||||
}
|
||||
func (m *TxTemplate) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_TxTemplate.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_TxTemplate proto.InternalMessageInfo
|
||||
|
||||
func (m *TxTemplate) GetInputs() []*lnrpc.OutPoint {
|
||||
if m != nil {
|
||||
return m.Inputs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *TxTemplate) GetOutputs() map[string]uint64 {
|
||||
if m != nil {
|
||||
return m.Outputs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
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"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *UtxoLease) Reset() { *m = UtxoLease{} }
|
||||
func (m *UtxoLease) String() string { return proto.CompactTextString(m) }
|
||||
func (*UtxoLease) ProtoMessage() {}
|
||||
func (*UtxoLease) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_6cc6942ac78249e5, []int{27}
|
||||
}
|
||||
|
||||
func (m *UtxoLease) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_UtxoLease.Unmarshal(m, b)
|
||||
}
|
||||
func (m *UtxoLease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_UtxoLease.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *UtxoLease) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_UtxoLease.Merge(m, src)
|
||||
}
|
||||
func (m *UtxoLease) XXX_Size() int {
|
||||
return xxx_messageInfo_UtxoLease.Size(m)
|
||||
}
|
||||
func (m *UtxoLease) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_UtxoLease.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_UtxoLease proto.InternalMessageInfo
|
||||
|
||||
func (m *UtxoLease) GetId() []byte {
|
||||
if m != nil {
|
||||
return m.Id
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *UtxoLease) GetOutpoint() *lnrpc.OutPoint {
|
||||
if m != nil {
|
||||
return m.Outpoint
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *UtxoLease) GetExpiration() uint64 {
|
||||
if m != nil {
|
||||
return m.Expiration
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
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"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *FinalizePsbtRequest) Reset() { *m = FinalizePsbtRequest{} }
|
||||
func (m *FinalizePsbtRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*FinalizePsbtRequest) ProtoMessage() {}
|
||||
func (*FinalizePsbtRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_6cc6942ac78249e5, []int{28}
|
||||
}
|
||||
|
||||
func (m *FinalizePsbtRequest) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_FinalizePsbtRequest.Unmarshal(m, b)
|
||||
}
|
||||
func (m *FinalizePsbtRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_FinalizePsbtRequest.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *FinalizePsbtRequest) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_FinalizePsbtRequest.Merge(m, src)
|
||||
}
|
||||
func (m *FinalizePsbtRequest) XXX_Size() int {
|
||||
return xxx_messageInfo_FinalizePsbtRequest.Size(m)
|
||||
}
|
||||
func (m *FinalizePsbtRequest) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_FinalizePsbtRequest.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_FinalizePsbtRequest proto.InternalMessageInfo
|
||||
|
||||
func (m *FinalizePsbtRequest) GetFundedPsbt() []byte {
|
||||
if m != nil {
|
||||
return m.FundedPsbt
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
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"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *FinalizePsbtResponse) Reset() { *m = FinalizePsbtResponse{} }
|
||||
func (m *FinalizePsbtResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*FinalizePsbtResponse) ProtoMessage() {}
|
||||
func (*FinalizePsbtResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_6cc6942ac78249e5, []int{29}
|
||||
}
|
||||
|
||||
func (m *FinalizePsbtResponse) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_FinalizePsbtResponse.Unmarshal(m, b)
|
||||
}
|
||||
func (m *FinalizePsbtResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_FinalizePsbtResponse.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *FinalizePsbtResponse) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_FinalizePsbtResponse.Merge(m, src)
|
||||
}
|
||||
func (m *FinalizePsbtResponse) XXX_Size() int {
|
||||
return xxx_messageInfo_FinalizePsbtResponse.Size(m)
|
||||
}
|
||||
func (m *FinalizePsbtResponse) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_FinalizePsbtResponse.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_FinalizePsbtResponse proto.InternalMessageInfo
|
||||
|
||||
func (m *FinalizePsbtResponse) GetSignedPsbt() []byte {
|
||||
if m != nil {
|
||||
return m.SignedPsbt
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *FinalizePsbtResponse) GetRawFinalTx() []byte {
|
||||
if m != nil {
|
||||
return m.RawFinalTx
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func init() {
|
||||
proto.RegisterEnum("walletrpc.WitnessType", WitnessType_name, WitnessType_value)
|
||||
proto.RegisterType((*ListUnspentRequest)(nil), "walletrpc.ListUnspentRequest")
|
||||
|
|
@ -1395,104 +1789,132 @@ func init() {
|
|||
proto.RegisterType((*ListSweepsResponse_TransactionIDs)(nil), "walletrpc.ListSweepsResponse.TransactionIDs")
|
||||
proto.RegisterType((*LabelTransactionRequest)(nil), "walletrpc.LabelTransactionRequest")
|
||||
proto.RegisterType((*LabelTransactionResponse)(nil), "walletrpc.LabelTransactionResponse")
|
||||
proto.RegisterType((*FundPsbtRequest)(nil), "walletrpc.FundPsbtRequest")
|
||||
proto.RegisterType((*FundPsbtResponse)(nil), "walletrpc.FundPsbtResponse")
|
||||
proto.RegisterType((*TxTemplate)(nil), "walletrpc.TxTemplate")
|
||||
proto.RegisterMapType((map[string]uint64)(nil), "walletrpc.TxTemplate.OutputsEntry")
|
||||
proto.RegisterType((*UtxoLease)(nil), "walletrpc.UtxoLease")
|
||||
proto.RegisterType((*FinalizePsbtRequest)(nil), "walletrpc.FinalizePsbtRequest")
|
||||
proto.RegisterType((*FinalizePsbtResponse)(nil), "walletrpc.FinalizePsbtResponse")
|
||||
}
|
||||
|
||||
func init() { proto.RegisterFile("walletrpc/walletkit.proto", fileDescriptor_6cc6942ac78249e5) }
|
||||
|
||||
var fileDescriptor_6cc6942ac78249e5 = []byte{
|
||||
// 1460 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x6f, 0x6f, 0x1a, 0x47,
|
||||
0x13, 0x8f, 0xff, 0x61, 0x98, 0x03, 0x8c, 0x17, 0x6c, 0x13, 0xe2, 0xc4, 0xce, 0x45, 0xcf, 0x53,
|
||||
0xab, 0x49, 0xb0, 0xea, 0x28, 0x55, 0x92, 0x4a, 0x55, 0x6d, 0x38, 0x0b, 0x0b, 0x0c, 0xce, 0x81,
|
||||
0x63, 0xa5, 0x7d, 0x71, 0x3a, 0xb8, 0x0d, 0x3e, 0x19, 0xee, 0x2e, 0x7b, 0x4b, 0x38, 0xde, 0xf5,
|
||||
0x53, 0x54, 0xca, 0x77, 0xe9, 0xa7, 0xe8, 0x27, 0xaa, 0x76, 0xf7, 0x38, 0xf6, 0x00, 0xa7, 0xaa,
|
||||
0xd4, 0x57, 0xbe, 0x9d, 0xdf, 0xcc, 0x6f, 0x67, 0x67, 0xc6, 0x33, 0x03, 0x3c, 0x1c, 0x9b, 0x83,
|
||||
0x01, 0xa6, 0xc4, 0xeb, 0x1d, 0x8b, 0xaf, 0x3b, 0x9b, 0x96, 0x3d, 0xe2, 0x52, 0x17, 0xa5, 0x22,
|
||||
0xa8, 0x94, 0x22, 0x5e, 0x4f, 0x48, 0x4b, 0x05, 0xdf, 0xee, 0x3b, 0x4c, 0x9d, 0xfd, 0xc5, 0x44,
|
||||
0x48, 0xd5, 0x26, 0xa0, 0x86, 0xed, 0xd3, 0x6b, 0xc7, 0xf7, 0xb0, 0x43, 0x75, 0xfc, 0x79, 0x84,
|
||||
0x7d, 0x8a, 0x1e, 0x41, 0x6a, 0x68, 0x3b, 0x46, 0xcf, 0x75, 0x3e, 0xf9, 0xc5, 0x95, 0xc3, 0x95,
|
||||
0xa3, 0x0d, 0x3d, 0x39, 0xb4, 0x9d, 0x0a, 0x3b, 0x73, 0xd0, 0x0c, 0x42, 0x70, 0x35, 0x04, 0xcd,
|
||||
0x80, 0x83, 0xea, 0x1b, 0xc8, 0xc7, 0xf8, 0x7c, 0xcf, 0x75, 0x7c, 0x8c, 0x9e, 0xc2, 0xc6, 0x88,
|
||||
0x06, 0x2e, 0x23, 0x5b, 0x3b, 0x52, 0x4e, 0x94, 0xf2, 0x80, 0xb9, 0x52, 0xbe, 0xa6, 0x81, 0xab,
|
||||
0x0b, 0x44, 0x7d, 0x0f, 0xa8, 0x81, 0x4d, 0x1f, 0xb7, 0x46, 0xd4, 0x1b, 0x45, 0x9e, 0x64, 0x61,
|
||||
0xd5, 0xb6, 0xb8, 0x0b, 0x69, 0x7d, 0xd5, 0xb6, 0xd0, 0x73, 0x48, 0xba, 0x23, 0xea, 0xb9, 0xb6,
|
||||
0x43, 0xf9, 0xdd, 0xca, 0xc9, 0x56, 0xc8, 0xd5, 0x1a, 0xd1, 0x2b, 0x26, 0xd6, 0x23, 0x05, 0xf5,
|
||||
0x35, 0xe4, 0x63, 0x94, 0xa1, 0x33, 0x4f, 0x00, 0x70, 0xe0, 0xd9, 0xc4, 0xa4, 0xb6, 0xeb, 0x70,
|
||||
0xee, 0x75, 0x5d, 0x92, 0xa8, 0x6d, 0x28, 0xe8, 0x78, 0xf0, 0x1f, 0xfb, 0xb2, 0x07, 0x3b, 0x73,
|
||||
0xa4, 0xc2, 0x1b, 0xf5, 0x3d, 0x24, 0xea, 0x78, 0xa2, 0xe3, 0xcf, 0xe8, 0x08, 0x72, 0x77, 0x78,
|
||||
0x62, 0x7c, 0xb2, 0x9d, 0x3e, 0x26, 0x86, 0x47, 0x18, 0xaf, 0x08, 0x7e, 0xf6, 0x0e, 0x4f, 0xce,
|
||||
0xb9, 0xf8, 0x8a, 0x49, 0xd1, 0x63, 0x00, 0xae, 0x69, 0x0e, 0xed, 0xc1, 0x24, 0xcc, 0x41, 0x8a,
|
||||
0xe9, 0x70, 0x81, 0x9a, 0x01, 0xe5, 0xd4, 0xb2, 0x48, 0xe8, 0xb7, 0xaa, 0x42, 0x5a, 0x1c, 0xc3,
|
||||
0xf7, 0x23, 0x58, 0x37, 0x2d, 0x8b, 0x70, 0xee, 0x94, 0xce, 0xbf, 0xd5, 0x77, 0xa0, 0x74, 0x88,
|
||||
0xe9, 0xf8, 0x66, 0x8f, 0x85, 0x00, 0xed, 0x40, 0x82, 0x06, 0xc6, 0x2d, 0x0e, 0xc2, 0xe7, 0x6e,
|
||||
0xd0, 0xa0, 0x86, 0x03, 0x54, 0x80, 0x8d, 0x81, 0xd9, 0xc5, 0x03, 0x7e, 0x65, 0x4a, 0x17, 0x07,
|
||||
0xf5, 0x47, 0xd8, 0xba, 0x1a, 0x75, 0x07, 0xb6, 0x7f, 0x1b, 0x5d, 0xf1, 0x0c, 0x32, 0x9e, 0x10,
|
||||
0x19, 0x98, 0x10, 0x77, 0x7a, 0x57, 0x3a, 0x14, 0x6a, 0x4c, 0xa6, 0xfe, 0xb9, 0x02, 0xa8, 0x8d,
|
||||
0x1d, 0x4b, 0x04, 0xc4, 0x9f, 0x86, 0x79, 0x1f, 0xc0, 0x37, 0xa9, 0xe1, 0x61, 0x62, 0xdc, 0x8d,
|
||||
0xb9, 0xe1, 0x9a, 0x9e, 0xf4, 0x4d, 0x7a, 0x85, 0x49, 0x7d, 0x8c, 0x8e, 0x60, 0xd3, 0x15, 0xfa,
|
||||
0xc5, 0x55, 0x5e, 0x4b, 0xd9, 0x72, 0x58, 0xd8, 0xe5, 0x4e, 0xd0, 0x1a, 0x51, 0x7d, 0x0a, 0xcf,
|
||||
0x9c, 0x5d, 0x93, 0x9c, 0x8d, 0x97, 0xf6, 0xfa, 0x5c, 0x69, 0x3f, 0x87, 0x6d, 0x56, 0xb7, 0x96,
|
||||
0x31, 0x72, 0x98, 0x82, 0x4d, 0x86, 0xd8, 0x2a, 0x6e, 0x1c, 0xae, 0x1c, 0x25, 0xf5, 0x1c, 0x07,
|
||||
0xae, 0x67, 0x72, 0xf5, 0x05, 0xe4, 0x63, 0xde, 0x87, 0x4f, 0xdf, 0x81, 0x04, 0x31, 0xc7, 0x06,
|
||||
0x8d, 0x42, 0x47, 0xcc, 0x71, 0x27, 0x50, 0x5f, 0x03, 0xd2, 0x7c, 0x6a, 0x0f, 0x4d, 0x8a, 0xcf,
|
||||
0x31, 0x9e, 0xbe, 0xf5, 0x00, 0x14, 0x46, 0x68, 0x50, 0x93, 0xf4, 0xf1, 0x34, 0xdb, 0xc0, 0x44,
|
||||
0x1d, 0x2e, 0x51, 0x5f, 0x41, 0x3e, 0x66, 0x16, 0x5e, 0xf2, 0xcd, 0x18, 0xa9, 0x5f, 0xd7, 0x20,
|
||||
0x7d, 0x85, 0x1d, 0xcb, 0x76, 0xfa, 0xed, 0x31, 0xc6, 0x5e, 0xac, 0x52, 0x57, 0xfe, 0xa1, 0x52,
|
||||
0xd1, 0x5b, 0x48, 0x8f, 0x6d, 0xea, 0x60, 0xdf, 0x37, 0xe8, 0xc4, 0xc3, 0x3c, 0xd7, 0xd9, 0x93,
|
||||
0xdd, 0x72, 0xd4, 0x55, 0xca, 0x37, 0x02, 0xee, 0x4c, 0x3c, 0xac, 0x2b, 0xe3, 0xd9, 0x81, 0xd5,
|
||||
0xa5, 0x39, 0x74, 0x47, 0x0e, 0x35, 0x7c, 0x93, 0xf2, 0xb8, 0x67, 0xf4, 0x94, 0x90, 0xb4, 0x4d,
|
||||
0x8a, 0x0e, 0x21, 0x3d, 0xf5, 0xba, 0x3b, 0xa1, 0x98, 0x87, 0x3f, 0xa3, 0x83, 0xf0, 0xfb, 0x6c,
|
||||
0x42, 0x31, 0x7a, 0x09, 0xa8, 0x4b, 0x5c, 0xd3, 0xea, 0x99, 0x3e, 0x35, 0x4c, 0x4a, 0xf1, 0xd0,
|
||||
0xa3, 0x3e, 0xcf, 0x40, 0x46, 0xdf, 0x8e, 0x90, 0xd3, 0x10, 0x40, 0x27, 0xb0, 0xe3, 0xe0, 0x80,
|
||||
0x1a, 0x33, 0x9b, 0x5b, 0x6c, 0xf7, 0x6f, 0x69, 0x31, 0xc1, 0x2d, 0xf2, 0x0c, 0x3c, 0x9b, 0x62,
|
||||
0x35, 0x0e, 0x31, 0x1b, 0x22, 0xa2, 0x8f, 0x2d, 0x43, 0x0e, 0x7e, 0x52, 0xd8, 0x44, 0x60, 0x25,
|
||||
0xca, 0x02, 0x7a, 0x05, 0xbb, 0x33, 0x9b, 0xd8, 0x13, 0x52, 0x73, 0x46, 0xed, 0xd9, 0x5b, 0x0a,
|
||||
0xb0, 0xf1, 0xc9, 0x25, 0x3d, 0x5c, 0xdc, 0xe4, 0x05, 0x24, 0x0e, 0xea, 0x2e, 0x14, 0xe4, 0xd4,
|
||||
0x4c, 0xab, 0x5e, 0xbd, 0x81, 0x9d, 0x39, 0x79, 0x98, 0xea, 0x9f, 0x21, 0xeb, 0x09, 0xc0, 0xf0,
|
||||
0x39, 0x12, 0xf6, 0xd0, 0x3d, 0x29, 0x21, 0xb2, 0xa5, 0x9e, 0xf1, 0x64, 0x1e, 0xf5, 0x8f, 0x15,
|
||||
0xc8, 0x9e, 0x8d, 0x86, 0x9e, 0x54, 0x75, 0xff, 0xaa, 0x1c, 0x0e, 0x40, 0x11, 0x01, 0xe2, 0xc1,
|
||||
0xe2, 0xd5, 0x90, 0xd1, 0x41, 0x88, 0x58, 0x88, 0x16, 0xb2, 0xba, 0xb6, 0x90, 0xd5, 0x28, 0x12,
|
||||
0xeb, 0x72, 0x24, 0xb6, 0x61, 0x2b, 0xf2, 0x2b, 0xec, 0x85, 0x2f, 0x61, 0x9b, 0x4d, 0x8f, 0x58,
|
||||
0x64, 0x50, 0x11, 0x36, 0xbf, 0x60, 0xd2, 0x75, 0x7d, 0xcc, 0x9d, 0x4d, 0xea, 0xd3, 0xa3, 0xfa,
|
||||
0xfb, 0xaa, 0x98, 0x5e, 0x73, 0x11, 0x6b, 0x40, 0x9e, 0xce, 0x7a, 0x99, 0x61, 0x61, 0x6a, 0xda,
|
||||
0x03, 0x3f, 0x7c, 0xe9, 0xc3, 0xf0, 0xa5, 0x52, 0xb7, 0xab, 0x0a, 0x85, 0xda, 0x03, 0x1d, 0xd1,
|
||||
0x05, 0x29, 0xba, 0x81, 0x2d, 0x99, 0xcd, 0xb6, 0xfc, 0xb0, 0xd9, 0xbf, 0x90, 0x12, 0xb0, 0xe8,
|
||||
0x85, 0x7c, 0xc1, 0x45, 0x95, 0x91, 0x67, 0x25, 0x9a, 0x0b, 0xcb, 0x2f, 0xbd, 0x85, 0x6c, 0x5c,
|
||||
0x07, 0x7d, 0xb7, 0x78, 0x15, 0xcb, 0x75, 0x6a, 0xde, 0xf4, 0x2c, 0x09, 0x09, 0x51, 0x0b, 0xaa,
|
||||
0x09, 0x7b, 0x0d, 0xd6, 0xd7, 0x24, 0xa6, 0x69, 0xdc, 0x10, 0xac, 0xd3, 0x20, 0x1a, 0x58, 0xfc,
|
||||
0x7b, 0x79, 0x03, 0x47, 0xfb, 0x90, 0x72, 0xbf, 0x60, 0x32, 0x26, 0x76, 0x98, 0xbe, 0xa4, 0x3e,
|
||||
0x13, 0xa8, 0x25, 0x28, 0x2e, 0x5e, 0x21, 0x1e, 0xf9, 0xfd, 0xd7, 0x35, 0x50, 0xa4, 0x6e, 0x80,
|
||||
0xf2, 0xb0, 0x75, 0xdd, 0xac, 0x37, 0x5b, 0x37, 0x4d, 0xe3, 0xe6, 0xa2, 0xd3, 0xd4, 0xda, 0xed,
|
||||
0xdc, 0x03, 0x54, 0x84, 0x42, 0xa5, 0x75, 0x79, 0x79, 0xd1, 0xb9, 0xd4, 0x9a, 0x1d, 0xa3, 0x73,
|
||||
0x71, 0xa9, 0x19, 0x8d, 0x56, 0xa5, 0x9e, 0x5b, 0x41, 0x7b, 0x90, 0x97, 0x90, 0x66, 0xcb, 0xa8,
|
||||
0x6a, 0x8d, 0xd3, 0x8f, 0xb9, 0x55, 0xb4, 0x03, 0xdb, 0x12, 0xa0, 0x6b, 0x1f, 0x5a, 0x75, 0x2d,
|
||||
0xb7, 0xc6, 0xf4, 0x6b, 0x9d, 0x46, 0xc5, 0x68, 0x9d, 0x9f, 0x6b, 0xba, 0x56, 0x9d, 0x02, 0xeb,
|
||||
0xec, 0x0a, 0x0e, 0x9c, 0x56, 0x2a, 0xda, 0x55, 0x67, 0x86, 0x6c, 0xa0, 0xff, 0xc1, 0xd3, 0x98,
|
||||
0x09, 0xbb, 0xbe, 0x75, 0xdd, 0x31, 0xda, 0x5a, 0xa5, 0xd5, 0xac, 0x1a, 0x0d, 0xed, 0x83, 0xd6,
|
||||
0xc8, 0x25, 0xd0, 0xff, 0x41, 0x8d, 0x13, 0xb4, 0xaf, 0x2b, 0x15, 0xad, 0xdd, 0x8e, 0xeb, 0x6d,
|
||||
0xa2, 0x03, 0x78, 0x34, 0xe7, 0xc1, 0x65, 0xab, 0xa3, 0x4d, 0x59, 0x73, 0x49, 0x74, 0x08, 0xfb,
|
||||
0xf3, 0x9e, 0x70, 0x8d, 0x90, 0x2f, 0x97, 0x42, 0xfb, 0x50, 0xe4, 0x1a, 0x32, 0xf3, 0xd4, 0x5f,
|
||||
0x40, 0x05, 0xc8, 0x85, 0x91, 0x33, 0xea, 0xda, 0x47, 0xa3, 0x76, 0xda, 0xae, 0xe5, 0x14, 0xf4,
|
||||
0x08, 0xf6, 0x9a, 0x5a, 0x9b, 0xd1, 0x2d, 0x80, 0xe9, 0xb9, 0x60, 0x9d, 0x36, 0x2b, 0xb5, 0x96,
|
||||
0x9e, 0xcb, 0x9c, 0xfc, 0xb5, 0x09, 0xa9, 0x1b, 0x5e, 0xa1, 0x75, 0x9b, 0xa2, 0x06, 0x28, 0xd2,
|
||||
0x62, 0x86, 0x1e, 0xcf, 0x15, 0x6f, 0x7c, 0x01, 0x2c, 0x3d, 0xb9, 0x0f, 0x8e, 0xfe, 0xc5, 0x14,
|
||||
0x69, 0xb3, 0x8a, 0xb3, 0x2d, 0x2c, 0x4e, 0x71, 0xb6, 0x25, 0x0b, 0x99, 0x0e, 0x99, 0xd8, 0x6e,
|
||||
0x84, 0x0e, 0x24, 0x83, 0x65, 0xab, 0x58, 0xe9, 0xf0, 0x7e, 0x85, 0x90, 0xf3, 0x1d, 0x64, 0xaa,
|
||||
0x98, 0xd8, 0x5f, 0x70, 0x13, 0x07, 0xb4, 0x8e, 0x27, 0x68, 0x5b, 0x32, 0x11, 0x0b, 0x57, 0x69,
|
||||
0x37, 0x5a, 0x1d, 0xea, 0x78, 0x52, 0xc5, 0x7e, 0x8f, 0xd8, 0x1e, 0x75, 0x09, 0x7a, 0x03, 0x29,
|
||||
0x61, 0xcb, 0xec, 0xf2, 0xb2, 0x52, 0xc3, 0xed, 0x99, 0xd4, 0x25, 0xf7, 0x5a, 0xfe, 0x04, 0x49,
|
||||
0x76, 0x1f, 0x5b, 0xb7, 0x90, 0x3c, 0x31, 0xa5, 0x75, 0xac, 0xb4, 0xb7, 0x20, 0x0f, 0x5d, 0xae,
|
||||
0x01, 0x0a, 0xf7, 0x28, 0x79, 0x15, 0x93, 0x69, 0x24, 0x79, 0xa9, 0x24, 0xf7, 0xff, 0xb9, 0xf5,
|
||||
0xab, 0x01, 0x8a, 0xb4, 0x9a, 0xc4, 0xd2, 0xb3, 0xb8, 0x70, 0xc5, 0xd2, 0xb3, 0x6c, 0xa3, 0x69,
|
||||
0x80, 0x22, 0xed, 0x20, 0x31, 0xb6, 0xc5, 0x95, 0x26, 0xc6, 0xb6, 0x6c, 0x75, 0xd1, 0x21, 0x13,
|
||||
0x1b, 0x74, 0xb1, 0x64, 0x2f, 0x1b, 0x8d, 0xb1, 0x64, 0x2f, 0x9f, 0x91, 0xbf, 0xc0, 0x66, 0x38,
|
||||
0x4a, 0xd0, 0x43, 0x49, 0x39, 0x3e, 0xf6, 0x62, 0x11, 0x9b, 0x9b, 0x3c, 0xe8, 0x02, 0x60, 0xd6,
|
||||
0xc3, 0xd1, 0xfe, 0x3d, 0xad, 0x5d, 0xf0, 0x3c, 0xfe, 0x66, 0xe3, 0x47, 0xbf, 0x41, 0x6e, 0xbe,
|
||||
0x5f, 0x22, 0x55, 0x36, 0x59, 0xde, 0xaf, 0x4b, 0xcf, 0xbe, 0xa9, 0x23, 0xc8, 0xcf, 0x7e, 0xf8,
|
||||
0xf5, 0xb8, 0x6f, 0xd3, 0xdb, 0x51, 0xb7, 0xdc, 0x73, 0x87, 0xc7, 0x03, 0xb6, 0xd1, 0x38, 0xb6,
|
||||
0xd3, 0x77, 0x30, 0x1d, 0xbb, 0xe4, 0xee, 0x78, 0xe0, 0x58, 0xc7, 0x7c, 0xbe, 0x1d, 0x47, 0x5c,
|
||||
0xdd, 0x04, 0xff, 0xa5, 0xf7, 0xea, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x49, 0x6e, 0x8a, 0xc5,
|
||||
0x32, 0x0e, 0x00, 0x00,
|
||||
// 1793 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xef, 0x6e, 0x22, 0xc9,
|
||||
0x11, 0x5f, 0x0c, 0xc6, 0x50, 0x80, 0x8d, 0x1b, 0xbc, 0x66, 0x59, 0xef, 0xd9, 0x3b, 0x97, 0xe4,
|
||||
0x9c, 0xdc, 0x1d, 0x56, 0xbc, 0xba, 0xcb, 0x9e, 0x13, 0x45, 0xb1, 0xf1, 0x58, 0x58, 0x60, 0xf0,
|
||||
0x35, 0x78, 0xad, 0x4d, 0x3e, 0x8c, 0x06, 0xa6, 0x6d, 0x8f, 0x0c, 0x33, 0x73, 0x33, 0x8d, 0x19,
|
||||
0xf2, 0x29, 0x4f, 0x11, 0xe9, 0xa4, 0xbc, 0xc3, 0xbd, 0x40, 0x1e, 0x28, 0x8f, 0x11, 0xf5, 0x1f,
|
||||
0x86, 0x1e, 0xc0, 0x7b, 0x8a, 0x72, 0x9f, 0x4c, 0xd7, 0xaf, 0xea, 0xd7, 0xd5, 0x55, 0x35, 0x5d,
|
||||
0xd5, 0x86, 0x57, 0x13, 0x73, 0x38, 0x24, 0xd4, 0xf7, 0x06, 0x47, 0xe2, 0xd7, 0xa3, 0x4d, 0x6b,
|
||||
0x9e, 0xef, 0x52, 0x17, 0x65, 0x23, 0xa8, 0x9a, 0xf5, 0xbd, 0x81, 0x90, 0x56, 0xcb, 0x81, 0x7d,
|
||||
0xef, 0x30, 0x75, 0xf6, 0x97, 0xf8, 0x42, 0xaa, 0xb5, 0x01, 0xb5, 0xec, 0x80, 0xde, 0x38, 0x81,
|
||||
0x47, 0x1c, 0x8a, 0xc9, 0x0f, 0x63, 0x12, 0x50, 0xf4, 0x1a, 0xb2, 0x23, 0xdb, 0x31, 0x06, 0xae,
|
||||
0x73, 0x17, 0x54, 0x12, 0x07, 0x89, 0xc3, 0x75, 0x9c, 0x19, 0xd9, 0x4e, 0x9d, 0xad, 0x39, 0x68,
|
||||
0x86, 0x12, 0x5c, 0x93, 0xa0, 0x19, 0x72, 0x50, 0x7b, 0x0f, 0xa5, 0x18, 0x5f, 0xe0, 0xb9, 0x4e,
|
||||
0x40, 0xd0, 0x5b, 0x58, 0x1f, 0xd3, 0xd0, 0x65, 0x64, 0xc9, 0xc3, 0xdc, 0x71, 0xae, 0x36, 0x64,
|
||||
0xae, 0xd4, 0x6e, 0x68, 0xe8, 0x62, 0x81, 0x68, 0xdf, 0x03, 0x6a, 0x11, 0x33, 0x20, 0x9d, 0x31,
|
||||
0xf5, 0xc6, 0x91, 0x27, 0x9b, 0xb0, 0x66, 0x5b, 0xdc, 0x85, 0x3c, 0x5e, 0xb3, 0x2d, 0xf4, 0x25,
|
||||
0x64, 0xdc, 0x31, 0xf5, 0x5c, 0xdb, 0xa1, 0x7c, 0xef, 0xdc, 0xf1, 0x96, 0xe4, 0xea, 0x8c, 0xe9,
|
||||
0x35, 0x13, 0xe3, 0x48, 0x41, 0xfb, 0x06, 0x4a, 0x31, 0x4a, 0xe9, 0xcc, 0x67, 0x00, 0x24, 0xf4,
|
||||
0x6c, 0xdf, 0xa4, 0xb6, 0xeb, 0x70, 0xee, 0x14, 0x56, 0x24, 0x5a, 0x17, 0xca, 0x98, 0x0c, 0x7f,
|
||||
0x61, 0x5f, 0x76, 0x61, 0x67, 0x81, 0x54, 0x78, 0xa3, 0x7d, 0x0f, 0xe9, 0x26, 0x99, 0x62, 0xf2,
|
||||
0x03, 0x3a, 0x84, 0xe2, 0x23, 0x99, 0x1a, 0x77, 0xb6, 0x73, 0x4f, 0x7c, 0xc3, 0xf3, 0x19, 0xaf,
|
||||
0x08, 0xfe, 0xe6, 0x23, 0x99, 0x5e, 0x70, 0xf1, 0x35, 0x93, 0xa2, 0x37, 0x00, 0x5c, 0xd3, 0x1c,
|
||||
0xd9, 0xc3, 0xa9, 0xcc, 0x41, 0x96, 0xe9, 0x70, 0x81, 0x56, 0x80, 0xdc, 0xa9, 0x65, 0xf9, 0xd2,
|
||||
0x6f, 0x4d, 0x83, 0xbc, 0x58, 0xca, 0xf3, 0x23, 0x48, 0x99, 0x96, 0xe5, 0x73, 0xee, 0x2c, 0xe6,
|
||||
0xbf, 0xb5, 0x13, 0xc8, 0xf5, 0x7c, 0xd3, 0x09, 0xcc, 0x01, 0x0b, 0x01, 0xda, 0x81, 0x34, 0x0d,
|
||||
0x8d, 0x07, 0x12, 0xca, 0xe3, 0xae, 0xd3, 0xb0, 0x41, 0x42, 0x54, 0x86, 0xf5, 0xa1, 0xd9, 0x27,
|
||||
0x43, 0xbe, 0x65, 0x16, 0x8b, 0x85, 0xf6, 0x2d, 0x6c, 0x5d, 0x8f, 0xfb, 0x43, 0x3b, 0x78, 0x88,
|
||||
0xb6, 0xf8, 0x1c, 0x0a, 0x9e, 0x10, 0x19, 0xc4, 0xf7, 0xdd, 0xd9, 0x5e, 0x79, 0x29, 0xd4, 0x99,
|
||||
0x4c, 0xfb, 0x77, 0x02, 0x50, 0x97, 0x38, 0x96, 0x08, 0x48, 0x30, 0x0b, 0xf3, 0x1e, 0x40, 0x60,
|
||||
0x52, 0xc3, 0x23, 0xbe, 0xf1, 0x38, 0xe1, 0x86, 0x49, 0x9c, 0x09, 0x4c, 0x7a, 0x4d, 0xfc, 0xe6,
|
||||
0x04, 0x1d, 0xc2, 0x86, 0x2b, 0xf4, 0x2b, 0x6b, 0xbc, 0x96, 0x36, 0x6b, 0xb2, 0xb0, 0x6b, 0xbd,
|
||||
0xb0, 0x33, 0xa6, 0x78, 0x06, 0xcf, 0x9d, 0x4d, 0x2a, 0xce, 0xc6, 0x4b, 0x3b, 0xb5, 0x50, 0xda,
|
||||
0x5f, 0xc2, 0x36, 0xab, 0x5b, 0xcb, 0x18, 0x3b, 0x4c, 0xc1, 0xf6, 0x47, 0xc4, 0xaa, 0xac, 0x1f,
|
||||
0x24, 0x0e, 0x33, 0xb8, 0xc8, 0x81, 0x9b, 0xb9, 0x5c, 0xfb, 0x0a, 0x4a, 0x31, 0xef, 0xe5, 0xd1,
|
||||
0x77, 0x20, 0xed, 0x9b, 0x13, 0x83, 0x46, 0xa1, 0xf3, 0xcd, 0x49, 0x2f, 0xd4, 0xbe, 0x01, 0xa4,
|
||||
0x07, 0xd4, 0x1e, 0x99, 0x94, 0x5c, 0x10, 0x32, 0x3b, 0xeb, 0x3e, 0xe4, 0x18, 0xa1, 0x41, 0x4d,
|
||||
0xff, 0x9e, 0xcc, 0xb2, 0x0d, 0x4c, 0xd4, 0xe3, 0x12, 0xed, 0x1d, 0x94, 0x62, 0x66, 0x72, 0x93,
|
||||
0x4f, 0xc6, 0x48, 0xfb, 0x31, 0x09, 0xf9, 0x6b, 0xe2, 0x58, 0xb6, 0x73, 0xdf, 0x9d, 0x10, 0xe2,
|
||||
0xc5, 0x2a, 0x35, 0xf1, 0x33, 0x95, 0x8a, 0xbe, 0x83, 0xfc, 0xc4, 0xa6, 0x0e, 0x09, 0x02, 0x83,
|
||||
0x4e, 0x3d, 0xc2, 0x73, 0xbd, 0x79, 0xfc, 0xb2, 0x16, 0xdd, 0x2a, 0xb5, 0x5b, 0x01, 0xf7, 0xa6,
|
||||
0x1e, 0xc1, 0xb9, 0xc9, 0x7c, 0xc1, 0xea, 0xd2, 0x1c, 0xb9, 0x63, 0x87, 0x1a, 0x81, 0x49, 0x79,
|
||||
0xdc, 0x0b, 0x38, 0x2b, 0x24, 0x5d, 0x93, 0xa2, 0x03, 0xc8, 0xcf, 0xbc, 0xee, 0x4f, 0x29, 0xe1,
|
||||
0xe1, 0x2f, 0x60, 0x10, 0x7e, 0x9f, 0x4d, 0x29, 0x41, 0x5f, 0x03, 0xea, 0xfb, 0xae, 0x69, 0x0d,
|
||||
0xcc, 0x80, 0x1a, 0x26, 0xa5, 0x64, 0xe4, 0xd1, 0x80, 0x67, 0xa0, 0x80, 0xb7, 0x23, 0xe4, 0x54,
|
||||
0x02, 0xe8, 0x18, 0x76, 0x1c, 0x12, 0x52, 0x63, 0x6e, 0xf3, 0x40, 0xec, 0xfb, 0x07, 0x5a, 0x49,
|
||||
0x73, 0x8b, 0x12, 0x03, 0xcf, 0x66, 0x58, 0x83, 0x43, 0xcc, 0xc6, 0x17, 0xd1, 0x27, 0x96, 0xa1,
|
||||
0x06, 0x3f, 0x23, 0x6c, 0x22, 0xb0, 0x1e, 0x65, 0x01, 0xbd, 0x83, 0x97, 0x73, 0x9b, 0xd8, 0x11,
|
||||
0xb2, 0x0b, 0x46, 0xdd, 0xf9, 0x59, 0xca, 0xb0, 0x7e, 0xe7, 0xfa, 0x03, 0x52, 0xd9, 0xe0, 0x05,
|
||||
0x24, 0x16, 0xda, 0x4b, 0x28, 0xab, 0xa9, 0x99, 0x55, 0xbd, 0x76, 0x0b, 0x3b, 0x0b, 0x72, 0x99,
|
||||
0xea, 0x3f, 0xc3, 0xa6, 0x27, 0x00, 0x23, 0xe0, 0x88, 0xbc, 0x43, 0x77, 0x95, 0x84, 0xa8, 0x96,
|
||||
0xb8, 0xe0, 0xa9, 0x3c, 0xda, 0x3f, 0x13, 0xb0, 0x79, 0x36, 0x1e, 0x79, 0x4a, 0xd5, 0xfd, 0x4f,
|
||||
0xe5, 0xb0, 0x0f, 0x39, 0x11, 0x20, 0x1e, 0x2c, 0x5e, 0x0d, 0x05, 0x0c, 0x42, 0xc4, 0x42, 0xb4,
|
||||
0x94, 0xd5, 0xe4, 0x52, 0x56, 0xa3, 0x48, 0xa4, 0xd4, 0x48, 0x6c, 0xc3, 0x56, 0xe4, 0x97, 0xbc,
|
||||
0x0b, 0xbf, 0x86, 0x6d, 0xd6, 0x3d, 0x62, 0x91, 0x41, 0x15, 0xd8, 0x78, 0x22, 0x7e, 0xdf, 0x0d,
|
||||
0x08, 0x77, 0x36, 0x83, 0x67, 0x4b, 0xed, 0x1f, 0x6b, 0xa2, 0x7b, 0x2d, 0x44, 0xac, 0x05, 0x25,
|
||||
0x3a, 0xbf, 0xcb, 0x0c, 0x8b, 0x50, 0xd3, 0x1e, 0x06, 0xf2, 0xa4, 0xaf, 0xe4, 0x49, 0x95, 0xdb,
|
||||
0xee, 0x5c, 0x28, 0x34, 0x5e, 0x60, 0x44, 0x97, 0xa4, 0xe8, 0x16, 0xb6, 0x54, 0x36, 0xdb, 0x0a,
|
||||
0xe4, 0x65, 0xff, 0x95, 0x92, 0x80, 0x65, 0x2f, 0xd4, 0x0d, 0x2e, 0xcf, 0x19, 0xf9, 0xa6, 0x42,
|
||||
0x73, 0x69, 0x05, 0xd5, 0xef, 0x60, 0x33, 0xae, 0x83, 0xbe, 0x58, 0xde, 0x8a, 0xe5, 0x3a, 0xbb,
|
||||
0x68, 0x7a, 0x96, 0x81, 0xb4, 0xa8, 0x05, 0xcd, 0x84, 0xdd, 0x16, 0xbb, 0xd7, 0x14, 0xa6, 0x59,
|
||||
0xdc, 0x10, 0xa4, 0x68, 0x18, 0x35, 0x2c, 0xfe, 0x7b, 0xf5, 0x05, 0x8e, 0xf6, 0x20, 0xeb, 0x3e,
|
||||
0x11, 0x7f, 0xe2, 0xdb, 0x32, 0x7d, 0x19, 0x3c, 0x17, 0x68, 0x55, 0xa8, 0x2c, 0x6f, 0x21, 0x13,
|
||||
0xf6, 0x53, 0x02, 0xb6, 0x2e, 0xc6, 0x8e, 0x75, 0x1d, 0xf4, 0xa3, 0x36, 0x59, 0x86, 0x94, 0x17,
|
||||
0xf4, 0x45, 0x65, 0xe5, 0x1b, 0x2f, 0x30, 0x5f, 0xa1, 0xdf, 0x42, 0xd2, 0x37, 0x27, 0x32, 0x74,
|
||||
0x3b, 0x4a, 0xe8, 0x7a, 0x61, 0x8f, 0x8c, 0xbc, 0xa1, 0x49, 0x49, 0xe3, 0x05, 0x66, 0x3a, 0xe8,
|
||||
0x6d, 0xbc, 0xe2, 0x78, 0x3d, 0x35, 0x12, 0xb1, 0x9a, 0xfb, 0x15, 0x14, 0x66, 0x35, 0xf7, 0x34,
|
||||
0xbf, 0x4a, 0x1a, 0x09, 0x9c, 0x13, 0x65, 0xf7, 0x81, 0x09, 0xcf, 0x00, 0x32, 0x54, 0x72, 0x9f,
|
||||
0xa5, 0x21, 0x75, 0x47, 0x48, 0xa0, 0xfd, 0x2b, 0x01, 0xc5, 0xb9, 0xc7, 0xb2, 0x62, 0xf6, 0x21,
|
||||
0x77, 0x37, 0x76, 0x2c, 0x62, 0x19, 0x73, 0xcf, 0x31, 0x08, 0x11, 0x53, 0x44, 0x35, 0x28, 0x0d,
|
||||
0x1e, 0x4c, 0xe7, 0x9e, 0x18, 0xa2, 0xbb, 0x18, 0xb6, 0x63, 0x91, 0x50, 0x76, 0xde, 0x6d, 0x01,
|
||||
0x89, 0x46, 0x70, 0xc9, 0x00, 0xf4, 0x07, 0xc8, 0x0f, 0xdd, 0xc1, 0x23, 0xb1, 0x0c, 0x31, 0xf6,
|
||||
0x24, 0xf9, 0x27, 0x5b, 0x56, 0x8e, 0xcd, 0x46, 0x1f, 0x3e, 0x9c, 0xe0, 0x9c, 0xd0, 0xbc, 0xe1,
|
||||
0x53, 0xd0, 0x4f, 0x09, 0x80, 0x79, 0x44, 0xd0, 0x17, 0x90, 0xb6, 0x1d, 0xde, 0xec, 0xc4, 0x47,
|
||||
0xbf, 0xf4, 0x9d, 0x4a, 0x18, 0xfd, 0x69, 0xb1, 0x2d, 0x6a, 0x2b, 0x43, 0x5c, 0x93, 0xdd, 0x4a,
|
||||
0x77, 0xa8, 0x3f, 0x8d, 0x5a, 0x65, 0xf5, 0x04, 0xf2, 0x2a, 0x80, 0x8a, 0x90, 0x7c, 0x24, 0x53,
|
||||
0xd9, 0xb4, 0xd9, 0x4f, 0x56, 0x38, 0x4f, 0xe6, 0x70, 0x2c, 0xba, 0x41, 0x0a, 0x8b, 0xc5, 0xc9,
|
||||
0xda, 0xfb, 0x84, 0xf6, 0x00, 0xd9, 0xe8, 0x2c, 0xff, 0xd7, 0x88, 0xb4, 0x30, 0x97, 0x25, 0x97,
|
||||
0xe6, 0xb2, 0x6f, 0xa1, 0x74, 0x61, 0x3b, 0xe6, 0xd0, 0xfe, 0x3b, 0x51, 0xeb, 0xed, 0xe7, 0x92,
|
||||
0xa7, 0x7d, 0x84, 0x72, 0xdc, 0x6e, 0x9e, 0x75, 0x3e, 0x0b, 0xc7, 0x0d, 0x85, 0x88, 0x67, 0xfd,
|
||||
0x00, 0xf2, 0xac, 0x95, 0xdf, 0x31, 0x63, 0xd6, 0xd0, 0xd7, 0x84, 0x86, 0x6f, 0x4e, 0x38, 0x5f,
|
||||
0x2f, 0xfc, 0xdd, 0x8f, 0x49, 0xc8, 0x29, 0xdd, 0x10, 0x95, 0x60, 0xeb, 0xa6, 0xdd, 0x6c, 0x77,
|
||||
0x6e, 0xdb, 0xc6, 0xed, 0x65, 0xaf, 0xad, 0x77, 0xbb, 0xc5, 0x17, 0xa8, 0x02, 0xe5, 0x7a, 0xe7,
|
||||
0xea, 0xea, 0xb2, 0x77, 0xa5, 0xb7, 0x7b, 0x46, 0xef, 0xf2, 0x4a, 0x37, 0x5a, 0x9d, 0x7a, 0xb3,
|
||||
0x98, 0x40, 0xbb, 0x50, 0x52, 0x90, 0x76, 0xc7, 0x38, 0xd7, 0x5b, 0xa7, 0x1f, 0x8b, 0x6b, 0x68,
|
||||
0x07, 0xb6, 0x15, 0x00, 0xeb, 0x1f, 0x3a, 0x4d, 0xbd, 0x98, 0x64, 0xfa, 0x8d, 0x5e, 0xab, 0x6e,
|
||||
0x74, 0x2e, 0x2e, 0x74, 0xac, 0x9f, 0xcf, 0x80, 0x14, 0xdb, 0x82, 0x03, 0xa7, 0xf5, 0xba, 0x7e,
|
||||
0xdd, 0x9b, 0x23, 0xeb, 0xe8, 0xd7, 0xf0, 0x36, 0x66, 0xc2, 0xb6, 0xef, 0xdc, 0xf4, 0x8c, 0xae,
|
||||
0x5e, 0xef, 0xb4, 0xcf, 0x8d, 0x96, 0xfe, 0x41, 0x6f, 0x15, 0xd3, 0xe8, 0x37, 0xa0, 0xc5, 0x09,
|
||||
0xba, 0x37, 0xf5, 0xba, 0xde, 0xed, 0xc6, 0xf5, 0x36, 0xd0, 0x3e, 0xbc, 0x5e, 0xf0, 0xe0, 0xaa,
|
||||
0xd3, 0xd3, 0x67, 0xac, 0xc5, 0x0c, 0x3a, 0x80, 0xbd, 0x45, 0x4f, 0xb8, 0x86, 0xe4, 0x2b, 0x66,
|
||||
0xd1, 0x1e, 0x54, 0xb8, 0x86, 0xca, 0x3c, 0xf3, 0x17, 0x50, 0x19, 0x8a, 0x32, 0x72, 0x46, 0x53,
|
||||
0xff, 0x68, 0x34, 0x4e, 0xbb, 0x8d, 0x62, 0x0e, 0xbd, 0x86, 0xdd, 0xb6, 0xde, 0x65, 0x74, 0x4b,
|
||||
0x60, 0x7e, 0x21, 0x58, 0xa7, 0xed, 0x7a, 0xa3, 0x83, 0x8b, 0x85, 0xe3, 0xff, 0x64, 0x20, 0x7b,
|
||||
0xcb, 0xbf, 0x81, 0xa6, 0x4d, 0x51, 0x0b, 0x72, 0xca, 0xc3, 0x04, 0xbd, 0x59, 0xb8, 0xbc, 0xe3,
|
||||
0x0f, 0xa0, 0xea, 0x67, 0xcf, 0xc1, 0x51, 0x8b, 0xc9, 0x29, 0x2f, 0x8b, 0x38, 0xdb, 0xd2, 0xc3,
|
||||
0x21, 0xce, 0xb6, 0xe2, 0x41, 0x82, 0xa1, 0x10, 0x7b, 0x1b, 0xa0, 0x7d, 0xc5, 0x60, 0xd5, 0x53,
|
||||
0xa4, 0x7a, 0xf0, 0xbc, 0x82, 0xe4, 0x3c, 0x81, 0xc2, 0x39, 0xf1, 0xed, 0x27, 0xd2, 0x26, 0x21,
|
||||
0x6d, 0x92, 0x29, 0xda, 0x56, 0x4c, 0xc4, 0x83, 0xa3, 0xfa, 0x32, 0x1a, 0x9d, 0x9b, 0x64, 0x7a,
|
||||
0x4e, 0x82, 0x81, 0x6f, 0x7b, 0xd4, 0xf5, 0xd1, 0x7b, 0xc8, 0x0a, 0x5b, 0x66, 0x57, 0x52, 0x95,
|
||||
0x5a, 0xee, 0xc0, 0xa4, 0xae, 0xff, 0xac, 0xe5, 0x1f, 0x21, 0xc3, 0xf6, 0x63, 0xcf, 0x0d, 0xa4,
|
||||
0x4e, 0x8c, 0xca, 0x73, 0xa4, 0xba, 0xbb, 0x24, 0x97, 0x2e, 0x37, 0x00, 0xc9, 0x77, 0x84, 0xfa,
|
||||
0x14, 0x51, 0x69, 0x14, 0x79, 0xb5, 0xaa, 0xce, 0x3f, 0x0b, 0xcf, 0x8f, 0x16, 0xe4, 0x94, 0xd1,
|
||||
0x3c, 0x96, 0x9e, 0xe5, 0x07, 0x47, 0x2c, 0x3d, 0xab, 0x26, 0xfa, 0x16, 0xe4, 0x94, 0x19, 0x3c,
|
||||
0xc6, 0xb6, 0x3c, 0xd2, 0xc7, 0xd8, 0x56, 0x8d, 0xee, 0x18, 0x0a, 0xb1, 0x41, 0x2f, 0x96, 0xec,
|
||||
0x55, 0xa3, 0x61, 0x2c, 0xd9, 0xab, 0x67, 0xc4, 0xbf, 0xc0, 0x86, 0x1c, 0xa5, 0xd0, 0x2b, 0x45,
|
||||
0x39, 0x3e, 0xf6, 0xc5, 0x22, 0xb6, 0x30, 0x79, 0xa1, 0x4b, 0x80, 0xf9, 0x0c, 0x83, 0xf6, 0x9e,
|
||||
0x19, 0x6d, 0x04, 0xcf, 0x9b, 0x4f, 0x0e, 0x3e, 0xe8, 0x6f, 0x50, 0x5c, 0x9c, 0x17, 0x90, 0xda,
|
||||
0x8d, 0x9e, 0x99, 0x57, 0xaa, 0x9f, 0x7f, 0x52, 0x47, 0x92, 0xd7, 0x21, 0x33, 0xeb, 0xde, 0x48,
|
||||
0x3d, 0xcf, 0xc2, 0x10, 0x52, 0x7d, 0xbd, 0x12, 0x93, 0x24, 0x1d, 0xc8, 0xab, 0x0d, 0x01, 0xa9,
|
||||
0x29, 0x5b, 0xd1, 0x61, 0xaa, 0xfb, 0xcf, 0xe2, 0x82, 0xf0, 0xec, 0xf7, 0x7f, 0x3d, 0xba, 0xb7,
|
||||
0xe9, 0xc3, 0xb8, 0x5f, 0x1b, 0xb8, 0xa3, 0xa3, 0x21, 0x7b, 0x67, 0x38, 0xb6, 0x73, 0xef, 0x10,
|
||||
0x3a, 0x71, 0xfd, 0xc7, 0xa3, 0xa1, 0x63, 0x1d, 0xf1, 0xae, 0x77, 0x14, 0xf1, 0xf4, 0xd3, 0xfc,
|
||||
0xff, 0x2f, 0xef, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x88, 0xe3, 0xa5, 0xe6, 0xc8, 0x11, 0x00,
|
||||
0x00,
|
||||
}
|
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
|
|
@ -1599,6 +2021,39 @@ type WalletKitClient interface {
|
|||
//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)
|
||||
//
|
||||
//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)
|
||||
}
|
||||
|
||||
type walletKitClient struct {
|
||||
|
|
@ -1726,6 +2181,24 @@ func (c *walletKitClient) LabelTransaction(ctx context.Context, in *LabelTransac
|
|||
return out, nil
|
||||
}
|
||||
|
||||
func (c *walletKitClient) FundPsbt(ctx context.Context, in *FundPsbtRequest, opts ...grpc.CallOption) (*FundPsbtResponse, error) {
|
||||
out := new(FundPsbtResponse)
|
||||
err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/FundPsbt", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *walletKitClient) FinalizePsbt(ctx context.Context, in *FinalizePsbtRequest, opts ...grpc.CallOption) (*FinalizePsbtResponse, error) {
|
||||
out := new(FinalizePsbtResponse)
|
||||
err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/FinalizePsbt", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// WalletKitServer is the server API for WalletKit service.
|
||||
type WalletKitServer interface {
|
||||
//
|
||||
|
|
@ -1820,6 +2293,39 @@ type WalletKitServer interface {
|
|||
//overwrite the exiting transaction label. Labels must not be empty, and
|
||||
//cannot exceed 500 characters.
|
||||
LabelTransaction(context.Context, *LabelTransactionRequest) (*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(context.Context, *FundPsbtRequest) (*FundPsbtResponse, 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(context.Context, *FinalizePsbtRequest) (*FinalizePsbtResponse, error)
|
||||
}
|
||||
|
||||
// UnimplementedWalletKitServer can be embedded to have forward compatible implementations.
|
||||
|
|
@ -1865,6 +2371,12 @@ func (*UnimplementedWalletKitServer) ListSweeps(ctx context.Context, req *ListSw
|
|||
func (*UnimplementedWalletKitServer) LabelTransaction(ctx context.Context, req *LabelTransactionRequest) (*LabelTransactionResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method LabelTransaction not implemented")
|
||||
}
|
||||
func (*UnimplementedWalletKitServer) FundPsbt(ctx context.Context, req *FundPsbtRequest) (*FundPsbtResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method FundPsbt not implemented")
|
||||
}
|
||||
func (*UnimplementedWalletKitServer) FinalizePsbt(ctx context.Context, req *FinalizePsbtRequest) (*FinalizePsbtResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method FinalizePsbt not implemented")
|
||||
}
|
||||
|
||||
func RegisterWalletKitServer(s *grpc.Server, srv WalletKitServer) {
|
||||
s.RegisterService(&_WalletKit_serviceDesc, srv)
|
||||
|
|
@ -2104,6 +2616,42 @@ func _WalletKit_LabelTransaction_Handler(srv interface{}, ctx context.Context, d
|
|||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _WalletKit_FundPsbt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(FundPsbtRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(WalletKitServer).FundPsbt(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/walletrpc.WalletKit/FundPsbt",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(WalletKitServer).FundPsbt(ctx, req.(*FundPsbtRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _WalletKit_FinalizePsbt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(FinalizePsbtRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(WalletKitServer).FinalizePsbt(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/walletrpc.WalletKit/FinalizePsbt",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(WalletKitServer).FinalizePsbt(ctx, req.(*FinalizePsbtRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
var _WalletKit_serviceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "walletrpc.WalletKit",
|
||||
HandlerType: (*WalletKitServer)(nil),
|
||||
|
|
@ -2160,6 +2708,14 @@ var _WalletKit_serviceDesc = grpc.ServiceDesc{
|
|||
MethodName: "LabelTransaction",
|
||||
Handler: _WalletKit_LabelTransaction_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "FundPsbt",
|
||||
Handler: _WalletKit_FundPsbt_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "FinalizePsbt",
|
||||
Handler: _WalletKit_FinalizePsbt_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{},
|
||||
Metadata: "walletrpc/walletkit.proto",
|
||||
|
|
|
|||
|
|
@ -476,6 +476,74 @@ func local_request_WalletKit_LabelTransaction_0(ctx context.Context, marshaler r
|
|||
|
||||
}
|
||||
|
||||
func request_WalletKit_FundPsbt_0(ctx context.Context, marshaler runtime.Marshaler, client WalletKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq FundPsbtRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
newReader, berr := utilities.IOReaderFactory(req.Body)
|
||||
if berr != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
|
||||
}
|
||||
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := client.FundPsbt(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_WalletKit_FundPsbt_0(ctx context.Context, marshaler runtime.Marshaler, server WalletKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq FundPsbtRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
newReader, berr := utilities.IOReaderFactory(req.Body)
|
||||
if berr != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
|
||||
}
|
||||
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := server.FundPsbt(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_WalletKit_FinalizePsbt_0(ctx context.Context, marshaler runtime.Marshaler, client WalletKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq FinalizePsbtRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
newReader, berr := utilities.IOReaderFactory(req.Body)
|
||||
if berr != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
|
||||
}
|
||||
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := client.FinalizePsbt(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_WalletKit_FinalizePsbt_0(ctx context.Context, marshaler runtime.Marshaler, server WalletKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq FinalizePsbtRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
newReader, berr := utilities.IOReaderFactory(req.Body)
|
||||
if berr != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
|
||||
}
|
||||
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := server.FinalizePsbt(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
// RegisterWalletKitHandlerServer registers the http handlers for service WalletKit to "mux".
|
||||
// UnaryRPC :call WalletKitServer directly.
|
||||
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
|
||||
|
|
@ -741,6 +809,46 @@ func RegisterWalletKitHandlerServer(ctx context.Context, mux *runtime.ServeMux,
|
|||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_WalletKit_FundPsbt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_WalletKit_FundPsbt_0(rctx, inboundMarshaler, server, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_WalletKit_FundPsbt_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_WalletKit_FinalizePsbt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_WalletKit_FinalizePsbt_0(rctx, inboundMarshaler, server, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_WalletKit_FinalizePsbt_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -1042,6 +1150,46 @@ func RegisterWalletKitHandlerClient(ctx context.Context, mux *runtime.ServeMux,
|
|||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_WalletKit_FundPsbt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
rctx, err := runtime.AnnotateContext(ctx, mux, req)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_WalletKit_FundPsbt_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_WalletKit_FundPsbt_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_WalletKit_FinalizePsbt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
rctx, err := runtime.AnnotateContext(ctx, mux, req)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_WalletKit_FinalizePsbt_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_WalletKit_FinalizePsbt_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -1071,6 +1219,10 @@ var (
|
|||
pattern_WalletKit_ListSweeps_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "wallet", "sweeps"}, "", runtime.AssumeColonVerbOpt(true)))
|
||||
|
||||
pattern_WalletKit_LabelTransaction_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "wallet", "tx", "label"}, "", runtime.AssumeColonVerbOpt(true)))
|
||||
|
||||
pattern_WalletKit_FundPsbt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "wallet", "psbt", "fund"}, "", runtime.AssumeColonVerbOpt(true)))
|
||||
|
||||
pattern_WalletKit_FinalizePsbt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "wallet", "psbt", "finalize"}, "", runtime.AssumeColonVerbOpt(true)))
|
||||
)
|
||||
|
||||
var (
|
||||
|
|
@ -1099,4 +1251,8 @@ var (
|
|||
forward_WalletKit_ListSweeps_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_WalletKit_LabelTransaction_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_WalletKit_FundPsbt_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_WalletKit_FinalizePsbt_0 = runtime.ForwardResponseMessage
|
||||
)
|
||||
|
|
|
|||
|
|
@ -128,6 +128,43 @@ service WalletKit {
|
|||
*/
|
||||
rpc LabelTransaction (LabelTransactionRequest)
|
||||
returns (LabelTransactionResponse);
|
||||
|
||||
/*
|
||||
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.
|
||||
*/
|
||||
rpc FundPsbt (FundPsbtRequest) returns (FundPsbtResponse);
|
||||
|
||||
/*
|
||||
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.
|
||||
*/
|
||||
rpc FinalizePsbt (FinalizePsbtRequest) returns (FinalizePsbtResponse);
|
||||
}
|
||||
|
||||
message ListUnspentRequest {
|
||||
|
|
@ -461,3 +498,103 @@ message LabelTransactionRequest {
|
|||
|
||||
message LabelTransactionResponse {
|
||||
}
|
||||
|
||||
message FundPsbtRequest {
|
||||
oneof template {
|
||||
/*
|
||||
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.
|
||||
*/
|
||||
bytes psbt = 1;
|
||||
|
||||
/*
|
||||
Use the outputs and optional inputs from this raw template.
|
||||
*/
|
||||
TxTemplate raw = 2;
|
||||
}
|
||||
|
||||
oneof fees {
|
||||
/*
|
||||
The target number of blocks that the transaction should be confirmed in.
|
||||
*/
|
||||
uint32 target_conf = 3;
|
||||
|
||||
/*
|
||||
The fee rate, expressed in sat/vbyte, that should be used to spend the
|
||||
input with.
|
||||
*/
|
||||
uint32 sat_per_vbyte = 4;
|
||||
}
|
||||
}
|
||||
message FundPsbtResponse {
|
||||
/*
|
||||
The funded but not yet signed PSBT packet.
|
||||
*/
|
||||
bytes funded_psbt = 1;
|
||||
|
||||
/*
|
||||
The index of the added change output or -1 if no change was left over.
|
||||
*/
|
||||
int32 change_output_index = 2;
|
||||
|
||||
/*
|
||||
The list of lock leases that were acquired for the inputs in the funded PSBT
|
||||
packet.
|
||||
*/
|
||||
repeated UtxoLease locked_utxos = 3;
|
||||
}
|
||||
|
||||
message TxTemplate {
|
||||
/*
|
||||
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.
|
||||
*/
|
||||
repeated lnrpc.OutPoint inputs = 1;
|
||||
|
||||
/*
|
||||
A map of all addresses and the amounts to send to in the funded PSBT.
|
||||
*/
|
||||
map<string, uint64> outputs = 2;
|
||||
}
|
||||
|
||||
message UtxoLease {
|
||||
/*
|
||||
A 32 byte random ID that identifies the lease.
|
||||
*/
|
||||
bytes id = 1;
|
||||
|
||||
// The identifying outpoint of the output being leased.
|
||||
lnrpc.OutPoint outpoint = 2;
|
||||
|
||||
/*
|
||||
The absolute expiration of the output lease represented as a unix timestamp.
|
||||
*/
|
||||
uint64 expiration = 3;
|
||||
}
|
||||
|
||||
message FinalizePsbtRequest {
|
||||
/*
|
||||
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.
|
||||
*/
|
||||
bytes funded_psbt = 1;
|
||||
}
|
||||
message FinalizePsbtResponse {
|
||||
// The fully signed and finalized transaction in PSBT format.
|
||||
bytes signed_psbt = 1;
|
||||
|
||||
// The fully signed and finalized transaction in the raw wire format.
|
||||
bytes raw_final_tx = 2;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -177,6 +177,74 @@
|
|||
]
|
||||
}
|
||||
},
|
||||
"/v2/wallet/psbt/finalize": {
|
||||
"post": {
|
||||
"summary": "FinalizePsbt expects a partial transaction with all inputs and outputs fully\ndeclared and tries to sign all inputs that belong to the wallet. Lnd must be\nthe last signer of the transaction. That means, if there are any unsigned\nnon-witness inputs or inputs without UTXO information attached or inputs\nwithout witness data that do not belong to lnd's wallet, this method will\nfail. If no error is returned, the PSBT is ready to be extracted and the\nfinal TX within to be broadcast.",
|
||||
"description": "NOTE: This method does NOT publish the transaction once finalized. It is the\ncaller's responsibility to either publish the transaction on success or\nunlock/release any locked UTXOs in case of an error in this method.",
|
||||
"operationId": "FinalizePsbt",
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "A successful response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/walletrpcFinalizePsbtResponse"
|
||||
}
|
||||
},
|
||||
"default": {
|
||||
"description": "An unexpected error response",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/runtimeError"
|
||||
}
|
||||
}
|
||||
},
|
||||
"parameters": [
|
||||
{
|
||||
"name": "body",
|
||||
"in": "body",
|
||||
"required": true,
|
||||
"schema": {
|
||||
"$ref": "#/definitions/walletrpcFinalizePsbtRequest"
|
||||
}
|
||||
}
|
||||
],
|
||||
"tags": [
|
||||
"WalletKit"
|
||||
]
|
||||
}
|
||||
},
|
||||
"/v2/wallet/psbt/fund": {
|
||||
"post": {
|
||||
"summary": "FundPsbt creates a fully populated PSBT that contains enough inputs to fund\nthe outputs specified in the template. There are two ways of specifying a\ntemplate: Either by passing in a PSBT with at least one output declared or\nby passing in a raw TxTemplate message.",
|
||||
"description": "If there are no inputs specified in the template, coin selection is\nperformed automatically. If the template does contain any inputs, it is\nassumed that full coin selection happened externally and no additional\ninputs are added. If the specified inputs aren't enough to fund the outputs\nwith the given fee rate, an error is returned.\n\nAfter either selecting or verifying the inputs, all input UTXOs are locked\nwith an internal app ID.\n\nNOTE: If this method returns without an error, it is the caller's\nresponsibility to either spend the locked UTXOs (by finalizing and then\npublishing the transaction) or to unlock/release the locked UTXOs in case of\nan error on the caller's side.",
|
||||
"operationId": "FundPsbt",
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "A successful response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/walletrpcFundPsbtResponse"
|
||||
}
|
||||
},
|
||||
"default": {
|
||||
"description": "An unexpected error response",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/runtimeError"
|
||||
}
|
||||
}
|
||||
},
|
||||
"parameters": [
|
||||
{
|
||||
"name": "body",
|
||||
"in": "body",
|
||||
"required": true,
|
||||
"schema": {
|
||||
"$ref": "#/definitions/walletrpcFundPsbtRequest"
|
||||
}
|
||||
}
|
||||
],
|
||||
"tags": [
|
||||
"WalletKit"
|
||||
]
|
||||
}
|
||||
},
|
||||
"/v2/wallet/send": {
|
||||
"post": {
|
||||
"summary": "SendOutputs is similar to the existing sendmany call in Bitcoind, and\nallows the caller to create a transaction that sends to several outputs at\nonce. This is ideal when wanting to batch create a set of transactions.",
|
||||
|
|
@ -689,6 +757,77 @@
|
|||
}
|
||||
}
|
||||
},
|
||||
"walletrpcFinalizePsbtRequest": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"funded_psbt": {
|
||||
"type": "string",
|
||||
"format": "byte",
|
||||
"description": "A PSBT that should be signed and finalized. The PSBT must contain all\nrequired inputs, outputs, UTXO data and partial signatures of all other\nsigners."
|
||||
}
|
||||
}
|
||||
},
|
||||
"walletrpcFinalizePsbtResponse": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"signed_psbt": {
|
||||
"type": "string",
|
||||
"format": "byte",
|
||||
"description": "The fully signed and finalized transaction in PSBT format."
|
||||
},
|
||||
"raw_final_tx": {
|
||||
"type": "string",
|
||||
"format": "byte",
|
||||
"description": "The fully signed and finalized transaction in the raw wire format."
|
||||
}
|
||||
}
|
||||
},
|
||||
"walletrpcFundPsbtRequest": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"psbt": {
|
||||
"type": "string",
|
||||
"format": "byte",
|
||||
"description": "Use an existing PSBT packet as the template for the funded PSBT.\n\nThe packet must contain at least one non-dust output. If one or more\ninputs are specified, no coin selection is performed. In that case every\ninput must be an UTXO known to the wallet that has not been locked\nbefore. The sum of all inputs must be sufficiently greater than the sum\nof all outputs to pay a miner fee with the specified fee rate. A change\noutput is added to the PSBT if necessary."
|
||||
},
|
||||
"raw": {
|
||||
"$ref": "#/definitions/walletrpcTxTemplate",
|
||||
"description": "Use the outputs and optional inputs from this raw template."
|
||||
},
|
||||
"target_conf": {
|
||||
"type": "integer",
|
||||
"format": "int64",
|
||||
"description": "The target number of blocks that the transaction should be confirmed in."
|
||||
},
|
||||
"sat_per_vbyte": {
|
||||
"type": "integer",
|
||||
"format": "int64",
|
||||
"description": "The fee rate, expressed in sat/vbyte, that should be used to spend the\ninput with."
|
||||
}
|
||||
}
|
||||
},
|
||||
"walletrpcFundPsbtResponse": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"funded_psbt": {
|
||||
"type": "string",
|
||||
"format": "byte",
|
||||
"description": "The funded but not yet signed PSBT packet."
|
||||
},
|
||||
"change_output_index": {
|
||||
"type": "integer",
|
||||
"format": "int32",
|
||||
"description": "The index of the added change output or -1 if no change was left over."
|
||||
},
|
||||
"locked_utxos": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"$ref": "#/definitions/walletrpcUtxoLease"
|
||||
},
|
||||
"description": "The list of lock leases that were acquired for the inputs in the funded PSBT\npacket."
|
||||
}
|
||||
}
|
||||
},
|
||||
"walletrpcKeyReq": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
|
|
@ -914,6 +1053,45 @@
|
|||
}
|
||||
}
|
||||
},
|
||||
"walletrpcTxTemplate": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"inputs": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"$ref": "#/definitions/lnrpcOutPoint"
|
||||
},
|
||||
"description": "An optional list of inputs to use. Every input must be an UTXO known to the\nwallet that has not been locked before. The sum of all inputs must be\nsufficiently greater than the sum of all outputs to pay a miner fee with the\nfee rate specified in the parent message.\n\nIf no inputs are specified, coin selection will be performed instead and\ninputs of sufficient value will be added to the resulting PSBT."
|
||||
},
|
||||
"outputs": {
|
||||
"type": "object",
|
||||
"additionalProperties": {
|
||||
"type": "string",
|
||||
"format": "uint64"
|
||||
},
|
||||
"description": "A map of all addresses and the amounts to send to in the funded PSBT."
|
||||
}
|
||||
}
|
||||
},
|
||||
"walletrpcUtxoLease": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"id": {
|
||||
"type": "string",
|
||||
"format": "byte",
|
||||
"description": "A 32 byte random ID that identifies the lease."
|
||||
},
|
||||
"outpoint": {
|
||||
"$ref": "#/definitions/lnrpcOutPoint",
|
||||
"description": "The identifying outpoint of the output being leased."
|
||||
},
|
||||
"expiration": {
|
||||
"type": "string",
|
||||
"format": "uint64",
|
||||
"description": "The absolute expiration of the output lease represented as a unix timestamp."
|
||||
}
|
||||
}
|
||||
},
|
||||
"walletrpcWitnessType": {
|
||||
"type": "string",
|
||||
"enum": [
|
||||
|
|
|
|||
|
|
@ -15,6 +15,8 @@ import (
|
|||
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
||||
"github.com/btcsuite/btcd/txscript"
|
||||
"github.com/btcsuite/btcd/wire"
|
||||
"github.com/btcsuite/btcutil"
|
||||
"github.com/btcsuite/btcutil/psbt"
|
||||
"github.com/btcsuite/btcwallet/wtxmgr"
|
||||
"github.com/grpc-ecosystem/grpc-gateway/runtime"
|
||||
"github.com/lightningnetwork/lnd/input"
|
||||
|
|
@ -114,12 +116,32 @@ var (
|
|||
Entity: "onchain",
|
||||
Action: "read",
|
||||
}},
|
||||
"/walletrpc.WalletKit/FundPsbt": {{
|
||||
Entity: "onchain",
|
||||
Action: "write",
|
||||
}},
|
||||
"/walletrpc.WalletKit/FinalizePsbt": {{
|
||||
Entity: "onchain",
|
||||
Action: "write",
|
||||
}},
|
||||
}
|
||||
|
||||
// DefaultWalletKitMacFilename is the default name of the wallet kit
|
||||
// macaroon that we expect to find via a file handle within the main
|
||||
// configuration file in this package.
|
||||
DefaultWalletKitMacFilename = "walletkit.macaroon"
|
||||
|
||||
// LndInternalLockID is the binary representation of the SHA256 hash of
|
||||
// the string "lnd-internal-lock-id" and is used for UTXO lock leases to
|
||||
// identify that we ourselves are locking an UTXO, for example when
|
||||
// giving out a funded PSBT. The ID corresponds to the hex value of
|
||||
// ede19a92ed321a4705f8a1cccc1d4f6182545d4bb4fae08bd5937831b7e38f98.
|
||||
LndInternalLockID = wtxmgr.LockID{
|
||||
0xed, 0xe1, 0x9a, 0x92, 0xed, 0x32, 0x1a, 0x47,
|
||||
0x05, 0xf8, 0xa1, 0xcc, 0xcc, 0x1d, 0x4f, 0x61,
|
||||
0x82, 0x54, 0x5d, 0x4b, 0xb4, 0xfa, 0xe0, 0x8b,
|
||||
0xd5, 0x93, 0x78, 0x31, 0xb7, 0xe3, 0x8f, 0x98,
|
||||
}
|
||||
)
|
||||
|
||||
// ErrZeroLabel is returned when an attempt is made to label a transaction with
|
||||
|
|
@ -307,6 +329,12 @@ func (w *WalletKit) LeaseOutput(ctx context.Context,
|
|||
return nil, errors.New("id must be 32 random bytes")
|
||||
}
|
||||
|
||||
// Don't allow our internal ID to be used externally for locking. Only
|
||||
// unlocking is allowed.
|
||||
if lockID == LndInternalLockID {
|
||||
return nil, errors.New("reserved id cannot be used")
|
||||
}
|
||||
|
||||
op, err := unmarshallOutPoint(req.Outpoint)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -830,3 +858,262 @@ func (w *WalletKit) LabelTransaction(ctx context.Context,
|
|||
err = w.cfg.Wallet.LabelTransaction(*hash, req.Label, req.Overwrite)
|
||||
return &LabelTransactionResponse{}, err
|
||||
}
|
||||
|
||||
// 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.
|
||||
func (w *WalletKit) FundPsbt(_ context.Context,
|
||||
req *FundPsbtRequest) (*FundPsbtResponse, error) {
|
||||
|
||||
var (
|
||||
err error
|
||||
packet *psbt.Packet
|
||||
feeSatPerKW chainfee.SatPerKWeight
|
||||
locks []*utxoLock
|
||||
rawPsbt bytes.Buffer
|
||||
)
|
||||
|
||||
// There are two ways a user can specify what we call the template (a
|
||||
// list of inputs and outputs to use in the PSBT): Either as a PSBT
|
||||
// packet directly or as a special RPC message. Find out which one the
|
||||
// user wants to use, they are mutually exclusive.
|
||||
switch {
|
||||
// The template is specified as a PSBT. All we have to do is parse it.
|
||||
case req.GetPsbt() != nil:
|
||||
r := bytes.NewReader(req.GetPsbt())
|
||||
packet, err = psbt.NewFromRawBytes(r, false)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("could not parse PSBT: %v", err)
|
||||
}
|
||||
|
||||
// The template is specified as a RPC message. We need to create a new
|
||||
// PSBT and copy the RPC information over.
|
||||
case req.GetRaw() != nil:
|
||||
tpl := req.GetRaw()
|
||||
if len(tpl.Outputs) == 0 {
|
||||
return nil, fmt.Errorf("no outputs specified")
|
||||
}
|
||||
|
||||
txOut := make([]*wire.TxOut, 0, len(tpl.Outputs))
|
||||
for addrStr, amt := range tpl.Outputs {
|
||||
addr, err := btcutil.DecodeAddress(
|
||||
addrStr, w.cfg.ChainParams,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error parsing address "+
|
||||
"%s for network %s: %v", addrStr,
|
||||
w.cfg.ChainParams.Name, err)
|
||||
}
|
||||
pkScript, err := txscript.PayToAddrScript(addr)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error getting pk "+
|
||||
"script for address %s: %v", addrStr,
|
||||
err)
|
||||
}
|
||||
|
||||
txOut = append(txOut, &wire.TxOut{
|
||||
Value: int64(amt),
|
||||
PkScript: pkScript,
|
||||
})
|
||||
}
|
||||
|
||||
txIn := make([]*wire.OutPoint, len(tpl.Inputs))
|
||||
for idx, in := range tpl.Inputs {
|
||||
op, err := unmarshallOutPoint(in)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error parsing "+
|
||||
"outpoint: %v", err)
|
||||
}
|
||||
txIn[idx] = op
|
||||
}
|
||||
|
||||
sequences := make([]uint32, len(txIn))
|
||||
packet, err = psbt.New(txIn, txOut, 2, 0, sequences)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("could not create PSBT: %v", err)
|
||||
}
|
||||
|
||||
default:
|
||||
return nil, fmt.Errorf("transaction template missing, need " +
|
||||
"to specify either PSBT or raw TX template")
|
||||
}
|
||||
|
||||
// Determine the desired transaction fee.
|
||||
switch {
|
||||
// Estimate the fee by the target number of blocks to confirmation.
|
||||
case req.GetTargetConf() != 0:
|
||||
targetConf := req.GetTargetConf()
|
||||
if targetConf < 2 {
|
||||
return nil, fmt.Errorf("confirmation target must be " +
|
||||
"greater than 1")
|
||||
}
|
||||
|
||||
feeSatPerKW, err = w.cfg.FeeEstimator.EstimateFeePerKW(
|
||||
targetConf,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("could not estimate fee: %v",
|
||||
err)
|
||||
}
|
||||
|
||||
// Convert the fee to sat/kW from the specified sat/vByte.
|
||||
case req.GetSatPerVbyte() != 0:
|
||||
feeSatPerKW = chainfee.SatPerKVByte(
|
||||
req.GetSatPerVbyte() * 1000,
|
||||
).FeePerKWeight()
|
||||
|
||||
default:
|
||||
return nil, fmt.Errorf("fee definition missing, need to " +
|
||||
"specify either target_conf or set_per_vbyte")
|
||||
}
|
||||
|
||||
// The RPC parsing part is now over. Several of the following operations
|
||||
// require us to hold the global coin selection lock so we do the rest
|
||||
// of the tasks while holding the lock. The result is a list of locked
|
||||
// UTXOs.
|
||||
changeIndex := int32(-1)
|
||||
err = w.cfg.CoinSelectionLocker.WithCoinSelectLock(func() error {
|
||||
// In case the user did specify inputs, we need to make sure
|
||||
// they are known to us, still unspent and not yet locked.
|
||||
if len(packet.UnsignedTx.TxIn) > 0 {
|
||||
// Get a list of all unspent witness outputs.
|
||||
utxos, err := w.cfg.Wallet.ListUnspentWitness(
|
||||
defaultMinConf, defaultMaxConf,
|
||||
)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Validate all inputs against our known list of UTXOs
|
||||
// now.
|
||||
err = verifyInputsUnspent(packet.UnsignedTx.TxIn, utxos)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// We made sure the input from the user is as sane as possible.
|
||||
// We can now ask the wallet to fund the TX. This will not yet
|
||||
// lock any coins but might still change the wallet DB by
|
||||
// generating a new change address.
|
||||
changeIndex, err = w.cfg.Wallet.FundPsbt(packet, feeSatPerKW)
|
||||
if err != nil {
|
||||
return fmt.Errorf("wallet couldn't fund PSBT: %v", err)
|
||||
}
|
||||
|
||||
// Make sure we can properly serialize the packet. If this goes
|
||||
// wrong then something isn't right with the inputs and we
|
||||
// probably shouldn't try to lock any of them.
|
||||
err = packet.Serialize(&rawPsbt)
|
||||
if err != nil {
|
||||
return fmt.Errorf("error serializing funded PSBT: %v",
|
||||
err)
|
||||
}
|
||||
|
||||
// Now we have obtained a set of coins that can be used to fund
|
||||
// the TX. Let's lock them to be sure they aren't spent by the
|
||||
// time the PSBT is published. This is the action we do here
|
||||
// that could cause an error. Therefore if some of the UTXOs
|
||||
// cannot be locked, the rollback of the other's locks also
|
||||
// happens in this function. If we ever need to do more after
|
||||
// this function, we need to extract the rollback needs to be
|
||||
// extracted into a defer.
|
||||
locks, err = lockInputs(w.cfg.Wallet, packet)
|
||||
if err != nil {
|
||||
return fmt.Errorf("could not lock inputs: %v", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Convert the lock leases to the RPC format.
|
||||
rpcLocks := make([]*UtxoLease, len(locks))
|
||||
for idx, lock := range locks {
|
||||
rpcLocks[idx] = &UtxoLease{
|
||||
Id: lock.lockID[:],
|
||||
Outpoint: &lnrpc.OutPoint{
|
||||
TxidBytes: lock.outpoint.Hash[:],
|
||||
TxidStr: lock.outpoint.String(),
|
||||
OutputIndex: lock.outpoint.Index,
|
||||
},
|
||||
Expiration: uint64(lock.expiration.Unix()),
|
||||
}
|
||||
}
|
||||
|
||||
return &FundPsbtResponse{
|
||||
FundedPsbt: rawPsbt.Bytes(),
|
||||
ChangeOutputIndex: changeIndex,
|
||||
LockedUtxos: rpcLocks,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// 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.
|
||||
func (w *WalletKit) FinalizePsbt(_ context.Context,
|
||||
req *FinalizePsbtRequest) (*FinalizePsbtResponse, error) {
|
||||
|
||||
// Parse the funded PSBT. No additional checks are required at this
|
||||
// level as the wallet will perform all of them.
|
||||
packet, err := psbt.NewFromRawBytes(
|
||||
bytes.NewReader(req.FundedPsbt), false,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error parsing PSBT: %v", err)
|
||||
}
|
||||
|
||||
// Let the wallet do the heavy lifting. This will sign all inputs that
|
||||
// we have the UTXO for. If some inputs can't be signed and don't have
|
||||
// witness data attached, this will fail.
|
||||
err = w.cfg.Wallet.FinalizePsbt(packet)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error finalizing PSBT: %v", err)
|
||||
}
|
||||
|
||||
var (
|
||||
finalPsbtBytes bytes.Buffer
|
||||
finalTxBytes bytes.Buffer
|
||||
)
|
||||
|
||||
// Serialize the finalized PSBT in both the packet and wire format.
|
||||
err = packet.Serialize(&finalPsbtBytes)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error serializing PSBT: %v", err)
|
||||
}
|
||||
finalTx, err := psbt.Extract(packet)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unable to extract final TX: %v", err)
|
||||
}
|
||||
err = finalTx.Serialize(&finalTxBytes)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error serializing final TX: %v", err)
|
||||
}
|
||||
|
||||
return &FinalizePsbtResponse{
|
||||
SignedPsbt: finalPsbtBytes.Bytes(),
|
||||
RawFinalTx: finalTxBytes.Bytes(),
|
||||
}, nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,9 +8,9 @@ import (
|
|||
|
||||
"github.com/btcsuite/btcd/wire"
|
||||
"github.com/btcsuite/btcutil"
|
||||
"github.com/btcsuite/btcutil/psbt"
|
||||
"github.com/lightningnetwork/lnd"
|
||||
"github.com/lightningnetwork/lnd/lnrpc"
|
||||
"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
|
||||
"github.com/lightningnetwork/lnd/lntest"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
|
@ -22,53 +22,48 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
ctxb := context.Background()
|
||||
const chanSize = lnd.MaxBtcFundingAmount
|
||||
|
||||
// First, we'll create two new nodes that we'll use to open channel
|
||||
// between for this test.
|
||||
// First, we'll create two new nodes that we'll use to open channels
|
||||
// between for this test. Dave gets some coins that will be used to
|
||||
// fund the PSBT, just to make sure that Carol has an empty wallet.
|
||||
carol, err := net.NewNode("carol", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to start new node: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
defer shutdownAndAssert(net, t, carol)
|
||||
|
||||
dave, err := net.NewNode("dave", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to start new node: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
defer shutdownAndAssert(net, t, dave)
|
||||
err = net.SendCoins(ctxb, btcutil.SatoshiPerBitcoin, dave)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to send coins to dave: %v", err)
|
||||
}
|
||||
|
||||
// Before we start the test, we'll ensure both sides are connected so
|
||||
// the funding flow can be properly executed.
|
||||
ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
err = net.EnsureConnected(ctxt, carol, dave)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to connect peers: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
err = net.EnsureConnected(ctxt, carol, net.Alice)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to connect peers: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// At this point, we can begin our PSBT channel funding workflow. We'll
|
||||
// start by generating a pending channel ID externally that will be used
|
||||
// to track this new funding type.
|
||||
var pendingChanID [32]byte
|
||||
if _, err := rand.Read(pendingChanID[:]); err != nil {
|
||||
t.Fatalf("unable to gen pending chan ID: %v", err)
|
||||
}
|
||||
_, err = rand.Read(pendingChanID[:])
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// We'll also test batch funding of two channels so we need another ID.
|
||||
var pendingChanID2 [32]byte
|
||||
if _, err := rand.Read(pendingChanID2[:]); err != nil {
|
||||
t.Fatalf("unable to gen pending chan ID: %v", err)
|
||||
}
|
||||
_, err = rand.Read(pendingChanID2[:])
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// Now that we have the pending channel ID, Carol will open the channel
|
||||
// by specifying a PSBT shim. We use the NoPublish flag here to avoid
|
||||
// publishing the whole batch TX too early.
|
||||
ctxt, cancel = context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
chanUpdates, psbtBytes, err := openChannelPsbt(
|
||||
chanUpdates, tempPsbt, err := openChannelPsbt(
|
||||
ctxt, carol, dave, lntest.OpenChannelParams{
|
||||
Amt: chanSize,
|
||||
FundingShim: &lnrpc.FundingShim{
|
||||
|
|
@ -81,16 +76,11 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
},
|
||||
},
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open channel to dave: %v", err)
|
||||
}
|
||||
packet, err := psbt.NewFromRawBytes(bytes.NewReader(psbtBytes), false)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to parse returned PSBT: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// Let's add a second channel to the batch. This time between carol and
|
||||
// alice. We will the batch TX once this channel funding is complete.
|
||||
// Let's add a second channel to the batch. This time between Carol and
|
||||
// Alice. We will publish the batch TX once this channel funding is
|
||||
// complete.
|
||||
ctxt, cancel = context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
chanUpdates2, psbtBytes2, err := openChannelPsbt(
|
||||
|
|
@ -101,59 +91,29 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
PsbtShim: &lnrpc.PsbtShim{
|
||||
PendingChanId: pendingChanID2[:],
|
||||
NoPublish: false,
|
||||
BasePsbt: tempPsbt,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to open channel to alice: %v", err)
|
||||
}
|
||||
packet2, err := psbt.NewFromRawBytes(bytes.NewReader(psbtBytes2), false)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to parse returned PSBT: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// We'll now create a fully signed transaction that sends to the outputs
|
||||
// encoded in the PSBT. We'll let the miner do it and convert the final
|
||||
// TX into a PSBT, that's way easier than assembling a PSBT manually.
|
||||
allOuts := append(packet.UnsignedTx.TxOut, packet2.UnsignedTx.TxOut...)
|
||||
finalTx, err := net.Miner.CreateTransaction(allOuts, 5, true)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to create funding transaction: %v", err)
|
||||
}
|
||||
|
||||
// The helper function splits the final TX into the non-witness data
|
||||
// encoded in a PSBT and the witness data returned separately.
|
||||
unsignedPsbt, scripts, witnesses, err := createPsbtFromSignedTx(finalTx)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to convert funding transaction into PSBT: %v",
|
||||
err)
|
||||
}
|
||||
|
||||
// The PSBT will also be checked if there are large enough inputs
|
||||
// present. We need to add some fake UTXO information to the PSBT to
|
||||
// tell it what size of inputs we have.
|
||||
for idx, txIn := range unsignedPsbt.UnsignedTx.TxIn {
|
||||
utxPrevOut := txIn.PreviousOutPoint.Index
|
||||
fakeUtxo := &wire.MsgTx{
|
||||
Version: 2,
|
||||
TxIn: []*wire.TxIn{{}},
|
||||
TxOut: make([]*wire.TxOut, utxPrevOut+1),
|
||||
}
|
||||
for idx := range fakeUtxo.TxOut {
|
||||
fakeUtxo.TxOut[idx] = &wire.TxOut{}
|
||||
}
|
||||
fakeUtxo.TxOut[utxPrevOut].Value = 10000000000
|
||||
unsignedPsbt.Inputs[idx].NonWitnessUtxo = fakeUtxo
|
||||
}
|
||||
|
||||
// Serialize the PSBT with the faked UTXO information.
|
||||
var buf bytes.Buffer
|
||||
err = unsignedPsbt.Serialize(&buf)
|
||||
if err != nil {
|
||||
t.Fatalf("error serializing PSBT: %v", err)
|
||||
// We'll now ask Dave's wallet to fund the PSBT for us. This will return
|
||||
// a packet with inputs and outputs set but without any witness data.
|
||||
// This is exactly what we need for the next step.
|
||||
ctxt, cancel = context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
fundReq := &walletrpc.FundPsbtRequest{
|
||||
Template: &walletrpc.FundPsbtRequest_Psbt{
|
||||
Psbt: psbtBytes2,
|
||||
},
|
||||
Fees: &walletrpc.FundPsbtRequest_SatPerVbyte{
|
||||
SatPerVbyte: 2,
|
||||
},
|
||||
}
|
||||
fundResp, err := dave.WalletKitClient.FundPsbt(ctxt, fundReq)
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// We have a PSBT that has no witness data yet, which is exactly what we
|
||||
// need for the next step: Verify the PSBT with the funding intents.
|
||||
|
|
@ -161,67 +121,50 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
Trigger: &lnrpc.FundingTransitionMsg_PsbtVerify{
|
||||
PsbtVerify: &lnrpc.FundingPsbtVerify{
|
||||
PendingChanId: pendingChanID[:],
|
||||
FundedPsbt: buf.Bytes(),
|
||||
FundedPsbt: fundResp.FundedPsbt,
|
||||
},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("error verifying PSBT with funding intent: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
_, err = carol.FundingStateStep(ctxb, &lnrpc.FundingTransitionMsg{
|
||||
Trigger: &lnrpc.FundingTransitionMsg_PsbtVerify{
|
||||
PsbtVerify: &lnrpc.FundingPsbtVerify{
|
||||
PendingChanId: pendingChanID2[:],
|
||||
FundedPsbt: buf.Bytes(),
|
||||
FundedPsbt: fundResp.FundedPsbt,
|
||||
},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("error verifying PSBT with funding intent 2: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// Now we'll add the witness data back into the PSBT to make it a
|
||||
// complete and signed transaction that can be finalized. We'll trick
|
||||
// a bit by putting the script sig back directly, because we know we
|
||||
// will only get non-witness outputs from the miner wallet.
|
||||
for idx := range finalTx.TxIn {
|
||||
if len(witnesses[idx]) > 0 {
|
||||
t.Fatalf("unexpected witness inputs in wallet TX")
|
||||
}
|
||||
unsignedPsbt.Inputs[idx].FinalScriptSig = scripts[idx]
|
||||
// Now we'll ask Dave's wallet to sign the PSBT so we can finish the
|
||||
// funding flow.
|
||||
ctxt, cancel = context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
finalizeReq := &walletrpc.FinalizePsbtRequest{
|
||||
FundedPsbt: fundResp.FundedPsbt,
|
||||
}
|
||||
finalizeRes, err := dave.WalletKitClient.FinalizePsbt(ctxt, finalizeReq)
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// We've signed our PSBT now, let's pass it to the intent again.
|
||||
buf.Reset()
|
||||
err = unsignedPsbt.Serialize(&buf)
|
||||
if err != nil {
|
||||
t.Fatalf("error serializing PSBT: %v", err)
|
||||
}
|
||||
_, err = carol.FundingStateStep(ctxb, &lnrpc.FundingTransitionMsg{
|
||||
Trigger: &lnrpc.FundingTransitionMsg_PsbtFinalize{
|
||||
PsbtFinalize: &lnrpc.FundingPsbtFinalize{
|
||||
PendingChanId: pendingChanID[:],
|
||||
SignedPsbt: buf.Bytes(),
|
||||
SignedPsbt: finalizeRes.SignedPsbt,
|
||||
},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("error finalizing PSBT with funding intent: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// Consume the "channel pending" update. This waits until the funding
|
||||
// transaction was fully compiled.
|
||||
ctxt, cancel = context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
updateResp, err := receiveChanUpdate(ctxt, chanUpdates)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to consume channel update message: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
upd, ok := updateResp.Update.(*lnrpc.OpenStatusUpdate_ChanPending)
|
||||
if !ok {
|
||||
t.Fatalf("expected PSBT funding update, instead got %v",
|
||||
updateResp)
|
||||
}
|
||||
require.True(t.t, ok)
|
||||
chanPoint := &lnrpc.ChannelPoint{
|
||||
FundingTxid: &lnrpc.ChannelPoint_FundingTxidBytes{
|
||||
FundingTxidBytes: upd.ChanPending.Txid,
|
||||
|
|
@ -231,29 +174,21 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
|
||||
// No transaction should have been published yet.
|
||||
mempool, err := net.Miner.Node.GetRawMempool()
|
||||
if err != nil {
|
||||
t.Fatalf("error querying mempool: %v", err)
|
||||
}
|
||||
if len(mempool) != 0 {
|
||||
t.Fatalf("unexpected txes in mempool: %v", mempool)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
require.Equal(t.t, 0, len(mempool))
|
||||
|
||||
// Let's progress the second channel now. This time we'll use the raw
|
||||
// wire format transaction directly.
|
||||
buf.Reset()
|
||||
err = finalTx.Serialize(&buf)
|
||||
require.NoError(t.t, err)
|
||||
_, err = carol.FundingStateStep(ctxb, &lnrpc.FundingTransitionMsg{
|
||||
Trigger: &lnrpc.FundingTransitionMsg_PsbtFinalize{
|
||||
PsbtFinalize: &lnrpc.FundingPsbtFinalize{
|
||||
PendingChanId: pendingChanID2[:],
|
||||
FinalRawTx: buf.Bytes(),
|
||||
FinalRawTx: finalizeRes.RawFinalTx,
|
||||
},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("error finalizing PSBT with funding intent 2: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// Consume the "channel pending" update for the second channel. This
|
||||
// waits until the funding transaction was fully compiled and in this
|
||||
|
|
@ -261,14 +196,9 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
ctxt, cancel = context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
updateResp2, err := receiveChanUpdate(ctxt, chanUpdates2)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to consume channel update message: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
upd2, ok := updateResp2.Update.(*lnrpc.OpenStatusUpdate_ChanPending)
|
||||
if !ok {
|
||||
t.Fatalf("expected PSBT funding update, instead got %v",
|
||||
updateResp2)
|
||||
}
|
||||
require.True(t.t, ok)
|
||||
chanPoint2 := &lnrpc.ChannelPoint{
|
||||
FundingTxid: &lnrpc.ChannelPoint_FundingTxidBytes{
|
||||
FundingTxidBytes: upd2.ChanPending.Txid,
|
||||
|
|
@ -278,19 +208,19 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
|
||||
// Great, now we can mine a block to get the transaction confirmed, then
|
||||
// wait for the new channel to be propagated through the network.
|
||||
var finalTx wire.MsgTx
|
||||
err = finalTx.Deserialize(bytes.NewReader(finalizeRes.RawFinalTx))
|
||||
require.NoError(t.t, err)
|
||||
|
||||
txHash := finalTx.TxHash()
|
||||
block := mineBlocks(t, net, 6, 1)[0]
|
||||
assertTxInBlock(t, block, &txHash)
|
||||
ctxt, cancel = context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
err = carol.WaitForNetworkChannelOpen(ctxt, chanPoint)
|
||||
if err != nil {
|
||||
t.Fatalf("carol didn't report channel: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
err = carol.WaitForNetworkChannelOpen(ctxt, chanPoint2)
|
||||
if err != nil {
|
||||
t.Fatalf("carol didn't report channel 2: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// With the channel open, ensure that it is counted towards Carol's
|
||||
// total channel balance.
|
||||
|
|
@ -298,12 +228,8 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
ctxt, cancel = context.WithTimeout(ctxb, defaultTimeout)
|
||||
defer cancel()
|
||||
balRes, err := carol.ChannelBalance(ctxt, balReq)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to get carol's balance: %v", err)
|
||||
}
|
||||
if balRes.LocalBalance.Sat == 0 {
|
||||
t.Fatalf("carol has an empty channel balance")
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
require.NotEqual(t.t, int64(0), balRes.LocalBalance.Sat)
|
||||
|
||||
// Next, to make sure the channel functions as normal, we'll make some
|
||||
// payments within the channel.
|
||||
|
|
@ -314,17 +240,13 @@ func testPsbtChanFunding(net *lntest.NetworkHarness, t *harnessTest) {
|
|||
}
|
||||
ctxt, _ = context.WithTimeout(ctxb, defaultTimeout)
|
||||
resp, err := dave.AddInvoice(ctxt, invoice)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to add invoice: %v", err)
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
ctxt, _ = context.WithTimeout(ctxb, defaultTimeout)
|
||||
err = completePaymentRequests(
|
||||
ctxt, carol, carol.RouterClient, []string{resp.PaymentRequest},
|
||||
true,
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("unable to make payments between Carol and Dave")
|
||||
}
|
||||
require.NoError(t.t, err)
|
||||
|
||||
// To conclude, we'll close the newly created channel between Carol and
|
||||
// Dave. This function will also block until the channel is closed and
|
||||
|
|
@ -421,31 +343,3 @@ func receiveChanUpdate(ctx context.Context,
|
|||
return updateMsg, nil
|
||||
}
|
||||
}
|
||||
|
||||
// createPsbtFromSignedTx is a utility function to create a PSBT from an
|
||||
// already-signed transaction, so we can test reconstructing, signing and
|
||||
// extracting it. Returned are: an unsigned transaction serialization, a list
|
||||
// of scriptSigs, one per input, and a list of witnesses, one per input.
|
||||
func createPsbtFromSignedTx(tx *wire.MsgTx) (*psbt.Packet, [][]byte,
|
||||
[]wire.TxWitness, error) {
|
||||
|
||||
scriptSigs := make([][]byte, 0, len(tx.TxIn))
|
||||
witnesses := make([]wire.TxWitness, 0, len(tx.TxIn))
|
||||
tx2 := tx.Copy()
|
||||
|
||||
// Blank out signature info in inputs
|
||||
for i, tin := range tx2.TxIn {
|
||||
tin.SignatureScript = nil
|
||||
scriptSigs = append(scriptSigs, tx.TxIn[i].SignatureScript)
|
||||
tin.Witness = nil
|
||||
witnesses = append(witnesses, tx.TxIn[i].Witness)
|
||||
}
|
||||
|
||||
// Outputs always contain: (value, scriptPubkey) so don't need
|
||||
// amending. Now tx2 is tx with all signing data stripped out
|
||||
unsignedPsbt, err := psbt.NewFromUnsignedTx(tx2)
|
||||
if err != nil {
|
||||
return nil, nil, nil, err
|
||||
}
|
||||
return unsignedPsbt, scriptSigs, witnesses, nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import (
|
|||
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
||||
"github.com/btcsuite/btcd/wire"
|
||||
"github.com/btcsuite/btcutil"
|
||||
"github.com/btcsuite/btcutil/psbt"
|
||||
"github.com/btcsuite/btcwallet/wallet/txauthor"
|
||||
"github.com/btcsuite/btcwallet/wtxmgr"
|
||||
|
||||
|
|
@ -141,6 +142,18 @@ func (w *WalletController) ReleaseOutput(wtxmgr.LockID, wire.OutPoint) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
// FundPsbt currently does nothing.
|
||||
func (w *WalletController) FundPsbt(_ *psbt.Packet,
|
||||
_ chainfee.SatPerKWeight) (int32, error) {
|
||||
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// FinalizePsbt currently does nothing.
|
||||
func (w *WalletController) FinalizePsbt(_ *psbt.Packet) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishTransaction sends a transaction to the PublishedTransactions chan.
|
||||
func (w *WalletController) PublishTransaction(tx *wire.MsgTx, _ string) error {
|
||||
w.PublishedTransactions <- tx
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@ import (
|
|||
"github.com/btcsuite/btcd/txscript"
|
||||
"github.com/btcsuite/btcd/wire"
|
||||
"github.com/btcsuite/btcutil"
|
||||
"github.com/btcsuite/btcutil/psbt"
|
||||
"github.com/btcsuite/btcwallet/chain"
|
||||
"github.com/btcsuite/btcwallet/waddrmgr"
|
||||
base "github.com/btcsuite/btcwallet/wallet"
|
||||
|
|
@ -690,6 +691,51 @@ func (b *BtcWallet) ListTransactionDetails(startHeight,
|
|||
return txDetails, nil
|
||||
}
|
||||
|
||||
// FundPsbt creates a fully populated PSBT packet that contains enough
|
||||
// inputs to fund the outputs specified in the passed in packet with the
|
||||
// specified fee rate. If there is change left, a change output from the
|
||||
// internal wallet is added and the index of the change output is returned.
|
||||
// Otherwise no additional output is created and the index -1 is returned.
|
||||
//
|
||||
// NOTE: If the packet doesn't contain any inputs, coin selection is
|
||||
// performed automatically. If the packet 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.
|
||||
// No lock lease is acquired for any of the selected/validated inputs.
|
||||
// It is in the caller's responsibility to lock the inputs before
|
||||
// handing them out.
|
||||
//
|
||||
// This is a part of the WalletController interface.
|
||||
func (b *BtcWallet) FundPsbt(packet *psbt.Packet,
|
||||
feeRate chainfee.SatPerKWeight) (int32, error) {
|
||||
|
||||
// The fee rate is passed in using units of sat/kw, so we'll convert
|
||||
// this to sat/KB as the CreateSimpleTx method requires this unit.
|
||||
feeSatPerKB := btcutil.Amount(feeRate.FeePerKVByte())
|
||||
|
||||
// Let the wallet handle coin selection and/or fee estimation based on
|
||||
// the partial TX information in the packet.
|
||||
return b.wallet.FundPsbt(packet, defaultAccount, feeSatPerKB)
|
||||
}
|
||||
|
||||
// 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 after it's been
|
||||
// finalized successfully.
|
||||
//
|
||||
// This is a part of the WalletController interface.
|
||||
func (b *BtcWallet) FinalizePsbt(packet *psbt.Packet) error {
|
||||
return b.wallet.FinalizePsbt(packet)
|
||||
}
|
||||
|
||||
// txSubscriptionClient encapsulates the transaction notification client from
|
||||
// the base wallet. Notifications received from the client will be proxied over
|
||||
// two distinct channels.
|
||||
|
|
|
|||
|
|
@ -1,15 +1,12 @@
|
|||
package btcwallet
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/btcsuite/btcd/btcec"
|
||||
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
||||
"github.com/btcsuite/btcd/txscript"
|
||||
"github.com/btcsuite/btcd/wire"
|
||||
"github.com/btcsuite/btcutil"
|
||||
"github.com/btcsuite/btcwallet/waddrmgr"
|
||||
base "github.com/btcsuite/btcwallet/wallet"
|
||||
"github.com/btcsuite/btcwallet/walletdb"
|
||||
"github.com/go-errors/errors"
|
||||
"github.com/lightningnetwork/lnd/input"
|
||||
|
|
@ -24,82 +21,29 @@ import (
|
|||
//
|
||||
// This is a part of the WalletController interface.
|
||||
func (b *BtcWallet) FetchInputInfo(prevOut *wire.OutPoint) (*lnwallet.Utxo, error) {
|
||||
// We manually look up the output within the tx store.
|
||||
txid := &prevOut.Hash
|
||||
txDetail, err := base.UnstableAPI(b.wallet).TxDetails(txid)
|
||||
_, txOut, confirmations, err := b.wallet.FetchInputInfo(prevOut)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
} else if txDetail == nil {
|
||||
return nil, lnwallet.ErrNotMine
|
||||
}
|
||||
|
||||
// With the output retrieved, we'll make an additional check to ensure
|
||||
// we actually have control of this output. We do this because the check
|
||||
// above only guarantees that the transaction is somehow relevant to us,
|
||||
// like in the event of us being the sender of the transaction.
|
||||
numOutputs := uint32(len(txDetail.TxRecord.MsgTx.TxOut))
|
||||
if prevOut.Index >= numOutputs {
|
||||
return nil, fmt.Errorf("invalid output index %v for "+
|
||||
"transaction with %v outputs", prevOut.Index, numOutputs)
|
||||
}
|
||||
pkScript := txDetail.TxRecord.MsgTx.TxOut[prevOut.Index].PkScript
|
||||
if _, err := b.fetchOutputAddr(pkScript); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Then, we'll populate all of the information required by the struct.
|
||||
addressType := lnwallet.UnknownAddressType
|
||||
switch {
|
||||
case txscript.IsPayToWitnessPubKeyHash(pkScript):
|
||||
case txscript.IsPayToWitnessPubKeyHash(txOut.PkScript):
|
||||
addressType = lnwallet.WitnessPubKey
|
||||
case txscript.IsPayToScriptHash(pkScript):
|
||||
case txscript.IsPayToScriptHash(txOut.PkScript):
|
||||
addressType = lnwallet.NestedWitnessPubKey
|
||||
}
|
||||
|
||||
// Determine the number of confirmations the output currently has.
|
||||
_, currentHeight, err := b.GetBestBlock()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unable to retrieve current height: %v",
|
||||
err)
|
||||
}
|
||||
confs := int64(0)
|
||||
if txDetail.Block.Height != -1 {
|
||||
confs = int64(currentHeight - txDetail.Block.Height)
|
||||
}
|
||||
|
||||
return &lnwallet.Utxo{
|
||||
AddressType: addressType,
|
||||
Value: btcutil.Amount(
|
||||
txDetail.TxRecord.MsgTx.TxOut[prevOut.Index].Value,
|
||||
),
|
||||
PkScript: pkScript,
|
||||
Confirmations: confs,
|
||||
AddressType: addressType,
|
||||
Value: btcutil.Amount(txOut.Value),
|
||||
PkScript: txOut.PkScript,
|
||||
Confirmations: confirmations,
|
||||
OutPoint: *prevOut,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// fetchOutputAddr attempts to fetch the managed address corresponding to the
|
||||
// passed output script. This function is used to look up the proper key which
|
||||
// should be used to sign a specified input.
|
||||
func (b *BtcWallet) fetchOutputAddr(script []byte) (waddrmgr.ManagedAddress, error) {
|
||||
_, addrs, _, err := txscript.ExtractPkScriptAddrs(script, b.netParams)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// If the case of a multi-sig output, several address may be extracted.
|
||||
// Therefore, we simply select the key for the first address we know
|
||||
// of.
|
||||
for _, addr := range addrs {
|
||||
addr, err := b.wallet.AddressInfo(addr)
|
||||
if err == nil {
|
||||
return addr, nil
|
||||
}
|
||||
}
|
||||
|
||||
return nil, lnwallet.ErrNotMine
|
||||
}
|
||||
|
||||
// deriveFromKeyLoc attempts to derive a private key using a fully specified
|
||||
// KeyLocator.
|
||||
func deriveFromKeyLoc(scopedMgr *waddrmgr.ScopedKeyManager,
|
||||
|
|
@ -273,83 +217,26 @@ func (b *BtcWallet) SignOutputRaw(tx *wire.MsgTx,
|
|||
func (b *BtcWallet) ComputeInputScript(tx *wire.MsgTx,
|
||||
signDesc *input.SignDescriptor) (*input.Script, error) {
|
||||
|
||||
outputScript := signDesc.Output.PkScript
|
||||
walletAddr, err := b.fetchOutputAddr(outputScript)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
pka := walletAddr.(waddrmgr.ManagedPubKeyAddress)
|
||||
privKey, err := pka.PrivKey()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var witnessProgram []byte
|
||||
inputScript := &input.Script{}
|
||||
|
||||
switch {
|
||||
|
||||
// If we're spending p2wkh output nested within a p2sh output, then
|
||||
// we'll need to attach a sigScript in addition to witness data.
|
||||
case pka.AddrType() == waddrmgr.NestedWitnessPubKey:
|
||||
pubKey := privKey.PubKey()
|
||||
pubKeyHash := btcutil.Hash160(pubKey.SerializeCompressed())
|
||||
|
||||
// Next, we'll generate a valid sigScript that will allow us to
|
||||
// spend the p2sh output. The sigScript will contain only a
|
||||
// single push of the p2wkh witness program corresponding to
|
||||
// the matching public key of this address.
|
||||
p2wkhAddr, err := btcutil.NewAddressWitnessPubKeyHash(
|
||||
pubKeyHash, b.netParams,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
witnessProgram, err = txscript.PayToAddrScript(p2wkhAddr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
bldr := txscript.NewScriptBuilder()
|
||||
bldr.AddData(witnessProgram)
|
||||
sigScript, err := bldr.Script()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
inputScript.SigScript = sigScript
|
||||
|
||||
// Otherwise, this is a regular p2wkh output, so we include the
|
||||
// witness program itself as the subscript to generate the proper
|
||||
// sighash digest. As part of the new sighash digest algorithm, the
|
||||
// p2wkh witness program will be expanded into a regular p2kh
|
||||
// script.
|
||||
default:
|
||||
witnessProgram = outputScript
|
||||
}
|
||||
|
||||
// If a tweak (single or double) is specified, then we'll need to use
|
||||
// this tweak to derive the final private key to be used for signing
|
||||
// this output.
|
||||
privKey, err = maybeTweakPrivKey(signDesc, privKey)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
privKeyTweaker := func(k *btcec.PrivateKey) (*btcec.PrivateKey, error) {
|
||||
return maybeTweakPrivKey(signDesc, k)
|
||||
}
|
||||
|
||||
// Generate a valid witness stack for the input.
|
||||
// TODO(roasbeef): adhere to passed HashType
|
||||
witnessScript, err := txscript.WitnessSignature(tx, signDesc.SigHashes,
|
||||
signDesc.InputIndex, signDesc.Output.Value, witnessProgram,
|
||||
signDesc.HashType, privKey, true,
|
||||
// Let the wallet compute the input script now.
|
||||
witness, sigScript, err := b.wallet.ComputeInputScript(
|
||||
tx, signDesc.Output, signDesc.InputIndex, signDesc.SigHashes,
|
||||
signDesc.HashType, privKeyTweaker,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
inputScript.Witness = witnessScript
|
||||
|
||||
return inputScript, nil
|
||||
return &input.Script{
|
||||
Witness: witness,
|
||||
SigScript: sigScript,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// A compile time check to ensure that BtcWallet implements the Signer
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
package chanfunding
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/sha256"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
|
@ -226,7 +225,7 @@ func (i *PsbtIntent) Verify(packet *psbt.Packet) error {
|
|||
outputSum := int64(0)
|
||||
for _, out := range packet.UnsignedTx.TxOut {
|
||||
outputSum += out.Value
|
||||
if txOutsEqual(out, expectedOutput) {
|
||||
if psbt.TxOutsEqual(out, expectedOutput) {
|
||||
outputFound = true
|
||||
}
|
||||
}
|
||||
|
|
@ -241,7 +240,7 @@ func (i *PsbtIntent) Verify(packet *psbt.Packet) error {
|
|||
if len(packet.UnsignedTx.TxIn) == 0 {
|
||||
return fmt.Errorf("PSBT has no inputs")
|
||||
}
|
||||
sum, err := sumUtxoInputValues(packet)
|
||||
sum, err := psbt.SumUtxoInputValues(packet)
|
||||
if err != nil {
|
||||
return fmt.Errorf("error determining input sum: %v", err)
|
||||
}
|
||||
|
|
@ -305,11 +304,13 @@ func (i *PsbtIntent) FinalizeRawTX(rawTx *wire.MsgTx) error {
|
|||
if i.PendingPsbt == nil {
|
||||
return fmt.Errorf("PSBT was not verified first")
|
||||
}
|
||||
err := verifyOutputsEqual(rawTx.TxOut, i.PendingPsbt.UnsignedTx.TxOut)
|
||||
err := psbt.VerifyOutputsEqual(
|
||||
rawTx.TxOut, i.PendingPsbt.UnsignedTx.TxOut,
|
||||
)
|
||||
if err != nil {
|
||||
return fmt.Errorf("outputs differ from verified PSBT: %v", err)
|
||||
}
|
||||
err = verifyInputPrevOutpointsEqual(
|
||||
err = psbt.VerifyInputPrevOutpointsEqual(
|
||||
rawTx.TxIn, i.PendingPsbt.UnsignedTx.TxIn,
|
||||
)
|
||||
if err != nil {
|
||||
|
|
@ -472,82 +473,6 @@ func (p *PsbtAssembler) ShouldPublishFundingTx() bool {
|
|||
// ConditionalPublishAssembler interface.
|
||||
var _ ConditionalPublishAssembler = (*PsbtAssembler)(nil)
|
||||
|
||||
// sumUtxoInputValues tries to extract the sum of all inputs specified in the
|
||||
// UTXO fields of the PSBT. An error is returned if an input is specified that
|
||||
// does not contain any UTXO information.
|
||||
func sumUtxoInputValues(packet *psbt.Packet) (int64, error) {
|
||||
// We take the TX ins of the unsigned TX as the truth for how many
|
||||
// inputs there should be, as the fields in the extra data part of the
|
||||
// PSBT can be empty.
|
||||
if len(packet.UnsignedTx.TxIn) != len(packet.Inputs) {
|
||||
return 0, fmt.Errorf("TX input length doesn't match PSBT " +
|
||||
"input length")
|
||||
}
|
||||
inputSum := int64(0)
|
||||
for idx, in := range packet.Inputs {
|
||||
switch {
|
||||
case in.WitnessUtxo != nil:
|
||||
// Witness UTXOs only need to reference the TxOut.
|
||||
inputSum += in.WitnessUtxo.Value
|
||||
|
||||
case in.NonWitnessUtxo != nil:
|
||||
// Non-witness UTXOs reference to the whole transaction
|
||||
// the UTXO resides in.
|
||||
utxOuts := in.NonWitnessUtxo.TxOut
|
||||
txIn := packet.UnsignedTx.TxIn[idx]
|
||||
inputSum += utxOuts[txIn.PreviousOutPoint.Index].Value
|
||||
|
||||
default:
|
||||
return 0, fmt.Errorf("input %d has no UTXO information",
|
||||
idx)
|
||||
}
|
||||
}
|
||||
return inputSum, nil
|
||||
}
|
||||
|
||||
// txOutsEqual returns true if two transaction outputs are equal.
|
||||
func txOutsEqual(out1, out2 *wire.TxOut) bool {
|
||||
if out1 == nil || out2 == nil {
|
||||
return out1 == out2
|
||||
}
|
||||
return out1.Value == out2.Value &&
|
||||
bytes.Equal(out1.PkScript, out2.PkScript)
|
||||
}
|
||||
|
||||
// verifyOutputsEqual verifies that the two slices of transaction outputs are
|
||||
// deep equal to each other. We do the length check and manual loop to provide
|
||||
// better error messages to the user than just returning "not equal".
|
||||
func verifyOutputsEqual(outs1, outs2 []*wire.TxOut) error {
|
||||
if len(outs1) != len(outs2) {
|
||||
return fmt.Errorf("number of outputs are different")
|
||||
}
|
||||
for idx, out := range outs1 {
|
||||
// There is a byte slice in the output so we can't use the
|
||||
// equality operator.
|
||||
if !txOutsEqual(out, outs2[idx]) {
|
||||
return fmt.Errorf("output %d is different", idx)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// verifyInputPrevOutpointsEqual verifies that the previous outpoints of the
|
||||
// two slices of transaction inputs are deep equal to each other. We do the
|
||||
// length check and manual loop to provide better error messages to the user
|
||||
// than just returning "not equal".
|
||||
func verifyInputPrevOutpointsEqual(ins1, ins2 []*wire.TxIn) error {
|
||||
if len(ins1) != len(ins2) {
|
||||
return fmt.Errorf("number of inputs are different")
|
||||
}
|
||||
for idx, in := range ins1 {
|
||||
if in.PreviousOutPoint != ins2[idx].PreviousOutPoint {
|
||||
return fmt.Errorf("previous outpoint of input %d is "+
|
||||
"different", idx)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// verifyInputsSigned verifies that the given list of inputs is non-empty and
|
||||
// that all the inputs either contain a script signature or a witness stack.
|
||||
func verifyInputsSigned(ins []*wire.TxIn) error {
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import (
|
|||
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
||||
"github.com/btcsuite/btcd/wire"
|
||||
"github.com/btcsuite/btcutil"
|
||||
"github.com/btcsuite/btcutil/psbt"
|
||||
"github.com/btcsuite/btcwallet/wallet/txauthor"
|
||||
"github.com/btcsuite/btcwallet/wtxmgr"
|
||||
"github.com/lightningnetwork/lnd/input"
|
||||
|
|
@ -273,6 +274,37 @@ type WalletController interface {
|
|||
// is set. Labels must not be empty, and they are limited to 500 chars.
|
||||
LabelTransaction(hash chainhash.Hash, label string, overwrite bool) error
|
||||
|
||||
// FundPsbt creates a fully populated PSBT packet that contains enough
|
||||
// inputs to fund the outputs specified in the passed in packet with the
|
||||
// specified fee rate. If there is change left, a change output from the
|
||||
// internal wallet is added and the index of the change output is
|
||||
// returned. Otherwise no additional output is created and the index -1
|
||||
// is returned.
|
||||
//
|
||||
// NOTE: If the packet doesn't contain any inputs, coin selection is
|
||||
// performed automatically. If the packet 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.
|
||||
// No lock lease is acquired for any of the selected/validated inputs.
|
||||
// It is in the caller's responsibility to lock the inputs before
|
||||
// handing them out.
|
||||
FundPsbt(packet *psbt.Packet, feeRate chainfee.SatPerKWeight) (int32,
|
||||
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 after it's been
|
||||
// finalized successfully.
|
||||
FinalizePsbt(packet *psbt.Packet) error
|
||||
|
||||
// SubscribeTransactions returns a TransactionSubscription client which
|
||||
// is capable of receiving async notifications as new transactions
|
||||
// related to the wallet are seen within the network, or found in
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user