akovalenko/lnd.xprv
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

lnrpc/signrpc: add ComputeInputScript to the Signer sub-server

Browse Source 
In this commit, we add the ComputeInputScript which will allow callers
to obtain witnesses for all outputs under control of the wallet. This
allows external scripting of things like coin join, etc.
This commit is contained in:
Olaoluwa Osuntokun 2018-11-28 20:08:00 -08:00
parent a8ac3cfe7d
commit 6c201e435a
No known key found for this signature in database
GPG Key ID: CE58F7F8E20FD9A2
2 changed files with 171 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

173
lnrpc/signrpc/signer.pb.go
View File

@ -14,6 +14,8 @@ It has these top-level messages:
SignDescriptor
SignReq
SignResp
InputScript
InputScriptResp
*/
package signrpc
@ -345,6 +347,50 @@ func (m *SignResp) GetRawSigs() [][]byte {
return nil
}
type InputScript struct {
// / The serializes witness stack for the specified input.
Witness [][]byte `protobuf:"bytes,1,rep,name=witness,proto3" json:"witness,omitempty"`
// **
// The optional sig script for the specified witness that will only be set if
// the input specified is a nested p2sh witness program.
SigScript []byte `protobuf:"bytes,2,opt,name=sig_script,json=sigScript,proto3" json:"sig_script,omitempty"`
}
func (m *InputScript) Reset() { *m = InputScript{} }
func (m *InputScript) String() string { return proto.CompactTextString(m) }
func (*InputScript) ProtoMessage() {}
func (*InputScript) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
func (m *InputScript) GetWitness() [][]byte {
if m != nil {
return m.Witness
}
return nil
}
func (m *InputScript) GetSigScript() []byte {
if m != nil {
return m.SigScript
}
return nil
}
type InputScriptResp struct {
InputScripts []*InputScript `protobuf:"bytes,1,rep,name=input_scripts,json=inputScripts" json:"input_scripts,omitempty"`
}
func (m *InputScriptResp) Reset() { *m = InputScriptResp{} }
func (m *InputScriptResp) String() string { return proto.CompactTextString(m) }
func (*InputScriptResp) ProtoMessage() {}
func (*InputScriptResp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (m *InputScriptResp) GetInputScripts() []*InputScript {
if m != nil {
return m.InputScripts
}
return nil
}
func init() {
proto.RegisterType((*KeyLocator)(nil), "signrpc.KeyLocator")
proto.RegisterType((*KeyDescriptor)(nil), "signrpc.KeyDescriptor")
@ -352,6 +398,8 @@ func init() {
proto.RegisterType((*SignDescriptor)(nil), "signrpc.SignDescriptor")
proto.RegisterType((*SignReq)(nil), "signrpc.SignReq")
proto.RegisterType((*SignResp)(nil), "signrpc.SignResp")
proto.RegisterType((*InputScript)(nil), "signrpc.InputScript")
proto.RegisterType((*InputScriptResp)(nil), "signrpc.InputScriptResp")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -372,9 +420,21 @@ type SignerClient interface {
// signed with, and also any optional tweaks. The return value is a fixed
// 64-byte signature (the same format as we use on the wire in Lightning).
//
// If we're unable to sign using the specified keys, then an error will be
// If we are unable to sign using the specified keys, then an error will be
// returned.
SignOutputRaw(ctx context.Context, in *SignReq, opts ...grpc.CallOption) (*SignResp, error)
// *
// ComputeInputScript generates a complete InputIndex for the passed
// transaction with the signature as defined within the passed SignDescriptor.
// This method should be capable of generating the proper input script for
// both regular p2wkh output and p2wkh outputs nested within a regular p2sh
// output.
//
// Note that when using this method to sign inputs belonging to the wallet,
// the only items of the SignDescriptor that need to be populated are pkScript
// in the TxOut field, the value in that same field, and finally the input
// index.
ComputeInputScript(ctx context.Context, in *SignReq, opts ...grpc.CallOption) (*InputScriptResp, error)
}
type signerClient struct {
@ -394,6 +454,15 @@ func (c *signerClient) SignOutputRaw(ctx context.Context, in *SignReq, opts ...g
return out, nil
}
func (c *signerClient) ComputeInputScript(ctx context.Context, in *SignReq, opts ...grpc.CallOption) (*InputScriptResp, error) {
out := new(InputScriptResp)
err := grpc.Invoke(ctx, "/signrpc.Signer/ComputeInputScript", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Signer service
type SignerServer interface {
@ -404,9 +473,21 @@ type SignerServer interface {
// signed with, and also any optional tweaks. The return value is a fixed
// 64-byte signature (the same format as we use on the wire in Lightning).
//
// If we're unable to sign using the specified keys, then an error will be
// If we are unable to sign using the specified keys, then an error will be
// returned.
SignOutputRaw(context.Context, *SignReq) (*SignResp, error)
// *
// ComputeInputScript generates a complete InputIndex for the passed
// transaction with the signature as defined within the passed SignDescriptor.
// This method should be capable of generating the proper input script for
// both regular p2wkh output and p2wkh outputs nested within a regular p2sh
// output.
//
// Note that when using this method to sign inputs belonging to the wallet,
// the only items of the SignDescriptor that need to be populated are pkScript
// in the TxOut field, the value in that same field, and finally the input
// index.
ComputeInputScript(context.Context, *SignReq) (*InputScriptResp, error)
}
func RegisterSignerServer(s *grpc.Server, srv SignerServer) {
@ -431,6 +512,24 @@ func _Signer_SignOutputRaw_Handler(srv interface{}, ctx context.Context, dec fun
return interceptor(ctx, in, info, handler)
}
func _Signer_ComputeInputScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SignReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SignerServer).ComputeInputScript(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/signrpc.Signer/ComputeInputScript",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SignerServer).ComputeInputScript(ctx, req.(*SignReq))
}
return interceptor(ctx, in, info, handler)
}
var _Signer_serviceDesc = grpc.ServiceDesc{
ServiceName: "signrpc.Signer",
HandlerType: (*SignerServer)(nil),
@ -439,6 +538,10 @@ var _Signer_serviceDesc = grpc.ServiceDesc{
MethodName: "SignOutputRaw",
Handler: _Signer_SignOutputRaw_Handler,
},
{
MethodName: "ComputeInputScript",
Handler: _Signer_ComputeInputScript_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "signrpc/signer.proto",
@ -447,35 +550,39 @@ var _Signer_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("signrpc/signer.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 465 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x92, 0x41, 0x8f, 0xd3, 0x3e,
0x10, 0xc5, 0xb7, 0xcd, 0x3f, 0x4d, 0x76, 0x92, 0x54, 0x7f, 0xcc, 0x0a, 0x02, 0x08, 0x51, 0x22,
0x16, 0xf5, 0x54, 0x44, 0x41, 0x1c, 0x38, 0x70, 0x58, 0x21, 0x54, 0x54, 0xa4, 0x95, 0xdc, 0xde,
0x23, 0x37, 0x35, 0x59, 0x2b, 0x21, 0xc9, 0xc6, 0x0e, 0xa9, 0x3f, 0x07, 0x5f, 0x18, 0x8d, 0x9d,
0xed, 0x76, 0x39, 0xb5, 0xef, 0x79, 0x32, 0xf3, 0xf3, 0x3c, 0xc3, 0x85, 0x14, 0x79, 0xd5, 0x36,
0xd9, 0x3b, 0xfc, 0xe5, 0xed, 0xa2, 0x69, 0x6b, 0x55, 0x13, 0x6f, 0x70, 0x93, 0x15, 0xc0, 0x9a,
0xeb, 0x1f, 0x75, 0xc6, 0x54, 0xdd, 0x92, 0x97, 0x00, 0x05, 0xd7, 0xe9, 0x4f, 0xf6, 0x4b, 0x94,
0x3a, 0x1e, 0xcd, 0x46, 0x73, 0x97, 0x9e, 0x17, 0x5c, 0x7f, 0x33, 0x06, 0x79, 0x01, 0x28, 0x52,
0x51, 0xed, 0xf9, 0x21, 0x1e, 0x9b, 0x53, 0xbf, 0xe0, 0xfa, 0x3b, 0xea, 0xa4, 0x84, 0x68, 0xcd,
0xf5, 0x57, 0x2e, 0xb3, 0x56, 0x34, 0xd8, 0xec, 0x0d, 0x44, 0x2d, 0xeb, 0x53, 0xfc, 0x62, 0xa7,
0x15, 0x97, 0xa6, 0x5f, 0xb8, 0x3a, 0xa3, 0x41, 0xcb, 0xfa, 0x35, 0xd7, 0x57, 0x68, 0x92, 0x05,
0x78, 0x58, 0x51, 0xd6, 0x99, 0xe9, 0x18, 0x2c, 0x1f, 0x2f, 0x06, 0xb6, 0xc5, 0x3d, 0xd8, 0xea,
0x8c, 0x4e, 0x0a, 0xa3, 0xae, 0x5c, 0x70, 0x0a, 0xae, 0x93, 0xcf, 0xe0, 0x6e, 0x0f, 0xd7, 0x9d,
0x22, 0x17, 0xe0, 0xfe, 0x66, 0x65, 0xc7, 0x4d, 0x77, 0x87, 0x5a, 0x81, 0xa4, 0x4d, 0x91, 0x5a,
0x14, 0xd3, 0x37, 0xa4, 0x7e, 0x53, 0x6c, 0x8c, 0x4e, 0xfe, 0x8c, 0x61, 0xba, 0x11, 0x79, 0x75,
0xc2, 0xfa, 0x1e, 0xf0, 0x22, 0xe9, 0x9e, 0xcb, 0xcc, 0x34, 0x0a, 0x96, 0x4f, 0x4e, 0x31, 0xee,
0x2b, 0x29, 0xd2, 0xa2, 0x24, 0xaf, 0x21, 0x94, 0xa2, 0xca, 0x4b, 0x9e, 0xaa, 0x9e, 0xb3, 0x62,
0x98, 0x12, 0x58, 0x6f, 0x8b, 0x16, 0x96, 0xec, 0xeb, 0x6e, 0x77, 0x2c, 0x71, 0x6c, 0x89, 0xf5,
0x6c, 0xc9, 0x25, 0x4c, 0x7b, 0xa1, 0x2a, 0x2e, 0xe5, 0x1d, 0xed, 0x7f, 0xa6, 0x28, 0x1a, 0x5c,
0x8b, 0x4c, 0xde, 0xc2, 0xa4, 0xee, 0x54, 0xd3, 0xa9, 0xd8, 0x35, 0x74, 0xd3, 0x23, 0x9d, 0xd9,
0x02, 0x1d, 0x4e, 0x49, 0x0c, 0x98, 0xec, 0x0d, 0x93, 0x37, 0xb1, 0x37, 0x1b, 0xcd, 0x23, 0x7a,
0x27, 0xc9, 0x2b, 0x08, 0x44, 0xd5, 0x74, 0x6a, 0x48, 0xcf, 0x37, 0xe9, 0x81, 0xb1, 0x6c, 0x7e,
0x19, 0x78, 0xb8, 0x14, 0xca, 0x6f, 0xc9, 0x0c, 0x42, 0x4c, 0x4e, 0x1d, 0x4e, 0x83, 0xa3, 0xd0,
0xb2, 0x7e, 0x7b, 0xb0, 0xa9, 0x7d, 0x02, 0x40, 0x00, 0xb3, 0x30, 0x19, 0x8f, 0x67, 0xce, 0x3c,
0x58, 0x3e, 0x3d, 0x32, 0x3d, 0x5c, 0x2e, 0x3d, 0x97, 0x83, 0x96, 0xc9, 0x25, 0xf8, 0x76, 0x88,
0x6c, 0xc8, 0x33, 0xf0, 0x71, 0x8a, 0x14, 0x39, 0x4e, 0x70, 0xe6, 0x21, 0xf5, 0x5a, 0xd6, 0x6f,
0x44, 0x2e, 0x97, 0x5f, 0x60, 0xb2, 0x31, 0xcf, 0x95, 0x7c, 0x84, 0x08, 0xff, 0x5d, 0x9b, 0xeb,
0x51, 0xd6, 0x93, 0xff, 0x1f, 0x4c, 0xa1, 0xfc, 0xf6, 0xf9, 0xa3, 0x7f, 0x1c, 0xd9, 0xec, 0x26,
0xe6, 0x95, 0x7f, 0xf8, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xd0, 0x6b, 0x86, 0xc5, 0xfd, 0x02, 0x00,
0x00,
// 536 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x93, 0xd1, 0x8f, 0xd2, 0x40,
0x10, 0xc6, 0x0f, 0x10, 0xca, 0x4d, 0x5b, 0xd4, 0x95, 0x68, 0xd5, 0x18, 0xb1, 0xf1, 0x0c, 0x4f,
0x18, 0xd1, 0x98, 0xe8, 0x93, 0x39, 0xcd, 0x85, 0x0b, 0x97, 0x5c, 0xb2, 0xf0, 0xde, 0x94, 0xb2,
0xf6, 0x36, 0xe5, 0xda, 0x5e, 0x77, 0x6b, 0xe9, 0x9b, 0xff, 0x83, 0xff, 0xb0, 0x99, 0xdd, 0x05,
0x8a, 0xde, 0x13, 0x7c, 0x5f, 0x67, 0x67, 0x7e, 0x3b, 0x5f, 0x0b, 0x43, 0xc1, 0xe3, 0xb4, 0xc8,
0xa3, 0xf7, 0xf8, 0xcb, 0x8a, 0x49, 0x5e, 0x64, 0x32, 0x23, 0x96, 0x71, 0xfd, 0x19, 0xc0, 0x9c,
0xd5, 0x57, 0x59, 0x14, 0xca, 0xac, 0x20, 0xaf, 0x00, 0x12, 0x56, 0x07, 0x3f, 0xc3, 0x5b, 0xbe,
0xa9, 0xbd, 0xd6, 0xa8, 0x35, 0xee, 0xd2, 0xd3, 0x84, 0xd5, 0x17, 0xca, 0x20, 0x2f, 0x01, 0x45,
0xc0, 0xd3, 0x35, 0xdb, 0x7a, 0x6d, 0xf5, 0xb4, 0x9f, 0xb0, 0xfa, 0x12, 0xb5, 0xbf, 0x01, 0x77,
0xce, 0xea, 0x1f, 0x4c, 0x44, 0x05, 0xcf, 0xb1, 0xd9, 0x5b, 0x70, 0x8b, 0xb0, 0x0a, 0xf0, 0xc4,
0xaa, 0x96, 0x4c, 0xa8, 0x7e, 0xce, 0xec, 0x84, 0xda, 0x45, 0x58, 0xcd, 0x59, 0x7d, 0x8e, 0x26,
0x99, 0x80, 0x85, 0x15, 0x9b, 0x2c, 0x52, 0x1d, 0xed, 0xe9, 0x93, 0x89, 0x61, 0x9b, 0x1c, 0xc0,
0x66, 0x27, 0xb4, 0x97, 0x28, 0x75, 0xde, 0x85, 0x4e, 0xc2, 0x6a, 0xff, 0x2b, 0x74, 0x97, 0xdb,
0xeb, 0x52, 0x92, 0x21, 0x74, 0x7f, 0x85, 0x9b, 0x92, 0xa9, 0xee, 0x1d, 0xaa, 0x05, 0x92, 0xe6,
0x49, 0xa0, 0x51, 0x54, 0x5f, 0x87, 0xf6, 0xf3, 0x64, 0xa1, 0xb4, 0xff, 0xa7, 0x0d, 0x83, 0x05,
0x8f, 0xd3, 0x06, 0xeb, 0x07, 0xc0, 0x8b, 0x04, 0x6b, 0x26, 0x22, 0xd5, 0xc8, 0x9e, 0x3e, 0x6d,
0x62, 0x1c, 0x2a, 0x29, 0xd2, 0xa2, 0x24, 0x6f, 0xc0, 0x11, 0x3c, 0x8d, 0x37, 0x2c, 0x90, 0x15,
0x0b, 0x13, 0x33, 0xc5, 0xd6, 0xde, 0x12, 0x2d, 0x2c, 0x59, 0x67, 0xe5, 0x6a, 0x5f, 0xd2, 0xd1,
0x25, 0xda, 0xd3, 0x25, 0x67, 0x30, 0xa8, 0xb8, 0x4c, 0x99, 0x10, 0x3b, 0xda, 0x07, 0xaa, 0xc8,
0x35, 0xae, 0x46, 0x26, 0xef, 0xa0, 0x97, 0x95, 0x32, 0x2f, 0xa5, 0xd7, 0x55, 0x74, 0x83, 0x3d,
0x9d, 0xda, 0x02, 0x35, 0x4f, 0x89, 0x07, 0x98, 0xec, 0x4d, 0x28, 0x6e, 0x3c, 0x6b, 0xd4, 0x1a,
0xbb, 0x74, 0x27, 0xc9, 0x6b, 0xb0, 0x79, 0x9a, 0x97, 0xd2, 0xa4, 0xd7, 0x57, 0xe9, 0x81, 0xb2,
0x74, 0x7e, 0x11, 0x58, 0xb8, 0x14, 0xca, 0xee, 0xc8, 0x08, 0x1c, 0x4c, 0x4e, 0x6e, 0x9b, 0xc1,
0x51, 0x28, 0xc2, 0x6a, 0xb9, 0xd5, 0xa9, 0x7d, 0x06, 0x40, 0x00, 0xb5, 0x30, 0xe1, 0xb5, 0x47,
0x9d, 0xb1, 0x3d, 0x7d, 0xb6, 0x67, 0x3a, 0x5e, 0x2e, 0x3d, 0x15, 0x46, 0x0b, 0xff, 0x0c, 0xfa,
0x7a, 0x88, 0xc8, 0xc9, 0x73, 0xe8, 0xe3, 0x14, 0xc1, 0x63, 0x9c, 0xd0, 0x19, 0x3b, 0xd4, 0x2a,
0xc2, 0x6a, 0xc1, 0x63, 0xe1, 0x5f, 0x80, 0x7d, 0x89, 0x64, 0xe6, 0xf6, 0x1e, 0x58, 0x66, 0x1d,
0xbb, 0x42, 0x23, 0xf1, 0x85, 0x15, 0x3c, 0x3e, 0x0e, 0x1a, 0xc7, 0x99, 0xa4, 0xaf, 0xe0, 0x61,
0xa3, 0x8f, 0x9a, 0xfa, 0x05, 0x5c, 0xbd, 0x07, 0x7d, 0x46, 0x77, 0xb4, 0xa7, 0xc3, 0x3d, 0x7c,
0xf3, 0x80, 0xc3, 0x0f, 0x42, 0x4c, 0x7f, 0xb7, 0xa0, 0xb7, 0x50, 0x5f, 0x11, 0xf9, 0x04, 0x2e,
0xfe, 0xbb, 0x56, 0x5b, 0xa7, 0x61, 0x45, 0x1e, 0x1d, 0x5d, 0x9e, 0xb2, 0xbb, 0x17, 0x8f, 0xff,
0x71, 0x44, 0x4e, 0xbe, 0x01, 0xf9, 0x9e, 0xdd, 0xe6, 0xa5, 0x64, 0xcd, 0xdb, 0xfd, 0x7f, 0xd4,
0xbb, 0x17, 0x86, 0x89, 0x7c, 0xd5, 0x53, 0x9f, 0xef, 0xc7, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff,
0x7b, 0x48, 0x93, 0x2a, 0xd6, 0x03, 0x00, 0x00,
}

32
lnrpc/signrpc/signer.proto
View File

@ -103,6 +103,22 @@ message SignResp {
repeated bytes raw_sigs = 1;
}
message InputScript {
/// The serializes witness stack for the specified input.
repeated bytes witness = 1;
/***
The optional sig script for the specified witness that will only be set if
the input specified is a nested p2sh witness program.
*/
bytes sig_script = 2;
}
message InputScriptResp {
/// The set of fully valid input scripts requested.
repeated InputScript input_scripts = 1;
}
service Signer {
/**
SignOutputRaw is a method that can be used to generated a signature for a
@ -111,8 +127,22 @@ service Signer {
signed with, and also any optional tweaks. The return value is a fixed
64-byte signature (the same format as we use on the wire in Lightning).
If we're unable to sign using the specified keys, then an error will be
If we are unable to sign using the specified keys, then an error will be
returned.
*/
rpc SignOutputRaw(SignReq) returns (SignResp);
/**
ComputeInputScript generates a complete InputIndex for the passed
transaction with the signature as defined within the passed SignDescriptor.
This method should be capable of generating the proper input script for
both regular p2wkh output and p2wkh outputs nested within a regular p2sh
output.
Note that when using this method to sign inputs belonging to the wallet,
the only items of the SignDescriptor that need to be populated are pkScript
in the TxOut field, the value in that same field, and finally the input
index.
*/
rpc ComputeInputScript(SignReq) returns (InputScriptResp);
}