public async Task <IChain> CreateChainTest()
{
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.Zero
};
var chainId = Hash.Generate();
var chain = await _chainCreationService.CreateNewChainAsync(chainId, new List <SmartContractRegistration> {
reg
});
var blockchain = _chainService.GetBlockChain(chainId);
var getNextHeight = new Func <Task <ulong> >(async() =>
{
var curHash = await blockchain.GetCurrentBlockHashAsync();
var indx = ((BlockHeader)await blockchain.GetHeaderByHashAsync(curHash)).Index;
return(indx + 1);
});
Assert.Equal(await getNextHeight(), GlobalConfig.GenesisBlockHeight + 1);
return(chain);
}
private async Task Init()
{
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.Zero,
Type = (int)SmartContractType.BasicContractZero
};
var chain1 = await _chainCreationService.CreateNewChainAsync(ChainId1, new List <SmartContractRegistration> {
reg
});
DataProvider1 = DataProvider.GetRootDataProvider(
chain1.Id,
Address.FromRawBytes(ChainId1.OfType(HashType.AccountZero).ToByteArray())
);
DataProvider1.StateStore = StateStore;
var chain2 = await _chainCreationService.CreateNewChainAsync(ChainId2, new List <SmartContractRegistration> {
reg
});
DataProvider2 = DataProvider.GetRootDataProvider(
chain2.Id,
Address.FromRawBytes(ChainId1.OfType(HashType.AccountZero).ToByteArray())
);
DataProvider2.StateStore = StateStore;
}
public async Task <BlockchainNodeContext> StartAsync(BlockchainNodeContextStartDto dto)
{
_defaultContractZeroCodeProvider.SetDefaultContractZeroRegistrationByType(dto.ZeroSmartContractType);
var context = new BlockchainNodeContext
{
ChainId = dto.ChainId,
TxHub = _txHub,
};
var chain = await _blockchainService.GetChainAsync();
chain = chain == null
? await _chainCreationService.CreateNewChainAsync(dto.Transactions)
: await _blockchainService.ResetChainToLibAsync(chain);
await _smartContractAddressUpdateService.UpdateSmartContractAddressesAsync(
await _blockchainService.GetBlockHeaderByHashAsync(chain.BestChainHash));
await _consensusService.TriggerConsensusAsync(new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
});
return(context);
}
private async Task Init()
{
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.Zero,
Type = (int)SmartContractType.BasicContractZero
};
var chain1 = await _chainCreationService.CreateNewChainAsync(ChainId1, new List <SmartContractRegistration> {
reg
});
var chain2 = await _chainCreationService.CreateNewChainAsync(ChainId2, new List <SmartContractRegistration> {
reg
});
}
public async Task SmartContractZeroByCreation()
{
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.Zero
};
var chain = await _chainCreationService.CreateNewChainAsync(ChainId, new List <SmartContractRegistration> {
reg
});
var contractAddressZero = AddressHelpers.GetSystemContractAddress(ChainId, GlobalConfig.GenesisBasicContract);
var copy = await _smartContractManager.GetAsync(contractAddressZero);
// throw exception if not registered
Assert.Equal(reg, copy);
}
public async Task <Address> Prepare(byte[] contractCode)
{
//create smart contact zero
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.FromRawBytes(SmartContractZeroCode),
Type = (int)SmartContractType.BasicContractZero
};
var chain = await _chainCreationService.CreateNewChainAsync(ChainId,
new List <SmartContractRegistration> {
reg
});
var contractAddressZero = _chainCreationService.GenesisContractHash(ChainId, SmartContractType.BasicContractZero);
//deploy token contract
var code = contractCode;
var txnDep = new Transaction()
{
From = Address.Zero,
To = contractAddressZero,
IncrementId = 0,
MethodName = "DeploySmartContract",
Params = ByteString.CopyFrom(ParamsPacker.Pack(1, code))
};
var txnCtxt = new TransactionContext()
{
Transaction = txnDep
};
var executive = await _smartContractService.GetExecutiveAsync(contractAddressZero, ChainId);
try
{
await executive.SetTransactionContext(txnCtxt).Apply();
await txnCtxt.Trace.CommitChangesAsync(_stateStore);
}
finally
{
await _smartContractService.PutExecutiveAsync(contractAddressZero, executive);
}
var contractAddr = txnCtxt.Trace.RetVal.Data.DeserializeToPbMessage <Address>();
return(contractAddr);
}
public async Task <IChain> CreateChain()
{
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.Zero
};
var chainId = Hash.Generate();
return(await _chainCreationService.CreateNewChainAsync(chainId, new List <SmartContractRegistration> {
reg
}));
}
public async Task Test()
{
// TODO: *** Contract Issues ***
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.FromRawBytes(SmartContractZeroCode)
};
var chain = await _service.CreateNewChainAsync(Hash.FromString("Hello"), new List <SmartContractRegistration> {
reg
});
Assert.Equal(Hash.FromString("Hello").DumpHex(), chain.Id.DumpHex());
}
private void CreateNewChain(byte[] tokenContractCode, byte[] consensusContractCode, byte[] basicContractZero,
byte[] sideChainGenesisContractCode)
{
var tokenCReg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(tokenContractCode),
ContractHash = Hash.FromRawBytes(tokenContractCode),
Type = (int)SmartContractType.TokenContract
};
var consensusCReg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(consensusContractCode),
ContractHash = Hash.FromRawBytes(consensusContractCode),
Type = (int)SmartContractType.AElfDPoS
};
var basicReg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(basicContractZero),
ContractHash = Hash.FromRawBytes(basicContractZero),
Type = (int)SmartContractType.BasicContractZero
};
var sideChainCReg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(sideChainGenesisContractCode),
ContractHash = Hash.FromRawBytes(sideChainGenesisContractCode),
Type = (int)SmartContractType.SideChainContract
};
var res = _chainCreationService.CreateNewChainAsync(Hash.LoadHex(ChainConfig.Instance.ChainId),
new List <SmartContractRegistration> {
basicReg, tokenCReg, consensusCReg, sideChainCReg
}).Result;
_logger?.Debug($"Genesis block hash = {res.GenesisBlockHash.DumpHex()}");
}
private async Task Init()
{
var reg1 = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SideChainCode),
ContractHash = Hash.FromRawBytes(SideChainCode),
Type = (int)SmartContractType.SideChainContract
};
var reg0 = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SCZeroContractCode),
ContractHash = Hash.FromRawBytes(SCZeroContractCode),
Type = (int)SmartContractType.BasicContractZero
};
var chain1 =
await _chainCreationService.CreateNewChainAsync(ChainId1,
new List <SmartContractRegistration> {
reg0, reg1
});
}
