956fd08adb
Add a method that makes a deep copy of all fields and resets size/hash caches. Close #3288 Signed-off-by: Ekaterina Pavlova <ekt@morphbits.io>
104 lines
2.6 KiB
Go
104 lines
2.6 KiB
Go
package transaction
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"math/big"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/io"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
|
|
)
|
|
|
|
//go:generate stringer -type=WitnessAction -linecomment
|
|
|
|
// WitnessAction represents an action to perform in WitnessRule if
|
|
// WitnessCondition matches.
|
|
type WitnessAction byte
|
|
|
|
const (
|
|
// WitnessDeny rejects current witness if condition is met.
|
|
WitnessDeny WitnessAction = 0 // Deny
|
|
// WitnessAllow approves current witness if condition is met.
|
|
WitnessAllow WitnessAction = 1 // Allow
|
|
)
|
|
|
|
// WitnessRule represents a single rule for Rules witness scope.
|
|
type WitnessRule struct {
|
|
Action WitnessAction `json:"action"`
|
|
Condition WitnessCondition `json:"condition"`
|
|
}
|
|
|
|
type witnessRuleAux struct {
|
|
Action string `json:"action"`
|
|
Condition json.RawMessage `json:"condition"`
|
|
}
|
|
|
|
// EncodeBinary implements the Serializable interface.
|
|
func (w *WitnessRule) EncodeBinary(bw *io.BinWriter) {
|
|
bw.WriteB(byte(w.Action))
|
|
w.Condition.EncodeBinary(bw)
|
|
}
|
|
|
|
// DecodeBinary implements the Serializable interface.
|
|
func (w *WitnessRule) DecodeBinary(br *io.BinReader) {
|
|
w.Action = WitnessAction(br.ReadB())
|
|
if br.Err == nil && w.Action != WitnessDeny && w.Action != WitnessAllow {
|
|
br.Err = errors.New("unknown witness rule action")
|
|
return
|
|
}
|
|
w.Condition = DecodeBinaryCondition(br)
|
|
}
|
|
|
|
// UnmarshalJSON implements the json.Unmarshaler interface.
|
|
func (w *WitnessRule) MarshalJSON() ([]byte, error) {
|
|
cond, err := w.Condition.MarshalJSON()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
aux := &witnessRuleAux{
|
|
Action: w.Action.String(),
|
|
Condition: cond,
|
|
}
|
|
return json.Marshal(aux)
|
|
}
|
|
|
|
// UnmarshalJSON implements the json.Unmarshaler interface.
|
|
func (w *WitnessRule) UnmarshalJSON(data []byte) error {
|
|
aux := &witnessRuleAux{}
|
|
err := json.Unmarshal(data, aux)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var action WitnessAction
|
|
switch aux.Action {
|
|
case WitnessDeny.String():
|
|
action = WitnessDeny
|
|
case WitnessAllow.String():
|
|
action = WitnessAllow
|
|
default:
|
|
return errors.New("unknown witness rule action")
|
|
}
|
|
cond, err := UnmarshalConditionJSON(aux.Condition)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
w.Action = action
|
|
w.Condition = cond
|
|
return nil
|
|
}
|
|
|
|
// ToStackItem implements Convertible interface.
|
|
func (w *WitnessRule) ToStackItem() stackitem.Item {
|
|
return stackitem.NewArray([]stackitem.Item{
|
|
stackitem.NewBigInteger(big.NewInt(int64(w.Action))),
|
|
w.Condition.ToStackItem(),
|
|
})
|
|
}
|
|
|
|
// Copy creates a deep copy of the WitnessRule.
|
|
func (w *WitnessRule) Copy() *WitnessRule {
|
|
return &WitnessRule{
|
|
Action: w.Action,
|
|
Condition: w.Condition.Copy(),
|
|
}
|
|
}
|