628 lines
20 KiB
Go
628 lines
20 KiB
Go
package morph
|
|
|
|
import (
|
|
"archive/tar"
|
|
"compress/gzip"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/native"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/state"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/transaction"
|
|
io2 "github.com/nspcc-dev/neo-go/pkg/io"
|
|
"github.com/nspcc-dev/neo-go/pkg/rpc/client"
|
|
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
|
|
"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
|
|
"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
|
|
"github.com/nspcc-dev/neo-go/pkg/smartcontract/nef"
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/emit"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
|
|
"github.com/nspcc-dev/neofs-node/pkg/innerring"
|
|
morphClient "github.com/nspcc-dev/neofs-node/pkg/morph/client"
|
|
"github.com/spf13/viper"
|
|
)
|
|
|
|
const (
|
|
nnsContract = "nns"
|
|
neofsContract = "neofs" // not deployed in side-chain.
|
|
processingContract = "processing" // not deployed in side-chain.
|
|
alphabetContract = "alphabet"
|
|
auditContract = "audit"
|
|
balanceContract = "balance"
|
|
containerContract = "container"
|
|
neofsIDContract = "neofsid"
|
|
netmapContract = "netmap"
|
|
proxyContract = "proxy"
|
|
reputationContract = "reputation"
|
|
subnetContract = "subnet"
|
|
)
|
|
|
|
const (
|
|
netmapEpochKey = "EpochDuration"
|
|
netmapMaxObjectSizeKey = "MaxObjectSize"
|
|
netmapAuditFeeKey = "AuditFee"
|
|
netmapContainerFeeKey = "ContainerFee"
|
|
netmapContainerAliasFeeKey = "ContainerAliasFee"
|
|
netmapEigenTrustIterationsKey = "EigenTrustIterations"
|
|
netmapEigenTrustAlphaKey = "EigenTrustAlpha"
|
|
netmapBasicIncomeRateKey = "BasicIncomeRate"
|
|
netmapInnerRingCandidateFeeKey = "InnerRingCandidateFee"
|
|
netmapWithdrawFeeKey = "WithdrawFee"
|
|
|
|
defaultEigenTrustIterations = 4
|
|
defaultEigenTrustAlpha = "0.1"
|
|
)
|
|
|
|
var (
|
|
contractList = []string{
|
|
auditContract,
|
|
balanceContract,
|
|
containerContract,
|
|
neofsIDContract,
|
|
netmapContract,
|
|
proxyContract,
|
|
reputationContract,
|
|
subnetContract,
|
|
}
|
|
|
|
fullContractList = append([]string{
|
|
neofsContract,
|
|
processingContract,
|
|
nnsContract,
|
|
alphabetContract,
|
|
}, contractList...)
|
|
)
|
|
|
|
type contractState struct {
|
|
NEF *nef.File
|
|
RawNEF []byte
|
|
Manifest *manifest.Manifest
|
|
RawManifest []byte
|
|
Hash util.Uint160
|
|
}
|
|
|
|
const (
|
|
updateMethodName = "update"
|
|
deployMethodName = "deploy"
|
|
)
|
|
|
|
func (c *initializeContext) deployNNS(method string) error {
|
|
cs := c.getContract(nnsContract)
|
|
h := cs.Hash
|
|
|
|
nnsCs, err := c.nnsContractState()
|
|
if err == nil {
|
|
if nnsCs.NEF.Checksum == cs.NEF.Checksum {
|
|
c.Command.Println("NNS contract is already deployed.")
|
|
return nil
|
|
}
|
|
h = nnsCs.Hash
|
|
}
|
|
|
|
err = c.addManifestGroup(h, cs)
|
|
if err != nil {
|
|
return fmt.Errorf("can't sign manifest group: %v", err)
|
|
}
|
|
|
|
params := getContractDeployParameters(cs.RawNEF, cs.RawManifest, nil)
|
|
|
|
signer := transaction.Signer{
|
|
Account: c.CommitteeAcc.Contract.ScriptHash(),
|
|
Scopes: transaction.CalledByEntry,
|
|
}
|
|
|
|
mgmtHash := c.nativeHash(nativenames.Management)
|
|
if method == updateMethodName {
|
|
mgmtHash = nnsCs.Hash
|
|
}
|
|
|
|
res, err := c.Client.InvokeFunction(mgmtHash, method, params, []transaction.Signer{signer})
|
|
if err != nil {
|
|
return fmt.Errorf("can't deploy NNS contract: %w", err)
|
|
}
|
|
if res.State != vm.HaltState.String() {
|
|
return fmt.Errorf("can't deploy NNS contract: %s", res.FaultException)
|
|
}
|
|
|
|
tx, err := c.Client.CreateTxFromScript(res.Script, c.CommitteeAcc, res.GasConsumed, 0, []client.SignerAccount{{
|
|
Signer: signer,
|
|
Account: c.CommitteeAcc,
|
|
}})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create deploy tx for %s: %w", nnsContract, err)
|
|
}
|
|
|
|
if err := c.multiSignAndSend(tx, committeeAccountName); err != nil {
|
|
return fmt.Errorf("can't send deploy transaction: %w", err)
|
|
}
|
|
|
|
return c.awaitTx()
|
|
}
|
|
|
|
func (c *initializeContext) updateContracts() error {
|
|
mgmtHash := c.nativeHash(nativenames.Management)
|
|
alphaCs := c.getContract(alphabetContract)
|
|
|
|
nnsCs, err := c.nnsContractState()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
nnsHash := nnsCs.Hash
|
|
|
|
totalGasCost := int64(0)
|
|
w := io2.NewBufBinWriter()
|
|
|
|
var keysParam []smartcontract.Parameter
|
|
|
|
// Update script size for a single-node committee is close to the maximum allowed size of 65535.
|
|
// Because of this we want to reuse alphabet contract NEF and manifest for different updates.
|
|
// The generated script is as following.
|
|
// 1. Initialize static slots for alphabet NEF and manifest.
|
|
// 2. Store NEF and manifest into static slots.
|
|
// 3. Push parameters for each alphabet contract on stack.
|
|
// 4. For each alphabet contract, invoke `update` using parameters on stack and
|
|
// NEF and manifest from step 2.
|
|
// 5. Update other contracts as usual.
|
|
emit.Instruction(w.BinWriter, opcode.INITSSLOT, []byte{2})
|
|
emit.Bytes(w.BinWriter, alphaCs.RawManifest)
|
|
emit.Bytes(w.BinWriter, alphaCs.RawNEF)
|
|
emit.Opcodes(w.BinWriter, opcode.STSFLD0, opcode.STSFLD1)
|
|
|
|
// alphabet contracts should be deployed by individual nodes to get different hashes.
|
|
for i, acc := range c.Accounts {
|
|
ctrHash, err := nnsResolveHash(c.Client, nnsHash, getAlphabetNNSDomain(i))
|
|
if err != nil {
|
|
return fmt.Errorf("can't resolve hash for contract update: %w", err)
|
|
}
|
|
|
|
keysParam = append(keysParam, smartcontract.Parameter{
|
|
Type: smartcontract.PublicKeyType,
|
|
Value: acc.PrivateKey().PublicKey().Bytes(),
|
|
})
|
|
|
|
params := c.getAlphabetDeployItems(i, len(c.Wallets))
|
|
emit.Array(w.BinWriter, params...)
|
|
emit.Opcodes(w.BinWriter, opcode.LDSFLD1, opcode.LDSFLD0)
|
|
emit.Int(w.BinWriter, 3)
|
|
emit.Opcodes(w.BinWriter, opcode.PACK)
|
|
emit.AppCallNoArgs(w.BinWriter, ctrHash, updateMethodName, callflag.All)
|
|
}
|
|
|
|
res, err := c.Client.InvokeScript(w.Bytes(), []transaction.Signer{{
|
|
Account: c.CommitteeAcc.Contract.ScriptHash(),
|
|
Scopes: transaction.Global,
|
|
}})
|
|
if err != nil {
|
|
return fmt.Errorf("can't update alphabet contracts: %w", err)
|
|
}
|
|
if res.State != vm.HaltState.String() {
|
|
return fmt.Errorf("can't update alphabet contracts: %s", res.FaultException)
|
|
}
|
|
|
|
w.Reset()
|
|
totalGasCost += res.GasConsumed
|
|
w.WriteBytes(res.Script)
|
|
|
|
for _, ctrName := range contractList {
|
|
cs := c.getContract(ctrName)
|
|
|
|
method := updateMethodName
|
|
ctrHash, err := nnsResolveHash(c.Client, nnsHash, ctrName+".neofs")
|
|
if err != nil {
|
|
if errors.Is(err, errMissingNNSRecord) {
|
|
// if contract not found we deploy it instead of update
|
|
method = deployMethodName
|
|
} else {
|
|
return fmt.Errorf("can't resolve hash for contract update: %w", err)
|
|
}
|
|
}
|
|
|
|
err = c.addManifestGroup(ctrHash, alphaCs)
|
|
if err != nil {
|
|
return fmt.Errorf("can't sign manifest group: %v", err)
|
|
}
|
|
|
|
invokeHash := mgmtHash
|
|
if method == updateMethodName {
|
|
invokeHash = ctrHash
|
|
}
|
|
|
|
params := getContractDeployParameters(cs.RawNEF, cs.RawManifest,
|
|
c.getContractDeployData(ctrName, keysParam))
|
|
signer := transaction.Signer{
|
|
Account: c.CommitteeAcc.Contract.ScriptHash(),
|
|
Scopes: transaction.Global,
|
|
}
|
|
|
|
res, err := c.Client.InvokeFunction(invokeHash, method, params, []transaction.Signer{signer})
|
|
if err != nil {
|
|
return fmt.Errorf("can't deploy %s contract: %w", ctrName, err)
|
|
}
|
|
if res.State != vm.HaltState.String() {
|
|
return fmt.Errorf("can't deploy %s contract: %s", ctrName, res.FaultException)
|
|
}
|
|
|
|
totalGasCost += res.GasConsumed
|
|
w.WriteBytes(res.Script)
|
|
|
|
if method == deployMethodName {
|
|
// same actions are done in initializeContext.setNNS, can be unified
|
|
domain := ctrName + ".neofs"
|
|
script, err := c.nnsRegisterDomainScript(nnsHash, cs.Hash, domain)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if script != nil {
|
|
totalGasCost += defaultRegisterSysfee + native.GASFactor
|
|
w.WriteBytes(script)
|
|
}
|
|
c.Command.Printf("NNS: Set %s -> %s\n", domain, cs.Hash.StringLE())
|
|
}
|
|
}
|
|
|
|
groupKey := c.ContractWallet.Accounts[0].PrivateKey().PublicKey()
|
|
sysFee, err := c.emitUpdateNNSGroupScript(w, nnsHash, groupKey)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.Command.Printf("NNS: Set %s -> %s\n", morphClient.NNSGroupKeyName, hex.EncodeToString(groupKey.Bytes()))
|
|
|
|
totalGasCost += sysFee
|
|
if err := c.sendCommitteeTx(w.Bytes(), totalGasCost); err != nil {
|
|
return err
|
|
}
|
|
return c.awaitTx()
|
|
}
|
|
|
|
func (c *initializeContext) deployContracts() error {
|
|
mgmtHash := c.nativeHash(nativenames.Management)
|
|
alphaCs := c.getContract(alphabetContract)
|
|
|
|
var keysParam []smartcontract.Parameter
|
|
|
|
// alphabet contracts should be deployed by individual nodes to get different hashes.
|
|
for i, acc := range c.Accounts {
|
|
ctrHash := state.CreateContractHash(acc.Contract.ScriptHash(), alphaCs.NEF.Checksum, alphaCs.Manifest.Name)
|
|
if c.isUpdated(ctrHash, alphaCs) {
|
|
c.Command.Printf("Alphabet contract #%d is already deployed.\n", i)
|
|
continue
|
|
}
|
|
|
|
invokeHash := mgmtHash
|
|
keysParam = append(keysParam, smartcontract.Parameter{
|
|
Type: smartcontract.PublicKeyType,
|
|
Value: acc.PrivateKey().PublicKey().Bytes(),
|
|
})
|
|
|
|
params := getContractDeployParameters(alphaCs.RawNEF, alphaCs.RawManifest,
|
|
c.getAlphabetDeployParameters(i, len(c.Wallets)))
|
|
signer := transaction.Signer{
|
|
Account: acc.Contract.ScriptHash(),
|
|
Scopes: transaction.CalledByEntry,
|
|
}
|
|
|
|
res, err := c.Client.InvokeFunction(invokeHash, deployMethodName, params, []transaction.Signer{signer})
|
|
if err != nil {
|
|
return fmt.Errorf("can't deploy alphabet #%d contract: %w", i, err)
|
|
}
|
|
if res.State != vm.HaltState.String() {
|
|
return fmt.Errorf("can't deploy alpabet #%d contract: %s", i, res.FaultException)
|
|
}
|
|
|
|
h, err := c.Client.SignAndPushInvocationTx(res.Script, acc, -1, 0, []client.SignerAccount{{
|
|
Signer: signer,
|
|
Account: acc,
|
|
}})
|
|
if err != nil {
|
|
return fmt.Errorf("can't push deploy transaction: %w", err)
|
|
}
|
|
|
|
c.Hashes = append(c.Hashes, h)
|
|
}
|
|
|
|
for _, ctrName := range contractList {
|
|
cs := c.getContract(ctrName)
|
|
|
|
ctrHash := cs.Hash
|
|
if c.isUpdated(ctrHash, cs) {
|
|
c.Command.Printf("%s contract is already deployed.\n", ctrName)
|
|
continue
|
|
}
|
|
|
|
err := c.addManifestGroup(ctrHash, cs)
|
|
if err != nil {
|
|
return fmt.Errorf("can't sign manifest group: %v", err)
|
|
}
|
|
|
|
invokeHash := mgmtHash
|
|
params := getContractDeployParameters(cs.RawNEF, cs.RawManifest,
|
|
c.getContractDeployData(ctrName, keysParam))
|
|
signer := transaction.Signer{
|
|
Account: c.CommitteeAcc.Contract.ScriptHash(),
|
|
Scopes: transaction.Global,
|
|
}
|
|
|
|
res, err := c.Client.InvokeFunction(invokeHash, deployMethodName, params, []transaction.Signer{signer})
|
|
if err != nil {
|
|
return fmt.Errorf("can't deploy %s contract: %w", ctrName, err)
|
|
}
|
|
if res.State != vm.HaltState.String() {
|
|
return fmt.Errorf("can't deploy %s contract: %s", ctrName, res.FaultException)
|
|
}
|
|
|
|
if err := c.sendCommitteeTx(res.Script, res.GasConsumed); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return c.awaitTx()
|
|
}
|
|
|
|
func (c *initializeContext) isUpdated(ctrHash util.Uint160, cs *contractState) bool {
|
|
realCs, err := c.Client.GetContractStateByHash(ctrHash)
|
|
return err == nil && realCs.NEF.Checksum == cs.NEF.Checksum
|
|
}
|
|
|
|
func (c *initializeContext) getContract(ctrName string) *contractState {
|
|
return c.Contracts[ctrName]
|
|
}
|
|
|
|
func (c *initializeContext) readContracts(names []string) error {
|
|
var (
|
|
fi os.FileInfo
|
|
err error
|
|
)
|
|
if c.ContractPath != "" {
|
|
fi, err = os.Stat(c.ContractPath)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid contracts path: %w", err)
|
|
}
|
|
}
|
|
|
|
if c.ContractPath != "" && fi.IsDir() {
|
|
for _, ctrName := range names {
|
|
cs := new(contractState)
|
|
cs.RawNEF, err = ioutil.ReadFile(filepath.Join(c.ContractPath, ctrName, ctrName+"_contract.nef"))
|
|
if err != nil {
|
|
return fmt.Errorf("can't read NEF file for %s contract: %w", ctrName, err)
|
|
}
|
|
cs.RawManifest, err = ioutil.ReadFile(filepath.Join(c.ContractPath, ctrName, "config.json"))
|
|
if err != nil {
|
|
return fmt.Errorf("can't read manifest file for %s contract: %w", ctrName, err)
|
|
}
|
|
c.Contracts[ctrName] = cs
|
|
}
|
|
} else {
|
|
var r io.ReadCloser
|
|
if c.ContractPath == "" {
|
|
c.Command.Println("Contracts flag is missing, latest release will be fetched from Github.")
|
|
r, err = downloadContractsFromGithub(c.Command)
|
|
} else {
|
|
r, err = os.Open(c.ContractPath)
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("can't open contracts archive: %w", err)
|
|
}
|
|
defer r.Close()
|
|
|
|
m, err := readContractsFromArchive(r, names)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, name := range names {
|
|
c.Contracts[name] = m[name]
|
|
}
|
|
}
|
|
|
|
for _, ctrName := range names {
|
|
cs := c.Contracts[ctrName]
|
|
if err := cs.parse(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if ctrName != alphabetContract {
|
|
cs.Hash = state.CreateContractHash(c.CommitteeAcc.Contract.ScriptHash(),
|
|
cs.NEF.Checksum, cs.Manifest.Name)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (cs *contractState) parse() error {
|
|
nf, err := nef.FileFromBytes(cs.RawNEF)
|
|
if err != nil {
|
|
return fmt.Errorf("can't parse NEF file: %w", err)
|
|
}
|
|
|
|
m := new(manifest.Manifest)
|
|
if err := json.Unmarshal(cs.RawManifest, m); err != nil {
|
|
return fmt.Errorf("can't parse manifest file: %w", err)
|
|
}
|
|
|
|
cs.NEF = &nf
|
|
cs.Manifest = m
|
|
return nil
|
|
}
|
|
|
|
func readContractsFromArchive(file io.Reader, names []string) (map[string]*contractState, error) {
|
|
m := make(map[string]*contractState, len(names))
|
|
for i := range names {
|
|
m[names[i]] = new(contractState)
|
|
}
|
|
|
|
gr, err := gzip.NewReader(file)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("contracts file must be tar.gz archive: %w", err)
|
|
}
|
|
|
|
r := tar.NewReader(gr)
|
|
for h, err := r.Next(); ; h, err = r.Next() {
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
dir, _ := filepath.Split(h.Name)
|
|
ctrName := filepath.Base(dir)
|
|
|
|
cs, ok := m[ctrName]
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
switch {
|
|
case strings.HasSuffix(h.Name, filepath.Join(ctrName, ctrName+"_contract.nef")):
|
|
cs.RawNEF, err = ioutil.ReadAll(r)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("can't read NEF file for %s contract: %w", ctrName, err)
|
|
}
|
|
case strings.HasSuffix(h.Name, "config.json"):
|
|
cs.RawManifest, err = ioutil.ReadAll(r)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("can't read manifest file for %s contract: %w", ctrName, err)
|
|
}
|
|
}
|
|
m[ctrName] = cs
|
|
}
|
|
|
|
for ctrName, cs := range m {
|
|
if cs.RawNEF == nil {
|
|
return nil, fmt.Errorf("NEF for %s contract wasn't found", ctrName)
|
|
}
|
|
if cs.RawManifest == nil {
|
|
return nil, fmt.Errorf("manifest for %s contract wasn't found", ctrName)
|
|
}
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func getContractDeployParameters(rawNef, rawManif []byte, deployData []smartcontract.Parameter) []smartcontract.Parameter {
|
|
return []smartcontract.Parameter{
|
|
{
|
|
Type: smartcontract.ByteArrayType,
|
|
Value: rawNef,
|
|
},
|
|
{
|
|
Type: smartcontract.ByteArrayType,
|
|
Value: rawManif,
|
|
},
|
|
{
|
|
Type: smartcontract.ArrayType,
|
|
Value: deployData,
|
|
},
|
|
}
|
|
}
|
|
|
|
func (c *initializeContext) getContractDeployData(ctrName string, keysParam []smartcontract.Parameter) []smartcontract.Parameter {
|
|
items := make([]smartcontract.Parameter, 1, 6)
|
|
items[0] = newContractParameter(smartcontract.BoolType, false) // notaryDisabled is false
|
|
|
|
switch ctrName {
|
|
case neofsContract:
|
|
items = append(items,
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[processingContract].Hash),
|
|
newContractParameter(smartcontract.ArrayType, keysParam),
|
|
newContractParameter(smartcontract.ArrayType, smartcontract.Parameter{}))
|
|
case processingContract:
|
|
items = append(items, newContractParameter(smartcontract.Hash160Type, c.Contracts[neofsContract].Hash))
|
|
return items[1:] // no notary info
|
|
case auditContract:
|
|
items = append(items,
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[netmapContract].Hash))
|
|
case balanceContract:
|
|
items = append(items,
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[netmapContract].Hash),
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[containerContract].Hash))
|
|
case containerContract:
|
|
// In case if NNS is updated multiple times, we can't calculate
|
|
// it's actual hash based on local data, thus query chain.
|
|
nnsCs, err := c.Client.GetContractStateByID(1)
|
|
if err != nil {
|
|
panic("NNS is not yet deployed")
|
|
}
|
|
items = append(items,
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[netmapContract].Hash),
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[balanceContract].Hash),
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[neofsIDContract].Hash),
|
|
newContractParameter(smartcontract.Hash160Type, nnsCs.Hash),
|
|
newContractParameter(smartcontract.StringType, "container"))
|
|
case neofsIDContract:
|
|
items = append(items,
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[netmapContract].Hash),
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[containerContract].Hash))
|
|
case netmapContract:
|
|
configParam := []smartcontract.Parameter{
|
|
{Type: smartcontract.StringType, Value: netmapEpochKey},
|
|
{Type: smartcontract.IntegerType, Value: viper.GetInt64(epochDurationInitFlag)},
|
|
{Type: smartcontract.StringType, Value: netmapMaxObjectSizeKey},
|
|
{Type: smartcontract.IntegerType, Value: viper.GetInt64(maxObjectSizeInitFlag)},
|
|
{Type: smartcontract.StringType, Value: netmapAuditFeeKey},
|
|
{Type: smartcontract.IntegerType, Value: viper.GetInt64(auditFeeInitFlag)},
|
|
{Type: smartcontract.StringType, Value: netmapContainerFeeKey},
|
|
{Type: smartcontract.IntegerType, Value: viper.GetInt64(containerFeeInitFlag)},
|
|
{Type: smartcontract.StringType, Value: netmapContainerAliasFeeKey},
|
|
{Type: smartcontract.IntegerType, Value: viper.GetInt64(containerAliasFeeInitFlag)},
|
|
{Type: smartcontract.StringType, Value: netmapEigenTrustIterationsKey},
|
|
{Type: smartcontract.IntegerType, Value: int64(defaultEigenTrustIterations)},
|
|
{Type: smartcontract.StringType, Value: netmapEigenTrustAlphaKey},
|
|
{Type: smartcontract.StringType, Value: defaultEigenTrustAlpha},
|
|
{Type: smartcontract.StringType, Value: netmapBasicIncomeRateKey},
|
|
{Type: smartcontract.IntegerType, Value: viper.GetInt64(incomeRateInitFlag)},
|
|
{Type: smartcontract.StringType, Value: netmapInnerRingCandidateFeeKey},
|
|
{Type: smartcontract.IntegerType, Value: viper.GetInt64(candidateFeeInitFlag)},
|
|
{Type: smartcontract.StringType, Value: netmapWithdrawFeeKey},
|
|
{Type: smartcontract.IntegerType, Value: viper.GetInt64(withdrawFeeInitFlag)},
|
|
}
|
|
items = append(items,
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[balanceContract].Hash),
|
|
newContractParameter(smartcontract.Hash160Type, c.Contracts[containerContract].Hash),
|
|
newContractParameter(smartcontract.ArrayType, keysParam),
|
|
newContractParameter(smartcontract.ArrayType, configParam))
|
|
case proxyContract:
|
|
items = nil
|
|
case reputationContract:
|
|
case subnetContract:
|
|
default:
|
|
panic(fmt.Sprintf("invalid contract name: %s", ctrName))
|
|
}
|
|
return items
|
|
}
|
|
|
|
func (c *initializeContext) getAlphabetDeployParameters(i, n int) []smartcontract.Parameter {
|
|
items := c.getAlphabetDeployItems(i, n)
|
|
return []smartcontract.Parameter{
|
|
newContractParameter(smartcontract.BoolType, items[0]),
|
|
newContractParameter(smartcontract.Hash160Type, items[1]),
|
|
newContractParameter(smartcontract.Hash160Type, items[2]),
|
|
newContractParameter(smartcontract.StringType, items[3]),
|
|
newContractParameter(smartcontract.IntegerType, items[4]),
|
|
newContractParameter(smartcontract.IntegerType, items[5]),
|
|
}
|
|
}
|
|
|
|
func (c *initializeContext) getAlphabetDeployItems(i, n int) []interface{} {
|
|
items := make([]interface{}, 6)
|
|
items[0] = false
|
|
items[1] = c.Contracts[netmapContract].Hash
|
|
items[2] = c.Contracts[proxyContract].Hash
|
|
items[3] = innerring.GlagoliticLetter(i).String()
|
|
items[4] = int64(i)
|
|
items[5] = int64(n)
|
|
return items
|
|
}
|
|
|
|
func newContractParameter(typ smartcontract.ParamType, value interface{}) smartcontract.Parameter {
|
|
return smartcontract.Parameter{
|
|
Type: typ,
|
|
Value: value,
|
|
}
|
|
}
|