mirror of
https://github.com/matrix-org/dendrite.git
synced 2026-01-16 18:43:10 -06:00
121 lines
3.5 KiB
Go
121 lines
3.5 KiB
Go
package zion
|
|
|
|
import (
|
|
_ "embed"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/ethclient"
|
|
"github.com/matrix-org/dendrite/authorization"
|
|
"github.com/matrix-org/dendrite/zion/contracts/localhost_space"
|
|
"github.com/matrix-org/dendrite/zion/contracts/localhost_space_factory"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
//go:embed contracts/localhost_space_factory/space-factory.json
|
|
var localhostSpaceFactoryJson []byte
|
|
|
|
type SpaceContractLocalhost struct {
|
|
ethClient *ethclient.Client
|
|
spaceFactory *localhost_space_factory.LocalhostSpaceFactory
|
|
spaces map[string]*localhost_space.LocalhostSpace
|
|
}
|
|
|
|
func NewSpaceContractLocalhost(ethClient *ethclient.Client) (*SpaceContractLocalhost, error) {
|
|
jsonAddress, err := loadSpaceFactoryAddress(localhostSpaceFactoryJson)
|
|
if err != nil {
|
|
log.Errorf("error parsing localhost space factory contract address %v. Error: %v", jsonAddress, err)
|
|
return nil, err
|
|
}
|
|
address := common.HexToAddress(jsonAddress.SpaceFactory)
|
|
spaceFactory, err := localhost_space_factory.NewLocalhostSpaceFactory(address, ethClient)
|
|
if err != nil {
|
|
log.Errorf("error fetching localhost space factory contract with address %v. Error: %v", jsonAddress, err)
|
|
return nil, err
|
|
}
|
|
// no errors.
|
|
var spaceContract = &SpaceContractLocalhost{
|
|
ethClient: ethClient,
|
|
spaceFactory: spaceFactory,
|
|
spaces: make(map[string]*localhost_space.LocalhostSpace),
|
|
}
|
|
return spaceContract, nil
|
|
}
|
|
|
|
func (za *SpaceContractLocalhost) IsEntitledToSpace(
|
|
spaceNetworkId string,
|
|
user common.Address,
|
|
permission authorization.Permission,
|
|
) (bool, error) {
|
|
// get the space and check if user is entitled.
|
|
space, err := za.getSpace(spaceNetworkId)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
isEntitled, err := space.IsEntitledToSpace(
|
|
nil,
|
|
user,
|
|
permission.String(),
|
|
)
|
|
return isEntitled, err
|
|
}
|
|
|
|
func (za *SpaceContractLocalhost) IsEntitledToChannel(
|
|
spaceNetworkId string,
|
|
channelNetworkId string,
|
|
user common.Address,
|
|
permission authorization.Permission,
|
|
) (bool, error) {
|
|
// get the space and check if user is entitled.
|
|
space, err := za.getSpace(spaceNetworkId)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
// channel entitlement check
|
|
isEntitled, err := space.IsEntitledToChannel(
|
|
nil,
|
|
channelNetworkId,
|
|
user,
|
|
permission.String(),
|
|
)
|
|
return isEntitled, err
|
|
}
|
|
|
|
func (za *SpaceContractLocalhost) IsSpaceDisabled(spaceNetworkId string) (bool, error) {
|
|
space, err := za.getSpace(spaceNetworkId)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
isDisabled, err := space.Disabled(nil)
|
|
return isDisabled, err
|
|
}
|
|
|
|
func (za *SpaceContractLocalhost) IsChannelDisabled(spaceNetworkId string, channelNetworkId string) (bool, error) {
|
|
space, err := za.getSpace(spaceNetworkId)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
channelIdHash := NetworkIdToHash(channelNetworkId)
|
|
channel, err := space.GetChannelByHash(nil, channelIdHash)
|
|
return channel.Disabled, err
|
|
}
|
|
|
|
func (za *SpaceContractLocalhost) getSpace(networkId string) (*localhost_space.LocalhostSpace, error) {
|
|
if za.spaces[networkId] == nil {
|
|
// convert the networkId to keccak256 spaceIdHash
|
|
spaceIdHash := NetworkIdToHash(networkId)
|
|
// then use the spaceFactory to fetch the space address
|
|
spaceAddress, err := za.spaceFactory.SpaceByHash(nil, spaceIdHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// cache the space for future use
|
|
space, err := localhost_space.NewLocalhostSpace(spaceAddress, za.ethClient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
za.spaces[networkId] = space
|
|
}
|
|
return za.spaces[networkId], nil
|
|
}
|