public async Task SetMethodFee_Fail_Test()
{
await CreateNativeTokenAsync();
var tokenSymbol = NativeTokenInfo.Symbol;
var methodName = "Transfer";
// unauthorized
{
var basicFee = 100;
var methodFees = new MethodFees
{
MethodName = methodName,
Fees =
{
new MethodFee {
Symbol = tokenSymbol, BasicFee = basicFee
}
}
};
var ret = await TokenContractStub.SetMethodFee.SendWithExceptionAsync(methodFees);
ret.TransactionResult.Error.ShouldContain("Unauthorized to set method fee");
}
// invalid fee
{
var basicFee = 0;
var methodFees = new MethodFees
{
MethodName = methodName,
Fees =
{
new MethodFee {
Symbol = tokenSymbol, BasicFee = basicFee
}
}
};
var ret = await TokenContractStub.SetMethodFee.SendWithExceptionAsync(methodFees);
ret.TransactionResult.Error.ShouldContain("Invalid amount");
}
//invalid token symbol
{
var basicFee = 100;
var methodFees = new MethodFees
{
MethodName = methodName,
Fees =
{
new MethodFee {
Symbol = "NOTEXIST", BasicFee = basicFee
}
}
};
var ret = await TokenContractStub.SetMethodFee.SendWithExceptionAsync(methodFees);
ret.TransactionResult.Error.ShouldContain("Token is not found");
}
}
public async Task SetMethodFee_Test()
{
var testMethodName = "Test";
var feeAmount = 100;
var methodFees = new MethodFees
{
MethodName = testMethodName,
Fees =
{
new MethodFee
{
BasicFee = feeAmount,
Symbol = "ELF"
}
}
};
var methodFeeController = await TokenHolderContractStub.GetMethodFeeController.CallAsync(new Empty());
var proposalId = await CreateProposalAsync(TokenHolderContractAddress,
methodFeeController.OwnerAddress, nameof(TokenHolderContractStub.SetMethodFee), methodFees);
await ApproveWithMinersAsync(proposalId);
await ParliamentContractStub.Release.SendAsync(proposalId);
var getMethodFee = await TokenHolderContractStub.GetMethodFee.CallAsync(new StringValue
{
Value = testMethodName
});
getMethodFee.Fees[0].BasicFee.ShouldBe(feeAmount);
}
public override Empty SetMethodFee(MethodFees input)
{
Assert(Context.Sender == GetDefaultOrganizationAddress(new Empty()));
State.TransactionFees[input.MethodName] = input;
return(new Empty());
}
public async Task SetMethodFee_Success_Test()
{
var tokenSymbol = "ELF";
var methodName = "Test";
var basicFee = 111;
var newMethodFees = new MethodFees
{
MethodName = methodName,
Fees =
{
new MethodFee
{
Symbol = tokenSymbol,
BasicFee = basicFee
}
}
};
const string proposalCreationMethodName = nameof(TreasuryContractStub.SetMethodFee);
await ExecuteProposalForParliamentTransaction(Tester, TreasuryContractAddress, proposalCreationMethodName,
newMethodFees);
var getMethodFee = await TreasuryContractStub.GetMethodFee.CallAsync(new StringValue
{
Value = methodName
});
getMethodFee.Fees.Count.ShouldBe(1);
getMethodFee.Fees[0].Symbol.ShouldBe(tokenSymbol);
getMethodFee.Fees[0].BasicFee.ShouldBe(basicFee);
}
public override Empty SetMethodFee(MethodFees input)
{
Assert(Context.Sender == GetGenesisOwnerAddress(new Empty()));
State.TransactionFees[input.MethodName] = input;
return(new Empty());
}
public override Empty SetMethodFee(MethodFees input)
{
foreach (var methodFee in input.Fees)
{
AssertValidToken(methodFee.Symbol, methodFee.BasicFee);
}
RequiredMethodFeeControllerSet();
Assert(Context.Sender == State.MethodFeeController.Value.OwnerAddress, "Unauthorized to set method fee.");
State.TransactionFees[input.MethodName] = input;
return(new Empty());
}
public override Empty SetMethodFee(MethodFees input)
{
if (State.ParliamentAuthContract.Value == null)
{
State.ParliamentAuthContract.Value =
Context.GetContractAddressByName(SmartContractConstants.ParliamentAuthContractSystemName);
}
Assert(Context.Sender == State.ParliamentAuthContract.GetDefaultOrganizationAddress.Call(new Empty()));
State.TransactionFees[input.MethodName] = input;
return(new Empty());
}
public override Empty SetMethodFee(MethodFees input)
{
if (State.MethodFeeController.Value == null)
{
throw new AssertionException("Need to set method fee controller before setting method fee.");
}
Assert(Context.Sender == State.MethodFeeController.Value.OwnerAddress,
"Only Owner can change method fee controller.");
State.TransactionFees[input.MethodName] = new MethodFees
{
Fees = { input.Fees }
};
return(new Empty());
}
public async Task Set_Repeat_Token_Test()
{
await IssueTokenAsync(NativeTokenSymbol, 100000_00000000);
await SetPrimaryTokenSymbolAsync();
var address = DefaultSender;
var methodName = nameof(TokenContractContainer.TokenContractStub.Transfer);
var basicMethodFee = 1000;
var methodFee = new MethodFees
{
MethodName = methodName,
Fees =
{
new MethodFee
{
Symbol = NativeTokenSymbol,
BasicFee = basicMethodFee
},
new MethodFee
{
Symbol = NativeTokenSymbol,
BasicFee = basicMethodFee
}
}
};
var sizeFee = 0;
await SubmitAndPassProposalOfDefaultParliamentAsync(TokenContractAddress,
nameof(TokenContractImplContainer.TokenContractImplStub.SetMethodFee), methodFee);
var beforeChargeBalance = await GetBalanceAsync(address, NativeTokenSymbol);
var chargeTransactionFeesInput = new ChargeTransactionFeesInput
{
MethodName = methodName,
ContractAddress = TokenContractAddress,
TransactionSizeFee = sizeFee,
};
var chargeFeeRet = await TokenContractStub.ChargeTransactionFees.SendAsync(chargeTransactionFeesInput);
chargeFeeRet.Output.Success.ShouldBeTrue();
var afterChargeBalance = await GetBalanceAsync(address, NativeTokenSymbol);
beforeChargeBalance.Sub(afterChargeBalance).ShouldBe(basicMethodFee.Add(basicMethodFee));
}
private Dictionary <string, long> GetBaseFeeDictionary(MethodFees methodFees)
{
var dict = new Dictionary <string, long>();
foreach (var methodFee in methodFees.Fees)
{
if (dict.ContainsKey(methodFee.Symbol))
{
dict[methodFee.Symbol] = dict[methodFee.Symbol].Add(methodFee.BasicFee);
}
else
{
dict[methodFee.Symbol] = methodFee.BasicFee;
}
}
return(dict);
}
public async Task GetMethodFee_Fix_Fee_Test(params string[] defaultSetMethodNames)
{
var methodFeeController = await TokenContractStub.GetMethodFeeController.CallAsync(new Empty());
string proposalMethodName = nameof(TokenContractStub.SetMethodFee);
await CreateNativeTokenAsync();
var tokenSymbol = NativeTokenInfo.Symbol;
var basicFee = 100;
foreach (var methodName in defaultSetMethodNames)
{
var beforeFee = (await TokenContractStub.GetMethodFee.CallAsync(new StringValue
{
Value = methodName
})).Fees.SingleOrDefault(x => x.Symbol == tokenSymbol);
var methodFees = new MethodFees
{
MethodName = methodName,
Fees =
{
new MethodFee {
Symbol = tokenSymbol, BasicFee = basicFee
}
}
};
var proposalId = await CreateProposalAsync(TokenContractAddress,
methodFeeController.OwnerAddress, proposalMethodName, methodFees);
await ApproveWithMinersAsync(proposalId);
var releaseResult = await ParliamentContractStub.Release.SendAsync(proposalId);
releaseResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
var updatedFee = (await TokenContractStub.GetMethodFee.CallAsync(new StringValue
{
Value = methodName
})).Fees.SingleOrDefault(x => x.Symbol == tokenSymbol);
updatedFee.BasicFee.ShouldBe(beforeFee.BasicFee);
}
}
public async Task SetMethodFee_Success_Test()
{
await CreateNativeTokenAsync();
var methodName = "Transfer";
var tokenSymbol = NativeTokenInfo.Symbol;
var basicFee = 100;
var methodFeeController = await TokenContractStub.GetMethodFeeController.CallAsync(new Empty());
string proposalMethodName = nameof(TokenContractStub.SetMethodFee);
var methodFees = new MethodFees
{
MethodName = methodName,
Fees =
{
new MethodFee {
Symbol = tokenSymbol, BasicFee = basicFee
}
}
};
var proposalId = await CreateProposalAsync(TokenContractAddress,
methodFeeController.OwnerAddress, proposalMethodName, methodFees);
await ApproveWithMinersAsync(proposalId);
var releaseResult = await ParliamentContractStub.Release.SendAsync(proposalId);
releaseResult.TransactionResult.Error.ShouldBeNullOrEmpty();
releaseResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
var afterUpdateMethodFees = await TokenContractStub.GetMethodFee.CallAsync(new StringValue
{
Value = methodName
});
var tokenFee = afterUpdateMethodFees.Fees.SingleOrDefault(x => x.Symbol == tokenSymbol);
tokenFee.BasicFee.ShouldBe(basicFee);
}
public async Task SetMethodFee_With_Invalid_Input_Test()
{
var methodFees = new MethodFees
{
MethodName = "Test",
Fees =
{
new MethodFee
{
BasicFee = 100,
Symbol = "NOTEXIST"
}
}
};
var setMethodFeeRet = await TokenHolderContractStub.SetMethodFee.SendWithExceptionAsync(methodFees);
setMethodFeeRet.TransactionResult.Error.ShouldContain("Token is not found");
methodFees.Fees[0].Symbol = "ELF";
methodFees.Fees[0].BasicFee = -1;
setMethodFeeRet = await TokenHolderContractStub.SetMethodFee.SendWithExceptionAsync(methodFees);
setMethodFeeRet.TransactionResult.Error.ShouldContain("Invalid amount");
}
private bool IsMethodFeeSetToZero(MethodFees methodFees)
{
return(!string.IsNullOrEmpty(methodFees.MethodName) &&
(methodFees.Fees == null || !methodFees.Fees.Any() || methodFees.Fees.All(x => x.BasicFee == 0)));
}
public async Task ChargeTransactionFees_With_Different_Transaction_Size_Fee_Token(int[] order, long[] balance,
int[] baseWeight, int[] tokenWeight, long sizeFee, string chargeSymbol, long chargeAmount, bool isSuccess)
{
await SetPrimaryTokenSymbolAsync();
var methodName = nameof(TokenContractContainer.TokenContractStub.Transfer);
var basicMethodFee = 1000;
var methodFee = new MethodFees
{
MethodName = methodName,
Fees =
{
new MethodFee
{
Symbol = NativeTokenSymbol,
BasicFee = basicMethodFee
}
}
};
await SubmitAndPassProposalOfDefaultParliamentAsync(TokenContractAddress,
nameof(TokenContractImplContainer.TokenContractImplStub.SetMethodFee), methodFee);
var tokenSymbolList = new [] { NativeTokenSymbol, "CWJ", "YPA" };
var tokenCount = 3;
var orderedSymbolList = new string[tokenCount];
var index = 0;
foreach (var o in order)
{
orderedSymbolList[index++] = tokenSymbolList[o - 1];
}
var sizeFeeSymbolList = new SymbolListToPayTxSizeFee();
for (var i = 0; i < tokenCount; i++)
{
var tokenSymbol = orderedSymbolList[i];
if (tokenSymbol != NativeTokenSymbol)
{
await CreateTokenAsync(DefaultSender, tokenSymbol);
}
if (balance[i] > 0)
{
await IssueTokenAsync(tokenSymbol, balance[i]);
}
sizeFeeSymbolList.SymbolsToPayTxSizeFee.Add(new SymbolToPayTxSizeFee
{
TokenSymbol = tokenSymbol,
AddedTokenWeight = tokenWeight[i],
BaseTokenWeight = baseWeight[i]
});
}
await SubmitAndPassProposalOfDefaultParliamentAsync(TokenContractAddress,
nameof(TokenContractImplContainer.TokenContractImplStub.SetSymbolsToPayTxSizeFee), sizeFeeSymbolList);
var beforeBalanceList = await GetDefaultBalancesAsync(orderedSymbolList);
var chargeTransactionFeesInput = new ChargeTransactionFeesInput
{
MethodName = methodName,
ContractAddress = TokenContractAddress,
TransactionSizeFee = sizeFee,
};
chargeTransactionFeesInput.SymbolsToPayTxSizeFee.AddRange(sizeFeeSymbolList.SymbolsToPayTxSizeFee);
var chargeFeeRet = await TokenContractStub.ChargeTransactionFees.SendAsync(chargeTransactionFeesInput);
chargeFeeRet.Output.Success.ShouldBe(isSuccess);
var afterBalanceList = await GetDefaultBalancesAsync(orderedSymbolList);
for (var i = 0; i < tokenCount; i++)
{
var balanceDiff = beforeBalanceList[i] - afterBalanceList[i];
if (orderedSymbolList[i] == chargeSymbol)
{
balanceDiff.ShouldBe(chargeAmount);
}
else
{
if (orderedSymbolList[i] == NativeTokenSymbol)
{
balanceDiff -= basicMethodFee;
}
balanceDiff.ShouldBe(0);
}
}
}
public override Empty SetMethodFee(MethodFees input)
{
State.TransactionFees[input.MethodName] = input;
return(new Empty());
}
public override Empty SetMethodFee(MethodFees input)
{
return(new Empty());
}
