[#54] morph: Introduce ContractStorageReader

* Implement MorphRuleChainStorageReader interface to make
  possible to read from Policy contract without wallets.

Signed-off-by: Airat Arifullin <aarifullin@yadro.com>
This commit is contained in:
aarifullin 2024-02-26 18:30:31 +03:00 committed by Evgenii Stratonikov
parent 9e66ce59c6
commit cf1f091e26
2 changed files with 48 additions and 4 deletions

View file

@ -6,18 +6,18 @@ import (
) )
type defaultChainRouter struct { type defaultChainRouter struct {
morph MorphRuleChainStorage morph MorphRuleChainStorageReader
local LocalOverrideStorage local LocalOverrideStorage
} }
func NewDefaultChainRouter(morph MorphRuleChainStorage) ChainRouter { func NewDefaultChainRouter(morph MorphRuleChainStorageReader) ChainRouter {
return &defaultChainRouter{ return &defaultChainRouter{
morph: morph, morph: morph,
} }
} }
func NewDefaultChainRouterWithLocalOverrides(morph MorphRuleChainStorage, local LocalOverrideStorage) ChainRouter { func NewDefaultChainRouterWithLocalOverrides(morph MorphRuleChainStorageReader, local LocalOverrideStorage) ChainRouter {
return &defaultChainRouter{ return &defaultChainRouter{
morph: morph, morph: morph,
local: local, local: local,

View file

@ -22,13 +22,20 @@ var (
ErrEngineTargetTypeUnsupported = errors.New("this target type is not supported yet") ErrEngineTargetTypeUnsupported = errors.New("this target type is not supported yet")
) )
// ContractStorage is the interface to manage chain rules within the policy contract. // ContractStorage is the interface to manage chain rules within Policy contract.
type ContractStorage struct { type ContractStorage struct {
contractInterface *client.Contract contractInterface *client.Contract
} }
var _ engine.MorphRuleChainStorage = (*ContractStorage)(nil) var _ engine.MorphRuleChainStorage = (*ContractStorage)(nil)
// ContractStorageReader is the interface to read data from Policy contract.
type ContractStorageReader struct {
contractReaderInterface *client.ContractReader
}
var _ engine.MorphRuleChainStorageReader = (*ContractStorageReader)(nil)
func NewContractStorage(actor client.Actor, contract util.Uint160) *ContractStorage { func NewContractStorage(actor client.Actor, contract util.Uint160) *ContractStorage {
return &ContractStorage{ return &ContractStorage{
contractInterface: client.New(actor, contract), contractInterface: client.New(actor, contract),
@ -112,6 +119,43 @@ func (s *ContractStorage) SetAdmin(addr util.Uint160) (util.Uint256, uint32, err
return s.contractInterface.SetAdmin(addr) return s.contractInterface.SetAdmin(addr)
} }
func NewContractStorageReader(inv client.Invoker, contract util.Uint160) *ContractStorageReader {
return &ContractStorageReader{
contractReaderInterface: client.NewReader(inv, contract),
}
}
func (s *ContractStorageReader) ListMorphRuleChains(name chain.Name, target engine.Target) ([]*chain.Chain, error) {
kind, err := policyKind(target.Type)
if err != nil {
return nil, err
}
items, err := s.contractReaderInterface.ListChainsByPrefix(big.NewInt(int64(kind)), target.Name, []byte(name))
if err != nil {
return nil, err
}
var chains []*chain.Chain
for _, item := range items {
serialized, err := bytesFromStackItem(item)
if err != nil {
return nil, err
}
c := new(chain.Chain)
if err := c.DecodeBytes(serialized); err != nil {
return nil, err
}
chains = append(chains, c)
}
return chains, nil
}
func (s *ContractStorageReader) GetAdmin() (util.Uint160, error) {
return s.contractReaderInterface.GetAdmin()
}
func bytesFromStackItem(param stackitem.Item) ([]byte, error) { func bytesFromStackItem(param stackitem.Item) ([]byte, error) {
switch param.Type() { switch param.Type() {
case stackitem.BufferT, stackitem.ByteArrayT, stackitem.IntegerT: case stackitem.BufferT, stackitem.ByteArrayT, stackitem.IntegerT: