aarifullin/neoneo-go
1
0
Fork 0
forked from TrueCloudLab/neoneo-go
Code Pull requests Activity

util: add LE suffix to Uint160 methods

Browse source
This commit is contained in:
Evgenii Stratonikov 2019-11-27 12:20:31 +03:00
parent 5d2fb41991
commit 57efad912c
28 changed files with 88 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
cli/smartcontract/smart_contract.go
View file

@ -585,6 +585,6 @@ func contractDeploy(ctx *cli.Context) error {
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to push invocation tx: %v", err), 1)
}
fmt.Printf("Sent deployment transaction %s for contract %s\n", txHash.ReverseString(), hash.Hash160(avm).ReverseString())
fmt.Printf("Sent deployment transaction %s for contract %s\n", txHash.ReverseString(), hash.Hash160(avm).StringLE())
return nil
}

2
pkg/compiler/codegen.go
View file

@ -670,7 +670,7 @@ func (c *codegen) convertBuiltin(expr *ast.CallExpr) {
c.prog.Err = err
return
}
bytes := uint160.Bytes()
bytes := uint160.BytesBE()
emitBytes(c.prog.BinWriter, bytes)
}
}

4
pkg/core/account_state.go
View file

@ -35,7 +35,7 @@ func (a Accounts) getAndUpdate(s storage.Store, hash util.Uint160) (*AccountStat
// present there. Returns nil otherwise.
func getAccountStateFromStore(s storage.Store, hash util.Uint160) (*AccountState, error) {
var account *AccountState
key := storage.AppendPrefix(storage.STAccount, hash.Bytes())
key := storage.AppendPrefix(storage.STAccount, hash.BytesBE())
b, err := s.Get(key)
if err == nil {
account = new(AccountState)
@ -55,7 +55,7 @@ func putAccountStateIntoStore(store storage.Store, as *AccountState) error {
if buf.Err != nil {
return buf.Err
}
key := storage.AppendPrefix(storage.STAccount, as.ScriptHash.Bytes())
key := storage.AppendPrefix(storage.STAccount, as.ScriptHash.BytesBE())
return store.Put(key, buf.Bytes())
}

8
pkg/core/blockchain.go
View file

@ -602,7 +602,7 @@ func processValidatorStateDescriptor(descriptor *transaction.StateDescriptor, st
}
func processAccountStateDescriptor(descriptor *transaction.StateDescriptor, state *BlockChainState) error {
hash, err := util.Uint160DecodeBytes(descriptor.Key)
hash, err := util.Uint160DecodeBytesBE(descriptor.Key)
if err != nil {
return err
}
@ -744,7 +744,7 @@ func (bc *Blockchain) GetStorageItems(hash util.Uint160) (map[string]*StorageIte
// Cut prefix and hash.
siMap[string(k[21:])] = si
}
bc.store.Seek(storage.AppendPrefix(storage.STStorage, hash.BytesReverse()), saveToMap)
bc.store.Seek(storage.AppendPrefix(storage.STStorage, hash.BytesLE()), saveToMap)
if err != nil {
return nil, err
}
@ -893,7 +893,7 @@ func (bc *Blockchain) GetContractState(hash util.Uint160) *ContractState {
// getContractStateFromStore returns contract state as recorded in the given
// store by the given script hash.
func getContractStateFromStore(s storage.Store, hash util.Uint160) *ContractState {
key := storage.AppendPrefix(storage.STContract, hash.Bytes())
key := storage.AppendPrefix(storage.STContract, hash.BytesBE())
contractBytes, err := s.Get(key)
if err != nil {
return nil
@ -1366,7 +1366,7 @@ func (bc *Blockchain) GetScriptHashesForVerifying(t *transaction.Transaction) ([
}
for _, a := range t.Attributes {
if a.Usage == transaction.Script {
h, err := util.Uint160DecodeBytes(a.Data)
h, err := util.Uint160DecodeBytesBE(a.Data)
if err != nil {
return nil, err
}

4
pkg/core/contract_state.go
View file

@ -70,13 +70,13 @@ func putContractStateIntoStore(s storage.Store, cs *ContractState) error {
if buf.Err != nil {
return buf.Err
}
key := storage.AppendPrefix(storage.STContract, cs.ScriptHash().Bytes())
key := storage.AppendPrefix(storage.STContract, cs.ScriptHash().BytesBE())
return s.Put(key, buf.Bytes())
}
// deleteContractStateInStore deletes given contract state in the given store.
func deleteContractStateInStore(s storage.Store, hash util.Uint160) error {
key := storage.AppendPrefix(storage.STContract, hash.Bytes())
key := storage.AppendPrefix(storage.STContract, hash.BytesBE())
return s.Delete(key)
}

18
pkg/core/interop_neo.go
View file

@ -74,7 +74,7 @@ func (ic *interopContext) headerGetNextConsensus(v *vm.VM) error {
if err != nil {
return err
}
v.Estack().PushVal(header.NextConsensus.BytesReverse())
v.Estack().PushVal(header.NextConsensus.BytesLE())
return nil
}
@ -271,7 +271,7 @@ func (ic *interopContext) outputGetScriptHash(v *vm.VM) error {
if err != nil {
return err
}
v.Estack().PushVal(output.ScriptHash.Bytes())
v.Estack().PushVal(output.ScriptHash.BytesBE())
return nil
}
@ -310,7 +310,7 @@ func (ic *interopContext) attrGetUsage(v *vm.VM) error {
// bcGetAccount returns or creates an account.
func (ic *interopContext) bcGetAccount(v *vm.VM) error {
accbytes := v.Estack().Pop().Bytes()
acchash, err := util.Uint160DecodeBytes(accbytes)
acchash, err := util.Uint160DecodeBytesBE(accbytes)
if err != nil {
return err
}
@ -364,7 +364,7 @@ func (ic *interopContext) accountGetScriptHash(v *vm.VM) error {
if !ok {
return fmt.Errorf("%T is not an account state", acc)
}
v.Estack().PushVal(acc.ScriptHash.Bytes())
v.Estack().PushVal(acc.ScriptHash.BytesBE())
return nil
}
@ -389,7 +389,7 @@ func (ic *interopContext) accountGetVotes(v *vm.VM) error {
// accountIsStandard checks whether given account is standard.
func (ic *interopContext) accountIsStandard(v *vm.VM) error {
accbytes := v.Estack().Pop().Bytes()
acchash, err := util.Uint160DecodeBytes(accbytes)
acchash, err := util.Uint160DecodeBytesBE(accbytes)
if err != nil {
return err
}
@ -601,11 +601,11 @@ func (ic *interopContext) assetCreate(v *vm.VM) error {
if !witnessOk {
return errors.New("witness check didn't succeed")
}
admin, err := util.Uint160DecodeBytes(v.Estack().Pop().Bytes())
admin, err := util.Uint160DecodeBytesBE(v.Estack().Pop().Bytes())
if err != nil {
return gherr.Wrap(err, "failed to get admin")
}
issuer, err := util.Uint160DecodeBytes(v.Estack().Pop().Bytes())
issuer, err := util.Uint160DecodeBytesBE(v.Estack().Pop().Bytes())
if err != nil {
return gherr.Wrap(err, "failed to get issuer")
}
@ -635,7 +635,7 @@ func (ic *interopContext) assetGetAdmin(v *vm.VM) error {
if !ok {
return fmt.Errorf("%T is not an asset state", as)
}
v.Estack().PushVal(as.Admin.Bytes())
v.Estack().PushVal(as.Admin.BytesBE())
return nil
}
@ -690,7 +690,7 @@ func (ic *interopContext) assetGetIssuer(v *vm.VM) error {
if !ok {
return fmt.Errorf("%T is not an asset state", as)
}
v.Estack().PushVal(as.Issuer.Bytes())
v.Estack().PushVal(as.Issuer.BytesBE())
return nil
}

12
pkg/core/interop_neo_test.go
View file

@ -74,7 +74,7 @@ func TestHeaderGetNextConsensus(t *testing.T) {
err := context.headerGetNextConsensus(v)
require.NoError(t, err)
value := v.Estack().Pop().Value()
require.Equal(t, block.NextConsensus.BytesReverse(), value)
require.Equal(t, block.NextConsensus.BytesLE(), value)
}
func TestTxGetAttributes(t *testing.T) {
@ -168,7 +168,7 @@ func TestOutputGetScriptHash(t *testing.T) {
err := context.outputGetScriptHash(v)
require.NoError(t, err)
scriptHash := v.Estack().Pop().Value()
require.Equal(t, tx.Outputs[0].ScriptHash.Bytes(), scriptHash)
require.Equal(t, tx.Outputs[0].ScriptHash.BytesBE(), scriptHash)
}
func TestOutputGetValue(t *testing.T) {
@ -208,7 +208,7 @@ func TestAccountGetScriptHash(t *testing.T) {
err := context.accountGetScriptHash(v)
require.NoError(t, err)
hash := v.Estack().Pop().Value()
require.Equal(t, accState.ScriptHash.Bytes(), hash)
require.Equal(t, accState.ScriptHash.BytesBE(), hash)
}
func TestAccountGetVotes(t *testing.T) {
@ -248,7 +248,7 @@ func TestAssetGetAdmin(t *testing.T) {
err := context.assetGetAdmin(v)
require.NoError(t, err)
admin := v.Estack().Pop().Value()
require.Equal(t, assetState.Admin.Bytes(), admin)
require.Equal(t, assetState.Admin.BytesBE(), admin)
}
func TestAssetGetAmount(t *testing.T) {
@ -298,7 +298,7 @@ func TestAssetGetIssuer(t *testing.T) {
err := context.assetGetIssuer(v)
require.NoError(t, err)
issuer := v.Estack().Pop().Value()
require.Equal(t, assetState.Issuer.Bytes(), issuer)
require.Equal(t, assetState.Issuer.BytesBE(), issuer)
}
func TestAssetGetOwner(t *testing.T) {
@ -381,7 +381,7 @@ func createVMAndContractState(t *testing.T) (*vm.VM, *ContractState, *interopCon
func createVMAndAccState(t *testing.T) (*vm.VM, *AccountState, *interopContext) {
v := vm.New()
rawHash := "4d3b96ae1bcc5a585e075e3b81920210dec16302"
hash, err := util.Uint160DecodeString(rawHash)
hash, err := util.Uint160DecodeStringBE(rawHash)
accountState := NewAccountState(hash)
key := &keys.PublicKey{X: big.NewInt(1), Y: big.NewInt(1)}

6
pkg/core/interop_system.go
View file

@ -63,7 +63,7 @@ func (ic *interopContext) bcGetBlock(v *vm.VM) error {
// bcGetContract returns contract.
func (ic *interopContext) bcGetContract(v *vm.VM) error {
hashbytes := v.Estack().Pop().Bytes()
hash, err := util.Uint160DecodeBytes(hashbytes)
hash, err := util.Uint160DecodeBytesBE(hashbytes)
if err != nil {
return err
}
@ -260,7 +260,7 @@ func getContextScriptHash(v *vm.VM, n int) util.Uint160 {
// invocation stack element number n.
func pushContextScriptHash(v *vm.VM, n int) error {
h := getContextScriptHash(v, n)
v.Estack().PushVal(h.Bytes())
v.Estack().PushVal(h.BytesBE())
return nil
}
@ -318,7 +318,7 @@ func (ic *interopContext) runtimeCheckWitness(v *vm.VM) error {
var err error
hashOrKey := v.Estack().Pop().Bytes()
hash, err := util.Uint160DecodeBytes(hashOrKey)
hash, err := util.Uint160DecodeBytesBE(hashOrKey)
if err != nil {
key := &keys.PublicKey{}
err = key.DecodeBytes(hashOrKey)

2
pkg/core/storage_item.go
View file

@ -14,7 +14,7 @@ type StorageItem struct {
// makeStorageItemKey returns a key used to store StorageItem in the DB.
func makeStorageItemKey(scripthash util.Uint160, key []byte) []byte {
return storage.AppendPrefix(storage.STStorage, append(scripthash.BytesReverse(), key...))
return storage.AppendPrefix(storage.STStorage, append(scripthash.BytesLE(), key...))
}
// getStorageItemFromStore returns StorageItem if it exists in the given Store.

2
pkg/core/storage_item_test.go
View file

@ -14,7 +14,7 @@ func TestPutGetDeleteStorageItem(t *testing.T) {
Value: []byte("smth"),
}
key := []byte("key")
cHash, err := util.Uint160DecodeBytes([]byte("abcdefghijklmnopqrst"))
cHash, err := util.Uint160DecodeBytesBE([]byte("abcdefghijklmnopqrst"))
assert.Nil(t, err)
assert.NoError(t, putStorageItemIntoStore(s, cHash, key, si))
siRead := getStorageItemFromStore(s, cHash, key)

2
pkg/core/transaction/register_test.go
View file

@ -12,7 +12,7 @@ import (
)
func TestRegisterTX(t *testing.T) {
someuint160, _ := util.Uint160DecodeString("4d3b96ae1bcc5a585e075e3b81920210dec16302")
someuint160, _ := util.Uint160DecodeStringBE("4d3b96ae1bcc5a585e075e3b81920210dec16302")
tx := &Transaction{
Type: RegisterType,
Version: 0,

4
pkg/crypto/address.go
View file

@ -8,7 +8,7 @@ import (
// Uint160.
func AddressFromUint160(u util.Uint160) string {
// Dont forget to prepend the Address version 0x17 (23) A
b := append([]byte{0x17}, u.Bytes()...)
b := append([]byte{0x17}, u.BytesBE()...)
return Base58CheckEncode(b)
}
@ -19,5 +19,5 @@ func Uint160DecodeAddress(s string) (u util.Uint160, err error) {
if err != nil {
return u, err
}
return util.Uint160DecodeBytes(b[1:21])
return util.Uint160DecodeBytesBE(b[1:21])
}

2
pkg/crypto/address_test.go
View file

@ -29,6 +29,6 @@ func TestUint160DecodeKnownAddress(t *testing.T) {
t.Fatal(err)
}
assert.Equal(t, "b28427088a3729b2536d10122960394e8be6721f", val.ReverseString())
assert.Equal(t, "b28427088a3729b2536d10122960394e8be6721f", val.StringLE())
assert.Equal(t, "1f72e68b4e39602912106d53b229378a082784b2", val.String())
}

4
pkg/crypto/hash/hash.go
View file

@ -30,7 +30,7 @@ func RipeMD160(data []byte) util.Uint160 {
hasher := ripemd160.New()
_, _ = hasher.Write(data)
hash, _ = util.Uint160DecodeBytes(hasher.Sum(nil))
hash, _ = util.Uint160DecodeBytesBE(hasher.Sum(nil))
return hash
}
@ -41,7 +41,7 @@ func Hash160(data []byte) util.Uint160 {
h1 := Sha256(data)
h2 := RipeMD160(h1.Bytes())
hash, _ = util.Uint160DecodeBytes(h2.Bytes())
hash, _ = util.Uint160DecodeBytesBE(h2.BytesBE())
return hash
}

4
pkg/crypto/hash/hash_test.go
View file

@ -36,7 +36,7 @@ func TestHashRipeMD160(t *testing.T) {
data := RipeMD160(input)
expected := "108f07b8382412612c048d07d13f814118445acd"
actual := hex.EncodeToString(data.Bytes())
actual := hex.EncodeToString(data.BytesBE())
assert.Equal(t, expected, actual)
}
@ -46,7 +46,7 @@ func TestHash160(t *testing.T) {
data := Hash160(publicKeyBytes)
expected := "c8e2b685cc70ec96743b55beb9449782f8f775d8"
actual := hex.EncodeToString(data.Bytes())
actual := hex.EncodeToString(data.BytesBE())
assert.Equal(t, expected, actual)
}

2
pkg/crypto/keys/publickey.go
View file

@ -237,7 +237,7 @@ func (p *PublicKey) GetVerificationScript() []byte {
func (p *PublicKey) Signature() []byte {
sig := hash.Hash160(p.GetVerificationScript())
return sig.Bytes()
return sig.BytesBE()
}
// Address returns a base58-encoded NEO-specific address based on the key hash.

4
pkg/rpc/param.go
View file

@ -85,11 +85,11 @@ func (p Param) GetUint160FromHex() (util.Uint160, error) {
return util.Uint160{}, err
}
scriptHashLE, err := util.Uint160DecodeString(s)
scriptHashLE, err := util.Uint160DecodeStringBE(s)
if err != nil {
return util.Uint160{}, err
}
return util.Uint160DecodeBytes(scriptHashLE.BytesReverse())
return util.Uint160DecodeBytesBE(scriptHashLE.BytesLE())
}
// GetUint160FromAddress returns Uint160 value of the parameter that was

4
pkg/rpc/param_test.go
View file

@ -112,8 +112,8 @@ func TestParamGetUint256(t *testing.T) {
func TestParamGetUint160FromHex(t *testing.T) {
in := "50befd26fdf6e4d957c11e078b24ebce6291456f"
u160, _ := util.Uint160DecodeString(in)
u160, _ = util.Uint160DecodeBytes(util.ArrayReverse(u160[:]))
u160, _ := util.Uint160DecodeStringBE(in)
u160, _ = util.Uint160DecodeBytesBE(util.ArrayReverse(u160[:]))
p := Param{stringT, in}
u, err := p.GetUint160FromHex()
assert.Equal(t, u160, u)

2
pkg/rpc/stack_param.go
View file

@ -236,7 +236,7 @@ func (p StackParam) TryParse(dest interface{}) error {
}
switch dest := dest.(type) {
case *util.Uint160:
if *dest, err = util.Uint160DecodeBytes(data); err != nil {
if *dest, err = util.Uint160DecodeBytesBE(data); err != nil {
return err
}
return nil

4
pkg/rpc/stack_param_test.go
View file

@ -157,11 +157,11 @@ func TestStackParam_TryParse(t *testing.T) {
params := StackParams{
{
Type: ByteArray,
Value: exp1.Bytes(),
Value: exp1.BytesBE(),
},
{
Type: ByteArray,
Value: exp2.Bytes(),
Value: exp2.BytesBE(),
},
}

4
pkg/rpc/txBuilder.go
View file

@ -41,7 +41,7 @@ func CreateRawContractTransaction(params ContractTxParams) (*transaction.Transac
tx.Attributes = append(tx.Attributes,
&transaction.Attribute{
Usage: transaction.Script,
Data: fromAddressHash.Bytes(),
Data: fromAddressHash.BytesBE(),
})
if err = AddInputsAndUnspentsToTx(tx, fromAddress, assetID, amount, balancer); err != nil {
@ -194,7 +194,7 @@ func expandArrayIntoScript(script *bytes.Buffer, slice []Param) error {
if err != nil {
return err
}
if err := vm.EmitBytes(script, hash.Bytes()); err != nil {
if err := vm.EmitBytes(script, hash.BytesBE()); err != nil {
return err
}
case Hash256:

2
pkg/rpc/wrappers/account_state.go
View file

@ -45,7 +45,7 @@ func NewAccountState(a *core.AccountState) AccountState {
sort.Sort(balances)
// reverse scriptHash to be consistent with other client
scriptHash, err := util.Uint160DecodeBytes(a.ScriptHash.BytesReverse())
scriptHash, err := util.Uint160DecodeBytesBE(a.ScriptHash.BytesLE())
if err != nil {
scriptHash = a.ScriptHash
}

2
pkg/smartcontract/param_context.go
View file

@ -158,7 +158,7 @@ func adjustValToType(typ ParamType, val string) (interface{}, error) {
case Hash160Type:
u, err := crypto.Uint160DecodeAddress(val)
if err == nil {
return hex.EncodeToString(u.Bytes()), nil
return hex.EncodeToString(u.BytesBE()), nil
}
b, err := hex.DecodeString(val)
if err != nil {

35
pkg/util/uint160.go
View file

@ -12,8 +12,8 @@ const uint160Size = 20
// Uint160 is a 20 byte long unsigned integer.
type Uint160 [uint160Size]uint8
// Uint160DecodeString attempts to decode the given string into an Uint160.
func Uint160DecodeString(s string) (Uint160, error) {
// Uint160DecodeStringBE attempts to decode the given string into an Uint160.
func Uint160DecodeStringBE(s string) (Uint160, error) {
var u Uint160
if len(s) != uint160Size*2 {
return u, fmt.Errorf("expected string size of %d got %d", uint160Size*2, len(s))
@ -22,11 +22,11 @@ func Uint160DecodeString(s string) (Uint160, error) {
if err != nil {
return u, err
}
return Uint160DecodeBytes(b)
return Uint160DecodeBytesBE(b)
}
// Uint160DecodeBytes attempts to decode the given bytes into an Uint160.
func Uint160DecodeBytes(b []byte) (u Uint160, err error) {
// Uint160DecodeBytesBE attempts to decode the given bytes into an Uint160.
func Uint160DecodeBytesBE(b []byte) (u Uint160, err error) {
if len(b) != uint160Size {
return u, fmt.Errorf("expected byte size of %d got %d", uint160Size, len(b))
}
@ -34,24 +34,29 @@ func Uint160DecodeBytes(b []byte) (u Uint160, err error) {
return
}
// Bytes returns the byte slice representation of u.
func (u Uint160) Bytes() []byte {
// BytesBE returns a big-endian byte representation of u.
func (u Uint160) BytesBE() []byte {
return u[:]
}
// BytesReverse returns a reversed byte representation of u.
func (u Uint160) BytesReverse() []byte {
return ArrayReverse(u.Bytes())
// BytesLE returns a little-endian byte representation of u.
func (u Uint160) BytesLE() []byte {
return ArrayReverse(u.BytesBE())
}
// String implements the stringer interface.
func (u Uint160) String() string {
return hex.EncodeToString(u.Bytes())
return u.StringBE()
}
// ReverseString is the same as String, but returns a reversed representation.
func (u Uint160) ReverseString() string {
return hex.EncodeToString(u.BytesReverse())
// StringBE returns string representations of u with big-endian byte order.
func (u Uint160) StringBE() string {
return hex.EncodeToString(u.BytesBE())
}
// StringLE returns string representations of u with little-endian byte order.
func (u Uint160) StringLE() string {
return hex.EncodeToString(u.BytesLE())
}
// Equals returns true if both Uint256 values are the same.
@ -78,7 +83,7 @@ func (u *Uint160) UnmarshalJSON(data []byte) (err error) {
return err
}
js = strings.TrimPrefix(js, "0x")
*u, err = Uint160DecodeString(js)
*u, err = Uint160DecodeStringBE(js)
return err
}

26
pkg/util/uint160_test.go
View file

@ -10,7 +10,7 @@ import (
func TestUint160UnmarshalJSON(t *testing.T) {
str := "2d3b96ae1bcc5a585e075e3b81920210dec16302"
expected, err := Uint160DecodeString(str)
expected, err := Uint160DecodeStringBE(str)
assert.NoError(t, err)
// UnmarshalJSON decodes hex-strings
@ -31,15 +31,15 @@ func TestUint160UnmarshalJSON(t *testing.T) {
func TestUInt160DecodeString(t *testing.T) {
hexStr := "2d3b96ae1bcc5a585e075e3b81920210dec16302"
val, err := Uint160DecodeString(hexStr)
val, err := Uint160DecodeStringBE(hexStr)
assert.NoError(t, err)
assert.Equal(t, hexStr, val.String())
_, err = Uint160DecodeString(hexStr[1:])
_, err = Uint160DecodeStringBE(hexStr[1:])
assert.Error(t, err)
hexStr = "zz3b96ae1bcc5a585e075e3b81920210dec16302"
_, err = Uint160DecodeString(hexStr)
_, err = Uint160DecodeStringBE(hexStr)
assert.Error(t, err)
}
@ -48,11 +48,11 @@ func TestUint160DecodeBytes(t *testing.T) {
b, err := hex.DecodeString(hexStr)
require.NoError(t, err)
val, err := Uint160DecodeBytes(b)
val, err := Uint160DecodeBytesBE(b)
assert.NoError(t, err)
assert.Equal(t, hexStr, val.String())
_, err = Uint160DecodeBytes(b[1:])
_, err = Uint160DecodeBytesBE(b[1:])
assert.Error(t, err)
}
@ -60,10 +60,10 @@ func TestUInt160Equals(t *testing.T) {
a := "2d3b96ae1bcc5a585e075e3b81920210dec16302"
b := "4d3b96ae1bcc5a585e075e3b81920210dec16302"
ua, err := Uint160DecodeString(a)
ua, err := Uint160DecodeStringBE(a)
require.NoError(t, err)
ub, err := Uint160DecodeString(b)
ub, err := Uint160DecodeStringBE(b)
require.NoError(t, err)
assert.False(t, ua.Equals(ub), "%s and %s cannot be equal", ua, ub)
assert.True(t, ua.Equals(ua), "%s and %s must be equal", ua, ua)
@ -73,11 +73,11 @@ func TestUInt160Less(t *testing.T) {
a := "2d3b96ae1bcc5a585e075e3b81920210dec16302"
b := "2d3b96ae1bcc5a585e075e3b81920210dec16303"
ua, err := Uint160DecodeString(a)
ua, err := Uint160DecodeStringBE(a)
assert.Nil(t, err)
ua2, err := Uint160DecodeString(a)
ua2, err := Uint160DecodeStringBE(a)
assert.Nil(t, err)
ub, err := Uint160DecodeString(b)
ub, err := Uint160DecodeStringBE(b)
assert.Nil(t, err)
assert.Equal(t, true, ua.Less(ub))
assert.Equal(t, false, ua.Less(ua2))
@ -88,9 +88,9 @@ func TestUInt160String(t *testing.T) {
hexStr := "b28427088a3729b2536d10122960394e8be6721f"
hexRevStr := "1f72e68b4e39602912106d53b229378a082784b2"
val, err := Uint160DecodeString(hexStr)
val, err := Uint160DecodeStringBE(hexStr)
assert.Nil(t, err)
assert.Equal(t, hexStr, val.String())
assert.Equal(t, hexRevStr, val.ReverseString())
assert.Equal(t, hexRevStr, val.StringLE())
}

2
pkg/vm/emit.go
View file

@ -118,7 +118,7 @@ func EmitAppCall(w *bytes.Buffer, scriptHash util.Uint160, tailCall bool) error
if tailCall {
op = opcode.TAILCALL
}
return Emit(w, op, scriptHash.Bytes())
return Emit(w, op, scriptHash.BytesBE())
}
// EmitAppCallWithOperationAndData emits an appcall with the given operation and data.

6
pkg/vm/vm.go
View file

@ -1112,7 +1112,7 @@ func (v *VM) execute(ctx *Context, op opcode.Opcode, parameter []byte) (err erro
v.checkInvocationStackSize()
}
hash, err := util.Uint160DecodeBytes(parameter)
hash, err := util.Uint160DecodeBytesBE(parameter)
if err != nil {
panic(err)
}
@ -1296,7 +1296,7 @@ func (v *VM) execute(ctx *Context, op opcode.Opcode, parameter []byte) (err erro
case opcode.HASH160:
b := v.estack.Pop().Bytes()
v.estack.PushVal(hash.Hash160(b).Bytes())
v.estack.PushVal(hash.Hash160(b).BytesBE())
case opcode.HASH256:
b := v.estack.Pop().Bytes()
@ -1341,7 +1341,7 @@ func (v *VM) execute(ctx *Context, op opcode.Opcode, parameter []byte) (err erro
hashBytes = parameter[2:]
}
hash, err := util.Uint160DecodeBytes(hashBytes)
hash, err := util.Uint160DecodeBytesBE(hashBytes)
if err != nil {
panic(err)
}

2
pkg/vm/vm_test.go
View file

@ -1403,7 +1403,7 @@ func TestSIGNByteArray(t *testing.T) {
func TestAppCall(t *testing.T) {
prog := []byte{byte(opcode.APPCALL)}
hash := util.Uint160{}
prog = append(prog, hash.Bytes()...)
prog = append(prog, hash.BytesBE()...)
prog = append(prog, byte(opcode.RET))
vm := load(prog)