public override Hash ProposeNewContract(ContractDeploymentInput input)
{
AssertDeploymentProposerAuthority(Context.Sender);
var proposedContractInputHash = CalculateHashFromInput(input);
Assert(State.ContractProposingInputMap[proposedContractInputHash] == null, "Already proposed.");
State.ContractProposingInputMap[proposedContractInputHash] = new ContractProposingInput
{
Proposer = Context.Sender,
Status = ContractProposingInputStatus.Proposed
};
RequireParliamentAuthAddressSet();
// Create proposal for deployment
State.ParliamentAuthContract.CreateProposal.Send(new CreateProposalInput
{
ToAddress = Context.Self,
ContractMethodName = nameof(BasicContractZeroContainer.BasicContractZeroBase.ProposeContractCodeCheck),
Params = new ContractCodeCheckInput
{
ContractInput = input.ToByteString(),
IsContractDeployment = true
}.ToByteString(),
OrganizationAddress = State.GenesisOwner.Value,
ExpiredTime = Context.CurrentBlockTime.AddHours(24) // Maybe, get the interval from configuration
});
Context.Fire(new ContractProposed
{
ProposedContractInputHash = proposedContractInputHash
});
return(proposedContractInputHash);
}
public override Address DeploySmartContract(ContractDeploymentInput input)
{
RequireAuthority();
var address = PrivateDeploySystemSmartContract(null, input.Category, input.Code.ToByteArray());
return address;
}
public async Task Deploy_MultiTimes()
{
var contractDeploymentInput = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory, // test the default runner
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("TokenConverter")).Value)
};
{
var address = await DeployAsync(Tester, ParliamentAddress, contractDeploymentInput);
address.ShouldNotBeNull();
}
{
var address = await DeployAsync(Tester, ParliamentAddress, contractDeploymentInput);
address.ShouldNotBeNull();
}
{
var minerTester = Tester.CreateNewContractTester(AnotherMinerKeyPair);
var address = await DeployAsync(minerTester, ParliamentAddress, contractDeploymentInput);
address.ShouldNotBeNull();
}
{
var otherTester = Tester.CreateNewContractTester(AnotherUserKeyPair);
var proposingTxResult = await otherTester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
proposingTxResult.Status.ShouldBe(TransactionResultStatus.Failed);
proposingTxResult.Error.Contains("Proposer authority validation failed.").ShouldBeTrue();
}
}
public async Task DeploySmartContracts_Test()
{
var contractDeploymentInput = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory, // test the default runner
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("MultiToken")).Value)
};
string methodName = "DeploySmartContract";
//create proposal to deploy
var proposalId = await CreateProposalAsync(methodName, contractDeploymentInput);
//approve
var txResult = await ApproveWithMinersAsync(proposalId);
txResult.Status.ShouldBe(TransactionResultStatus.Mined);
//release
var txResult2 = await ReleaseProposalAsync(proposalId);
txResult2.Status.ShouldBe(TransactionResultStatus.Mined);
var creator = ContractDeployed.Parser.ParseFrom(txResult2.Logs[0].Indexed[0]).Creator;
creator.ShouldBe(Tester.GetCallOwnerAddress());
var deployAddress = ContractDeployed.Parser.ParseFrom(txResult2.Logs[0].NonIndexed).Address;
deployAddress.ShouldNotBeNull();
}
public override Address DeploySmartContract(ContractDeploymentInput input)
{
return(DeploySystemSmartContract(new SystemContractDeploymentInput()
{
Category = input.Category,
Code = input.Code,
TransactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList()
}));
}
public async Task UpdateSmartContractWithCodeCheck_Test()
{
var contractDeploymentInput = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory, // test the default runner
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("TokenConverter")).Value)
};
var newAddress = await DeployAsync(Tester, ParliamentAddress, contractDeploymentInput);
var code = Codes.Single(kv => kv.Key.Contains("ReferendumAuth")).Value;
var contractUpdateInput = new ContractUpdateInput
{
Address = newAddress,
Code = ByteString.CopyFrom(code)
};
var proposingTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeUpdateContract), contractUpdateInput);
proposingTxResult.Status.ShouldBe(TransactionResultStatus.Mined);
var proposalId = ProposalCreated.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated))).NonIndexed)
.ProposalId;
proposalId.ShouldNotBeNull();
var proposedContractInputHash = ContractProposed.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed)
.ProposedContractInputHash;
await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId);
var releaseApprovedContractTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput
{
ProposalId = proposalId,
ProposedContractInputHash = proposedContractInputHash
});
releaseApprovedContractTxResult.Status.ShouldBe(TransactionResultStatus.Mined);
var codeCheckProposalId = ProposalCreated.Parser
.ParseFrom(releaseApprovedContractTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated)))
.NonIndexed).ProposalId;
codeCheckProposalId.ShouldNotBeNull();
// Wait for contract code check event handler to finish its job
// Mine a block, should include approval transaction
var block = await Tester.MineEmptyBlockAsync();
var txs = await Tester.GetTransactionsAsync(block.TransactionIds);
txs.First(tx => tx.To == ParliamentAddress).MethodName
.ShouldBe(nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.ApproveMultiProposals));
}
internal async Task <Address> DeployAsync(ContractTester <BasicContractZeroTestAElfModule> tester,
Address parliamentContract, ContractDeploymentInput contractDeploymentInput)
{
var proposingTxResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
var proposalCreatedEvent =
proposingTxResult.Logs.FirstOrDefault(l => l.Name.Contains(nameof(ProposalCreated)));
if (proposalCreatedEvent == null)
{
return(null);
}
var proposalId = ProposalCreated.Parser
.ParseFrom(proposalCreatedEvent.NonIndexed)
.ProposalId;
var proposedContractInputHash = ContractProposed.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed)
.ProposedContractInputHash;
await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId);
// release contract code and trigger code check proposal
var releaseApprovedContractTxResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput
{
ProposalId = proposalId,
ProposedContractInputHash = proposedContractInputHash
});
var codeCheckProposalId = ProposalCreated.Parser
.ParseFrom(releaseApprovedContractTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated)))
.NonIndexed).ProposalId;
await ApproveWithMinersAsync(Tester, ParliamentAddress, codeCheckProposalId);
// release code check proposal and deployment completes
var deploymentResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.ReleaseCodeCheckedContract),
new ReleaseContractInput
{ ProposedContractInputHash = proposedContractInputHash, ProposalId = codeCheckProposalId });
var deploymentEvent = deploymentResult.Logs.FirstOrDefault(l => l.Name.Contains(nameof(ContractDeployed)));
var address = deploymentEvent != null
? ContractDeployed.Parser.ParseFrom(deploymentEvent.NonIndexed).Address
: null;
return(address);
}
public override Address DeploySmartContract(ContractDeploymentInput input)
{
RequireSenderAuthority();
AssertDeploymentProposerAuthority(Context.Origin);
var inputHash = CalculateHashFromInput(input);
TryClearContractProposingInput(inputHash, out var contractProposingInput);
var address =
PrivateDeploySystemSmartContract(null, input.Category, input.Code.ToByteArray(), false,
DecideNormalContractAuthor(contractProposingInput?.Proposer ?? Context.Sender));
return(address);
}
public override Address DeploySmartContract(ContractDeploymentInput input)
{
RequireSenderAuthority(State.CodeCheckController.Value?.OwnerAddress);
// AssertDeploymentProposerAuthority(Context.Origin);
var inputHash = CalculateHashFromInput(input);
TryClearContractProposingData(inputHash, out var contractProposingInput);
var address =
DeploySmartContract(null, input.Category, input.Code.ToByteArray(), false,
DecideNonSystemContractAuthor(contractProposingInput?.Proposer, Context.Sender));
return(address);
}
public async Task DeploySmartContracts_WithWrongProposer_Test()
{
var contractDeploymentInput = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory, // test the default runner
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("TokenConverter")).Value)
};
var otherTester = Tester.CreateNewContractTester(AnotherUserKeyPair);
var proposalId = await CreateProposalAsync(otherTester, ParliamentAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.ProposeNewContract), contractDeploymentInput);
await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId);
var releaseResult = await ReleaseProposalAsync(otherTester, ParliamentAddress, proposalId);
releaseResult.Status.ShouldBe(TransactionResultStatus.Failed);
releaseResult.Error.Contains("Proposer authority validation failed.").ShouldBeTrue();
}
public override Hash ProposeNewContract(ContractDeploymentInput input)
{
// AssertDeploymentProposerAuthority(Context.Sender);
var proposedContractInputHash = CalculateHashFromInput(input);
Assert(State.ContractProposingInputMap[proposedContractInputHash] == null, "Already proposed.");
State.ContractProposingInputMap[proposedContractInputHash] = new ContractProposingInput
{
Proposer = Context.Sender,
Status = ContractProposingInputStatus.Proposed
};
RequireParliamentContractAddressSet();
// Create proposal for deployment
var proposalCreationInput = new CreateProposalBySystemContractInput
{
ProposalInput = new CreateProposalInput
{
ToAddress = Context.Self,
ContractMethodName =
nameof(BasicContractZeroContainer.BasicContractZeroBase.ProposeContractCodeCheck),
Params = new ContractCodeCheckInput
{
ContractInput = input.ToByteString(),
IsContractDeployment = true
}.ToByteString(),
OrganizationAddress = State.ContractDeploymentController.Value.OwnerAddress,
ExpiredTime = Context.CurrentBlockTime.AddSeconds(ContractProposalExpirationTimePeriod)
},
OriginProposer = Context.Sender
};
Context.SendInline(State.ContractDeploymentController.Value.ContractAddress,
nameof(AuthorizationContractContainer.AuthorizationContractReferenceState
.CreateProposalBySystemContract), proposalCreationInput.ToByteString());
Context.Fire(new ContractProposed
{
ProposedContractInputHash = proposedContractInputHash
});
return(proposedContractInputHash);
}
private async Task <Address> Deploy_SmartContracts_Test()
{
var contractDeploymentInput = new ContractDeploymentInput()
{
Category = KernelConstants.DefaultRunnerCategory, // test the default runner
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("MultiToken")).Value)
};
var result = await DefaultTester.DeploySmartContract.SendAsync(contractDeploymentInput);
result.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
result.Output.ShouldNotBeNull();
{
var tx = await DefaultTester.DeploySmartContract.SendWithExceptionAsync(contractDeploymentInput);
tx.TransactionResult.Error.ShouldContain("contract code has already been deployed before");
}
return(result.Output);
}
public override Hash ProposeNewContract(ContractDeploymentInput input)
{
// AssertDeploymentProposerAuthority(Context.Sender);
var proposedContractInputHash = CalculateHashFromInput(input);
RegisterContractProposingData(proposedContractInputHash);
// Create proposal for deployment
var proposalCreationInput = new CreateProposalBySystemContractInput
{
ProposalInput = new CreateProposalInput
{
ToAddress = Context.Self,
ContractMethodName =
nameof(BasicContractZeroImplContainer.BasicContractZeroImplBase.ProposeContractCodeCheck),
Params = new ContractCodeCheckInput
{
ContractInput = input.ToByteString(),
CodeCheckReleaseMethod = nameof(DeploySmartContract),
ProposedContractInputHash = proposedContractInputHash,
Category = input.Category,
IsSystemContract = false
}.ToByteString(),
OrganizationAddress = State.ContractDeploymentController.Value.OwnerAddress,
ExpiredTime = Context.CurrentBlockTime.AddSeconds(ContractProposalExpirationTimePeriod)
},
OriginProposer = Context.Sender
};
Context.SendInline(State.ContractDeploymentController.Value.ContractAddress,
nameof(AuthorizationContractContainer.AuthorizationContractReferenceState
.CreateProposalBySystemContract), proposalCreationInput.ToByteString());
Context.Fire(new ContractProposed
{
ProposedContractInputHash = proposedContractInputHash
});
return(proposedContractInputHash);
}
public async Task DeploySmartContractWithCodeCheck_Test()
{
var contractDeploymentInput = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("MultiToken")).Value)
};
// propose contract code
var proposingTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
var proposalId = ProposalCreated.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated))).NonIndexed)
.ProposalId;
var proposedContractInputHash = ContractProposed.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed)
.ProposedContractInputHash;
await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId);
// release contract code and trigger code check proposal
await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput
{
ProposalId = proposalId,
ProposedContractInputHash = proposedContractInputHash
});
// Wait for contract code check event handler to finish its job
// Mine a block, should include approval transaction
var block = await Tester.MineEmptyBlockAsync();
var txs = await Tester.GetTransactionsAsync(block.TransactionIds);
txs.First(tx => tx.To == ParliamentAddress).MethodName
.ShouldBe(nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.ApproveMultiProposals));
}
public async Task UpdateSmartContract_Test()
{
var contractDeploymentInput = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory, // test the default runner
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("TokenConverter")).Value)
};
var newAddress = await DeployAsync(Tester, ParliamentAddress, contractDeploymentInput);
var code = Codes.Single(kv => kv.Key.Contains("Treasury")).Value;
var contractUpdateInput = new ContractUpdateInput
{
Address = newAddress,
Code = ByteString.CopyFrom(code)
};
var proposingTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeUpdateContract), contractUpdateInput);
proposingTxResult.Status.ShouldBe(TransactionResultStatus.Mined);
var proposalId = ProposalCreated.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated))).NonIndexed)
.ProposalId;
proposalId.ShouldNotBeNull();
var proposedContractInputHash = ContractProposed.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed)
.ProposedContractInputHash;
await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId);
var releaseApprovedContractTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput
{
ProposalId = proposalId,
ProposedContractInputHash = proposedContractInputHash
});
releaseApprovedContractTxResult.Status.ShouldBe(TransactionResultStatus.Mined);
var codeCheckProposalId = ProposalCreated.Parser
.ParseFrom(releaseApprovedContractTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated)))
.NonIndexed).ProposalId;
codeCheckProposalId.ShouldNotBeNull();
await ApproveWithMinersAsync(Tester, ParliamentAddress, codeCheckProposalId);
var updateResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.ReleaseCodeCheckedContract),
new ReleaseContractInput
{ ProposedContractInputHash = proposedContractInputHash, ProposalId = codeCheckProposalId });
updateResult.Status.ShouldBe(TransactionResultStatus.Mined);
var contractAddress = CodeUpdated.Parser
.ParseFrom(updateResult.Logs.First(l => l.Name.Contains(nameof(CodeUpdated))).Indexed[0]).Address;
contractAddress.ShouldBe(newAddress);
var codeHash = Hash.FromRawBytes(code);
var newHash = CodeUpdated.Parser
.ParseFrom(updateResult.Logs.First(l => l.Name.Contains(nameof(CodeUpdated))).NonIndexed).NewCodeHash;
newHash.ShouldBe(codeHash);
}
public async Task ChangeContractZeroOwner_Test()
{
var createOrganizationResult = await Tester.ExecuteContractWithMiningAsync(ParliamentAddress,
nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.CreateOrganization),
new CreateOrganizationInput
{
ReleaseThreshold = 1000
});
var organizationAddress = Address.Parser.ParseFrom(createOrganizationResult.ReturnValue);
var methodName = "ChangeGenesisOwner";
var proposalId = await CreateProposalAsync(Tester, ParliamentAddress, methodName, organizationAddress);
var txResult1 = await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId);
txResult1.Status.ShouldBe(TransactionResultStatus.Mined);
var txResult2 = await ReleaseProposalAsync(Tester, ParliamentAddress, proposalId);
txResult2.Status.ShouldBe(TransactionResultStatus.Mined);
// test deployment with only one miner
var contractDeploymentInput = new ContractDeploymentInput()
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("TokenConverter")).Value)
};
// propose contract code
var proposingTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
var contractProposalId = ProposalCreated.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated))).NonIndexed)
.ProposalId;
var proposedContractInputHash = ContractProposed.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed)
.ProposedContractInputHash;
await ApproveWithKeyPairAsync(Tester, ParliamentAddress, contractProposalId,
Tester.InitialMinerList.First());
// release contract code and trigger code check proposal
var releaseApprovedContractTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput
{
ProposalId = contractProposalId,
ProposedContractInputHash = proposedContractInputHash
});
var codeCheckProposalId = ProposalCreated.Parser
.ParseFrom(releaseApprovedContractTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated)))
.NonIndexed).ProposalId;
await ApproveWithKeyPairAsync(Tester, ParliamentAddress, codeCheckProposalId,
Tester.InitialMinerList.First());
// release code check proposal and deployment completes
var deploymentResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.ReleaseCodeCheckedContract),
new ReleaseContractInput
{ ProposedContractInputHash = proposedContractInputHash, ProposalId = codeCheckProposalId });
var creator = ContractDeployed.Parser
.ParseFrom(deploymentResult.Logs.First(l => l.Name.Contains(nameof(ContractDeployed))).Indexed[0])
.Author;
creator.ShouldBe(BasicContractZeroAddress);
var deployAddress = ContractDeployed.Parser.ParseFrom(deploymentResult.Logs.First(l => l.Name.Contains(nameof(ContractDeployed))).NonIndexed).Address;
deployAddress.ShouldNotBeNull();
var author = Address.Parser.ParseFrom(await Tester.CallContractMethodAsync(BasicContractZeroAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.GetContractAuthor), deployAddress));
author.ShouldBe(BasicContractZeroAddress);
}
public async Task DeploySmartContracts_RepeatedProposals_Test()
{
var contractDeploymentInput = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory, // test the default runner
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("TokenConverter")).Value)
};
// propose contract code
var proposingTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
{
// propose contract code
var repeatedProposingTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
repeatedProposingTxResult.Status.ShouldBe(TransactionResultStatus.Failed);
repeatedProposingTxResult.Error.Contains("Already proposed.").ShouldBeTrue();
}
var proposalId = ProposalCreated.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated))).NonIndexed)
.ProposalId;
var proposedContractInputHash = ContractProposed.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed)
.ProposedContractInputHash;
await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId);
// release contract code and trigger code check proposal
var releaseApprovedContractTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput
{
ProposalId = proposalId,
ProposedContractInputHash = proposedContractInputHash
});
var codeCheckProposalId = ProposalCreated.Parser
.ParseFrom(releaseApprovedContractTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated)))
.NonIndexed).ProposalId;
await ApproveWithMinersAsync(Tester, ParliamentAddress, codeCheckProposalId);
{
// propose contract code
var repeatedProposingTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
repeatedProposingTxResult.Status.ShouldBe(TransactionResultStatus.Failed);
repeatedProposingTxResult.Error.Contains("Already proposed.").ShouldBeTrue();
}
// release code check proposal and deployment completes
var deploymentResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.ReleaseCodeCheckedContract),
new ReleaseContractInput
{ ProposedContractInputHash = proposedContractInputHash, ProposalId = codeCheckProposalId });
deploymentResult.Status.ShouldBe(TransactionResultStatus.Mined);
{
// propose contract code
var repeatedProposingTxResult = await Tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
repeatedProposingTxResult.Status.ShouldBe(TransactionResultStatus.Mined);
}
}
public async Task DeploySmartContracts_CreatorDeploy_Test()
{
StartSideChain();
var contractDeploymentInput = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory, // test the default runner
Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.Contains("TokenConverter")).Value)
};
// propose contract code
var proposingTxResult = await SideChainTester.ExecuteContractWithMiningAsync(SideBasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
proposingTxResult.Status.ShouldBe(TransactionResultStatus.Mined);
var proposalId = ProposalCreated.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated))).NonIndexed)
.ProposalId;
proposalId.ShouldNotBeNull();
var proposedContractInputHash = ContractProposed.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed)
.ProposedContractInputHash;
await ApproveWithMinersAsync(SideChainTester, SideParliamentAddress, proposalId);
// release contract code and trigger code check proposal
var releaseApprovedContractTxResult = await SideChainTester.ExecuteContractWithMiningAsync(SideBasicContractZeroAddress,
nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput
{
ProposalId = proposalId,
ProposedContractInputHash = proposedContractInputHash
});
releaseApprovedContractTxResult.Status.ShouldBe(TransactionResultStatus.Mined);
var codeCheckProposalId = ProposalCreated.Parser
.ParseFrom(releaseApprovedContractTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated)))
.NonIndexed).ProposalId;
codeCheckProposalId.ShouldNotBeNull();
await ApproveWithMinersAsync(SideChainTester, SideParliamentAddress, codeCheckProposalId);
// release code check proposal and deployment completes
var deploymentResult = await SideChainTester.ExecuteContractWithMiningAsync(SideBasicContractZeroAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.ReleaseCodeCheckedContract),
new ReleaseContractInput
{ ProposedContractInputHash = proposedContractInputHash, ProposalId = codeCheckProposalId });
deploymentResult.Status.ShouldBe(TransactionResultStatus.Mined);
var creator = ContractDeployed.Parser.ParseFrom(deploymentResult.Logs[1].Indexed[0]).Author;
creator.ShouldBe(SideChainTester.GetCallOwnerAddress());
var deployAddress = ContractDeployed.Parser.ParseFrom(deploymentResult.Logs[1].NonIndexed).Address;
deployAddress.ShouldNotBeNull();
var author = Address.Parser.ParseFrom(await SideChainTester.CallContractMethodAsync(SideBasicContractZeroAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.GetContractAuthor), deployAddress));
author.ShouldBe(SideChainTester.GetCallOwnerAddress());
}
