forked from TrueCloudLab/neoneo-go
92 lines
2.8 KiB
Go
92 lines
2.8 KiB
Go
package client
|
|
|
|
// Various non-policy things from native contracts.
|
|
|
|
import (
|
|
"crypto/elliptic"
|
|
"fmt"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/native/noderoles"
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
|
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
|
|
)
|
|
|
|
// GetOraclePrice invokes `getPrice` method on a native Oracle contract.
|
|
func (c *Client) GetOraclePrice() (int64, error) {
|
|
oracleHash, err := c.GetNativeContractHash(nativenames.Notary)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to get native Oracle hash: %w", err)
|
|
}
|
|
return c.invokeNativeGetMethod(oracleHash, "getPrice")
|
|
}
|
|
|
|
// GetNNSPrice invokes `getPrice` method on a native NameService contract.
|
|
func (c *Client) GetNNSPrice() (int64, error) {
|
|
nnsHash, err := c.GetNativeContractHash(nativenames.NameService)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to get native NameService hash: %w", err)
|
|
}
|
|
return c.invokeNativeGetMethod(nnsHash, "getPrice")
|
|
}
|
|
|
|
// GetGasPerBlock invokes `getGasPerBlock` method on a native NEO contract.
|
|
func (c *Client) GetGasPerBlock() (int64, error) {
|
|
neoHash, err := c.GetNativeContractHash(nativenames.Neo)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to get native NEO hash: %w", err)
|
|
}
|
|
return c.invokeNativeGetMethod(neoHash, "getGasPerBlock")
|
|
}
|
|
|
|
// GetDesignatedByRole invokes `getDesignatedByRole` method on a native RoleManagement contract.
|
|
func (c *Client) GetDesignatedByRole(role noderoles.Role, index uint32) (keys.PublicKeys, error) {
|
|
rmHash, err := c.GetNativeContractHash(nativenames.Designation)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get native RoleManagement hash: %w", err)
|
|
}
|
|
result, err := c.InvokeFunction(rmHash, "getDesignatedByRole", []smartcontract.Parameter{
|
|
{
|
|
Type: smartcontract.IntegerType,
|
|
Value: int64(role),
|
|
},
|
|
{
|
|
Type: smartcontract.IntegerType,
|
|
Value: int64(index),
|
|
},
|
|
}, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = getInvocationError(result)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("`getDesignatedByRole`: %w", err)
|
|
}
|
|
return topPublicKeysFromStack(result.Stack)
|
|
}
|
|
|
|
// topPublicKeysFromStack returns the top array of public keys from stack.
|
|
func topPublicKeysFromStack(st []stackitem.Item) (keys.PublicKeys, error) {
|
|
index := len(st) - 1 // top stack element is last in the array
|
|
var (
|
|
pks keys.PublicKeys
|
|
err error
|
|
)
|
|
items, ok := st[index].Value().([]stackitem.Item)
|
|
if !ok {
|
|
return nil, fmt.Errorf("invalid stack item type: %s", st[index].Type())
|
|
}
|
|
pks = make(keys.PublicKeys, len(items))
|
|
for i, item := range items {
|
|
val, ok := item.Value().([]byte)
|
|
if !ok {
|
|
return nil, fmt.Errorf("invalid array element #%d: %s", i, item.Type())
|
|
}
|
|
pks[i], err = keys.NewPublicKeyFromBytes(val, elliptic.P256())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return pks, nil
|
|
}
|