-
Notifications
You must be signed in to change notification settings - Fork 0
/
reducedtransaction.go
107 lines (88 loc) · 2.95 KB
/
reducedtransaction.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package ergo
/*
#include "ergo.h"
*/
import "C"
import (
"runtime"
"unsafe"
)
// ReducedTransaction represents reduced transaction, i.e. unsigned transaction where each unsigned input
// is augmented with ReducedInput which contains a script reduction result.
// After an unsigned transaction is reduced it can be signed without context.
// Thus, it can be serialized and transferred for example to Cold Wallet and signed
// in an environment where secrets are known.
// see EIP-19 for more details -
// https://github.com/ergoplatform/eips/blob/f280890a4163f2f2e988a0091c078e36912fc531/eip-0019.md
type ReducedTransaction interface {
// UnsignedTransaction returns the UnsignedTransaction
UnsignedTransaction() UnsignedTransaction
pointer() C.ReducedTransactionPtr
}
type reducedTransaction struct {
p C.ReducedTransactionPtr
}
func newReducedTransaction(r *reducedTransaction) ReducedTransaction {
runtime.SetFinalizer(r, finalizeReducedTransaction)
return r
}
// NewReducedTransaction creates a ReducedTransaction i.e unsigned transaction where each unsigned input
// is augmented with ReducedInput which contains a script reduction result
func NewReducedTransaction(unsignedTx UnsignedTransaction, boxesToSpent Boxes, dataBoxes Boxes, stateContext StateContext) (ReducedTransaction, error) {
var p C.ReducedTransactionPtr
errPtr := C.ergo_lib_reduced_tx_from_unsigned_tx(unsignedTx.pointer(), boxesToSpent.pointer(), dataBoxes.pointer(), stateContext.pointer(), &p)
err := newError(errPtr)
if err.isError() {
return nil, err.error()
}
r := &reducedTransaction{p: p}
return newReducedTransaction(r), nil
}
func (r *reducedTransaction) UnsignedTransaction() UnsignedTransaction {
var p C.UnsignedTransactionPtr
C.ergo_lib_reduced_tx_unsigned_tx(r.p, &p)
ut := &unsignedTransaction{p: p}
return newUnsignedTransaction(ut)
}
func (r *reducedTransaction) pointer() C.ReducedTransactionPtr {
return r.p
}
func finalizeReducedTransaction(r *reducedTransaction) {
C.ergo_lib_reduced_tx_delete(r.p)
}
// Propositions list(public keys)
type Propositions interface {
// Add adds new proposition
Add(bytes []byte) error
pointer() C.PropositionsPtr
}
type propositions struct {
p C.PropositionsPtr
}
func newPropositions(p *propositions) Propositions {
runtime.SetFinalizer(p, finalizePropositions)
return p
}
// NewPropositions creates empty proposition holder
func NewPropositions() Propositions {
var p C.PropositionsPtr
C.ergo_lib_propositions_new(&p)
prop := &propositions{p: p}
return newPropositions(prop)
}
func (p *propositions) Add(bytes []byte) error {
byteData := C.CBytes(bytes)
defer C.free(unsafe.Pointer(byteData))
errPtr := C.ergo_lib_propositions_add_proposition_from_bytes(p.p, (*C.uchar)(byteData), C.uintptr_t(len(bytes)))
err := newError(errPtr)
if err.isError() {
return err.error()
}
return nil
}
func (p *propositions) pointer() C.PropositionsPtr {
return p.p
}
func finalizePropositions(p *propositions) {
C.ergo_lib_propositions_delete(p.p)
}