public async Task <byte[]> DeploySmartContract(int category, byte[] contract)
{
SmartContractRegistration registration = new SmartContractRegistration
{
Category = category,
ContractBytes = ByteString.CopyFrom(contract),
ContractHash = Hash.FromRawBytes(contract)
};
var tx = Api.GetTransaction();
ulong serialNumber = _serialNumber.Increment().Value;
var creator = Api.GetTransaction().From;
var info = new ContractInfo()
{
Owner = creator,
SerialNumber = serialNumber
};
var address = info.Address;
// calculate new account address
var account = DataPath.CalculateAccountAddress(tx.From, tx.IncrementId);
await Api.DeployContractAsync(account, registration);
Console.WriteLine("TestContractZero: Deployment success, {0}", account.DumpHex());
return(account.DumpByteArray());
}
public virtual async Task <IExecutive> RunAsync(SmartContractRegistration reg)
{
var code = reg.Code.ToByteArray();
var loadContext = GetLoadContext();
Assembly assembly = LoadAssembly(code, loadContext);
if (assembly == null)
{
throw new CSharpInvalidCodeException("Invalid binary code.");
}
ContractVersion = assembly.GetName().Version?.ToString();
var executive = new Executive(assembly)
{
ContractHash = reg.CodeHash,
IsSystemContract = reg.IsSystemContract,
ContractVersion = ContractVersion
};
return(await Task.FromResult(executive));
}
public async Task AppendBlockTest()
{
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);
var block = CreateBlock(chain.GenesisBlockHash, chain.Id, GlobalConfig.GenesisBlockHeight + 1);
await blockchain.AddBlocksAsync(new List <IBlock> {
block
});
Assert.Equal(await getNextHeight(), GlobalConfig.GenesisBlockHeight + 2);
Assert.Equal((await blockchain.GetCurrentBlockHashAsync()).DumpHex(), block.GetHash().DumpHex());
Assert.Equal(block.Header.Index, GlobalConfig.GenesisBlockHeight + 1);
}
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 virtual async Task <IExecutive> RunAsync(SmartContractRegistration reg)
{
var code = reg.Code.ToByteArray();
var loadContext = GetLoadContext();
Assembly assembly = LoadAssembly(code, loadContext);
if (assembly == null)
{
throw new InvalidAssemblyException("Invalid binary code.");
}
ContractVersion = assembly.GetName().Version?.ToString();
var executive = new Executive(assembly)
{
ContractHash = reg.CodeHash,
ContractVersion = ContractVersion
};
// AssemblyLoadContext needs to be called after initializing the Executive
// to ensure that it is not unloaded early in release mode.
loadContext.Unload();
return(await Task.FromResult(executive));
}
public async Task Update_Contract_Success()
{
var registrationA = new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = Hash.FromString("TestContractA").ToByteString(),
CodeHash = Hash.FromString("TestContractA")
};
var registrationANew = new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = Hash.FromString("TestContractA_New").ToByteString(),
CodeHash = Hash.FromString("TestContractA")
};
var registrationB = new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = Hash.FromString("TestContractB").ToByteString(),
CodeHash = Hash.FromString("TestContractB")
};
await _smartContractService.DeployContractAsync(Address.Genesis, registrationA, false, null);
await _smartContractService.UpdateContractAsync(Address.Genesis, registrationANew, false, null);
await _smartContractService.UpdateContractAsync(Address.Genesis, registrationB, false, null);
}
public virtual async Task <IExecutive> RunAsync(SmartContractRegistration reg)
{
var code = reg.Code.ToByteArray();
var loadContext = GetLoadContext();
Assembly assembly = null;
using (Stream stream = new MemoryStream(code))
{
assembly = loadContext.LoadFromStream(stream);
}
if (assembly == null)
{
throw new InvalidCodeException("Invalid binary code.");
}
var executive = new Executive(assembly, _executivePlugins)
{
ContractHash = reg.CodeHash
};
return(await Task.FromResult(executive));
}
public static void DeployContract(Address address, SmartContractRegistration registration)
{
Assert(_smartContractContext.ContractAddress.Equals(GetContractZeroAddress()));
var task = _smartContractContext.SmartContractService.DeployContractAsync(GetChainId(), address,
registration, false);
task.Wait();
}
private void CheckSmartContractRegistration(SmartContractRegistration smartContractRegistration)
{
smartContractRegistration.Category.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration
.Category);
smartContractRegistration.Code.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration
.Code);
smartContractRegistration.CodeHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration
.CodeHash);
}
private Type GetContractType(SmartContractRegistration registration)
{
var runner = _smartContractRunnerFactory.GetRunner(registration.Category);
if (runner == null)
{
throw new NotSupportedException($"Runner for category {registration.Category} is not registered.");
}
return(runner.GetContractType(registration));
}
private Address PrivateDeploySystemSmartContract(Hash name, int category, byte[] code)
{
if (name != null)
{
Assert(State.NameAddressMapping[name] == null, "contract name already been registered");
}
var serialNumber = State.ContractSerialNumber.Value;
// Increment
State.ContractSerialNumber.Value = serialNumber + 1;
var contractAddress = AddressHelper.BuildContractAddress(Context.ChainId, serialNumber);
var codeHash = Hash.FromRawBytes(code);
var info = new ContractInfo
{
SerialNumber = serialNumber,
Author = Context.Origin,
Category = category,
CodeHash = codeHash
};
State.ContractInfos[contractAddress] = info;
var reg = new SmartContractRegistration
{
Category = category,
Code = ByteString.CopyFrom(code),
CodeHash = codeHash
};
State.SmartContractRegistrations[reg.CodeHash] = reg;
Context.DeployContract(contractAddress, reg, name);
Context.Fire(new ContractDeployed()
{
CodeHash = codeHash,
Address = contractAddress,
Author = Context.Origin
});
Context.LogDebug(() => "BasicContractZero - Deployment ContractHash: " + codeHash.ToHex());
Context.LogDebug(() => "BasicContractZero - Deployment success: " + contractAddress.GetFormatted());
if (name != null)
{
State.NameAddressMapping[name] = contractAddress;
}
return(contractAddress);
}
public async Task DeployContractAsync(byte[] code, Address address)
{
var reg = new SmartContractRegistration
{
Category = 1,
ContractBytes = ByteString.CopyFrom(code),
ContractHash = Hash.FromRawBytes(code)
};
await SmartContractService.DeployContractAsync(ChainId1, address, reg, false);
}
public void SetDefaultContractZeroRegistrationByType(Type defaultZero)
{
var code = File.ReadAllBytes(defaultZero.Assembly.Location);
DefaultContractZeroRegistration = new SmartContractRegistration()
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(code),
CodeHash = Hash.FromRawBytes(code)
};
}
public SmartContractRunnerTest()
{
var contractCode = File.ReadAllBytes(typeof(TestContract.TestContract).Assembly.Location);
Runner = GetRequiredService <ISmartContractRunner>();
Reg = new SmartContractRegistration()
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(contractCode),
CodeHash = Hash.FromRawBytes(contractCode)
};
}
private async Task Init()
{
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.Zero
};
var chain1 = await _chainCreationService.CreateNewChainAsync(ChainId1, new List <SmartContractRegistration> {
reg
});
}
public async Task Deploy_Contract_Success()
{
var registration = new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = Hash.FromString("TestDeployContract").ToByteString(),
CodeHash = Hash.FromString("TestDeployContract")
};
await _smartContractService.DeployContractAsync(Address.Genesis, registration, false, null);
}
public async Task Put_ZeroRegistration_Executive_Success()
{
var registration = new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = Hash.FromString("TestPutExecutive").ToByteString(),
CodeHash = Hash.FromString("TestPutExecutive")
};
var mockExecutive = new Mock <IExecutive>();
await _smartContractExecutiveService.PutExecutiveAsync(SampleAddress.AddressList[7], mockExecutive.Object);
}
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);
}
private async Task DeploySampleContracts()
{
var reg = new SmartContractRegistration
{
Category = 1,
ContractBytes = ByteString.CopyFrom(ContractCode),
ContractHash = Hash.FromRawBytes(ContractCode)
};
await SmartContractService.DeployContractAsync(ChainId1, ContractAddress1, reg, false);
await SmartContractService.DeployContractAsync(ChainId2, ContractAddress2, reg, false);
}
private Module GetAbiModule(SmartContractRegistration reg, string name = null)
{
var code = reg.ContractBytes.ToByteArray();
if (reg.Category == 0)
{
name = ((SmartContractType)reg.Type).ToString();
}
var abiModule = Generator.GetABIModule(code, name);
return(abiModule);
}
private async Task DeploySampleContracts()
{
var reg = new SmartContractRegistration
{
Category = 1,
ContractBytes = ByteString.CopyFrom(ExampleContractCode),
ContractHash = Hash.FromRawBytes(ExampleContractCode)
};
await SmartContractService.DeployContractAsync(ChainId1, SampleContractAddress1, reg, true);
Executive1 = await SmartContractService.GetExecutiveAsync(SampleContractAddress1, ChainId1);
}
private async Task <IExecutive> GetExecutiveAsync(Address address, SmartContractRegistration reg)
{
// get runner
var runner = _smartContractRunnerContainer.GetRunner(reg.Category);
// run smartcontract executive info and return executive
var executive = await runner.RunAsync(reg);
var context =
_hostSmartContractBridgeContextService.Create();
executive.SetHostSmartContractBridgeContext(context);
return(executive);
}
public override Address UpdateSmartContract(ContractUpdateInput input)
{
var contractAddress = input.Address;
var code = input.Code.ToByteArray();
var info = State.ContractInfos[contractAddress];
Assert(info != null, "Contract not found.");
RequireSenderAuthority(State.CodeCheckController.Value?.OwnerAddress);
var inputHash = CalculateHashFromInput(input);
if (!TryClearContractProposingData(inputHash, out _))
{
Assert(Context.Sender == info.Author, "No permission.");
}
var oldCodeHash = info.CodeHash;
var newCodeHash = Hash.FromRawBytes(code);
Assert(!oldCodeHash.Equals(newCodeHash), "Code is not changed.");
Assert(State.SmartContractRegistrations[newCodeHash] == null, "Same code has been deployed before.");
info.CodeHash = newCodeHash;
info.Version++;
State.ContractInfos[contractAddress] = info;
var reg = new SmartContractRegistration
{
Category = info.Category,
Code = ByteString.CopyFrom(code),
CodeHash = newCodeHash,
IsSystemContract = info.IsSystemContract,
Version = info.Version
};
State.SmartContractRegistrations[reg.CodeHash] = reg;
Context.UpdateContract(contractAddress, reg, null);
Context.Fire(new CodeUpdated()
{
Address = contractAddress,
OldCodeHash = oldCodeHash,
NewCodeHash = newCodeHash,
Version = info.Version
});
Context.LogDebug(() => "BasicContractZero - update success: " + contractAddress.GetFormatted());
return(contractAddress);
}
public async Task Update_Contract_Success()
{
var registrationA = new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = HashHelper.ComputeFrom("TestContractA").ToByteString(),
CodeHash = HashHelper.ComputeFrom("TestContractA")
};
var registrationANew = new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = HashHelper.ComputeFrom("TestContractA_New").ToByteString(),
CodeHash = HashHelper.ComputeFrom("TestContractA")
};
var registrationB = new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = HashHelper.ComputeFrom("TestContractB").ToByteString(),
CodeHash = HashHelper.ComputeFrom("TestContractB")
};
await _smartContractService.DeployContractAsync(new ContractDto
{
BlockHeight = 1,
ContractAddress = SampleAddress.AddressList[0],
ContractName = null,
IsPrivileged = false,
SmartContractRegistration = registrationA
});
await _smartContractService.UpdateContractAsync(new ContractDto
{
ContractAddress = SampleAddress.AddressList[1],
SmartContractRegistration = registrationANew,
BlockHeight = 2,
IsPrivileged = false,
ContractName = null
});
await _smartContractService.UpdateContractAsync(new ContractDto
{
ContractAddress = SampleAddress.AddressList[2],
SmartContractRegistration = registrationB,
BlockHeight = 2,
IsPrivileged = false,
ContractName = null
});
}
public virtual void SetDefaultContractZeroRegistrationByType(Type defaultZero)
{
var dllPath = Directory.Exists(_contractOptions.GenesisContractDir)
? Path.Combine(_contractOptions.GenesisContractDir, $"{defaultZero.Assembly.GetName().Name}.dll")
: defaultZero.Assembly.Location;
var code = File.ReadAllBytes(dllPath);
DefaultContractZeroRegistration = new SmartContractRegistration()
{
Category = GetCategory(),
Code = ByteString.CopyFrom(code),
CodeHash = HashHelper.ComputeFrom(code)
};
}
public async Task DeployUserContract()
{
var reg = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(SmartContractZeroCode),
ContractHash = Hash.Zero
};
var chain = await _chainCreationService.CreateNewChainAsync(ChainId, new List <SmartContractRegistration> {
reg
});
var code = ExampleContractCode;
var contractAddressZero = AddressHelpers.GetSystemContractAddress(ChainId, GlobalConfig.GenesisBasicContract);
var txnDep = new Transaction()
{
From = Address.Zero,
To = contractAddressZero,
IncrementId = NewIncrementId(),
MethodName = "DeploySmartContract",
Params = ByteString.CopyFrom(ParamsPacker.Pack(0, code))
};
var txnCtxt = new TransactionContext
{
Transaction = txnDep
};
var executive = await _smartContractService.GetExecutiveAsync(contractAddressZero, ChainId);
await executive.SetTransactionContext(txnCtxt).Apply();
await txnCtxt.Trace.CommitChangesAsync(_stateStore);
Assert.True(string.IsNullOrEmpty(txnCtxt.Trace.StdErr));
var address = Address.FromRawBytes(txnCtxt.Trace.RetVal.Data.DeserializeToBytes());
var regExample = new SmartContractRegistration
{
Category = 0,
ContractBytes = ByteString.CopyFrom(code),
ContractHash = Hash.FromRawBytes(code)
};
var copy = await _smartContractManager.GetAsync(address);
Assert.Equal(regExample, copy);
}
public void SetDefaultContractZeroRegistrationByType(Type defaultZero)
{
var dllPath = Directory.Exists(_contractOptions.GenesisContractDir)
? Path.Combine(_contractOptions.GenesisContractDir, $"{defaultZero.Assembly.GetName().Name}.dll")
: defaultZero.Assembly.Location;
var code = File.ReadAllBytes(dllPath);
DefaultContractZeroRegistration = new SmartContractRegistration()
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(code),
CodeHash = Hash.FromRawBytes(code)
};
}
public async Task <IExecutive> RunAsync(SmartContractRegistration reg)
{
// TODO: Maybe input arguments can be simplified
var code = reg.ContractBytes.ToByteArray();
var loadContext = GetLoadContext();
Assembly assembly = null;
using (Stream stream = new MemoryStream(code))
{
assembly = loadContext.LoadFromStream(stream);
}
if (assembly == null)
{
throw new InvalidCodeException("Invalid binary code.");
}
string name = null;
if (reg.Category == 0)
{
name = ((SmartContractType)reg.Type).ToString();
}
var abiModule = GetAbiModule(reg, name);
// TODO: Change back
var types = assembly.GetTypes();
var type = types.FirstOrDefault(x => x.FullName.Contains(abiModule.Name));
if (type == null)
{
throw new InvalidCodeException($"No SmartContract type {abiModule.Name} is defined in the code.");
}
var instance = (ISmartContract)Activator.CreateInstance(type);
var ApiSingleton = loadContext.Sdk.GetTypes().FirstOrDefault(x => x.Name.EndsWith("Api"));
if (ApiSingleton == null)
{
throw new InvalidCodeException("No Api was found.");
}
Executive executive = new Executive(abiModule).SetSmartContract(instance).SetApi(ApiSingleton);
return(await Task.FromResult(executive));
}
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());
}
