public async Task CanGetStatefulContractBytecode()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var bytecode = await fx.Client.GetContractBytecodeAsync(fx.ContractRecord.Contract);
Assert.False(bytecode.IsEmpty);
}
public async Task CanRetrieveRecordFromContractCreateRemoved()
{
await using var fxContract = await StatefulContract.CreateAsync(_network);
var records = await fxContract.Client.GetContractRecordsAsync(fxContract.ContractRecord.Contract);
Assert.NotNull(records);
Assert.Empty(records);
}
public async Task CanGetStatefulContractAddressFromSmartContractAddress()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var info = await fx.Client.GetContractInfoAsync(fx.ContractRecord.Contract);
var address = await fx.Client.GetAddressFromSmartContractId(info.SmartContractId);
Assert.Equal(fx.ContractRecord.Contract, address);
}
public async Task CanCreateAContractWithParameters()
{
await using var fx = await StatefulContract.CreateAsync(_network);
Assert.NotNull(fx.ContractRecord);
Assert.NotNull(fx.ContractRecord.Contract);
Assert.Equal(ResponseCode.Success, fx.ContractRecord.Status);
Assert.NotEmpty(fx.ContractRecord.Hash.ToArray());
Assert.NotNull(fx.ContractRecord.Concensus);
Assert.NotNull(fx.ContractRecord.Memo);
Assert.InRange(fx.ContractRecord.Fee, 0UL, ulong.MaxValue);
}
public async Task ContractWithNoRecords()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var transactionCount = Generator.Integer(2, 5);
for (int i = 0; i < transactionCount; i++)
{
await fx.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = 30_000,
FunctionName = "get_message"
});
public async Task CanGetCreateContractRecipt()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var receipt = await fx.Client.GetReceiptAsync(fx.ContractRecord.Id);
var createRecipt = Assert.IsType <CreateContractReceipt>(receipt);
Assert.Equal(fx.ContractRecord.Id, createRecipt.Id);
Assert.Equal(fx.ContractRecord.Status, createRecipt.Status);
Assert.Equal(fx.ContractRecord.CurrentExchangeRate, createRecipt.CurrentExchangeRate);
Assert.Equal(fx.ContractRecord.NextExchangeRate, createRecipt.NextExchangeRate);
Assert.Equal(fx.ContractRecord.Contract, createRecipt.Contract);
}
public async Task CreateWithoutRequiredContractParamsThrowsError()
{
var ex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await StatefulContract.CreateAsync(_network, async fx =>
{
fx.ContractParams.Arguments = null;
await fx.Client.CreateContractAsync(fx.ContractParams);
});
});
Assert.StartsWith("Unable to create contract, status: ContractRevertExecuted", ex.Message);
Assert.Equal(ResponseCode.ContractRevertExecuted, ex.Status);
}
public async Task CanCreateAContractWithStateAlternateSignatoryAsync()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var receipt = await fx.Client.CallContractAsync(new CallContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "get_message",
Signatory = _network.PrivateKey
}, ctx => ctx.Signatory = null);
Assert.NotNull(receipt);
Assert.Equal(ResponseCode.Success, receipt.Status);
}
public async Task CanGetStatefulContractInfo()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var info = await fx.Client.GetContractInfoAsync(fx.ContractRecord.Contract);
Assert.NotNull(info);
Assert.Equal(fx.ContractRecord.Contract, info.Contract);
Assert.Equal(fx.ContractRecord.Contract, info.Address); // Assume for now they are equal
Assert.NotNull(info.SmartContractId);
Assert.Equal(fx.ContractParams.Administrator, info.Administrator);
Assert.InRange(info.Expiration, DateTime.UtcNow, DateTime.MaxValue);
Assert.Equal(fx.ContractParams.RenewPeriod, info.RenewPeriod);
Assert.InRange(info.Size, 0, fx.FileParams.Contents.Length);
Assert.StartsWith("Stateful Contract Create: Instantiating Stateful Instance", info.Memo);
}
public async Task CanRetrieveRecordFromContractCreate()
{
await using var fxContract = await StatefulContract.CreateAsync(_network);
var records = await fxContract.Client.GetContractRecordsAsync(fxContract.ContractRecord.Contract);
Assert.NotNull(records);
Assert.Single(records);
var record = records[0];
Assert.Equal(ResponseCode.Success, record.Status);
Assert.Equal(fxContract.ContractRecord.Id, record.Id);
Assert.InRange(record.Fee, 0UL, ulong.MaxValue);
Assert.StartsWith("Stateful Contract Create: Instantiating Stateful Instance", record.Memo);
Assert.NotNull(record.Concensus);
Assert.False(record.Hash.IsEmpty);
}
public async Task CanCreateAContractAndSetStateAsync()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var newMessage = Generator.Code(50);
var setRecord = await fx.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(1200),
FunctionName = "set_message",
FunctionArgs = new object[] { newMessage }
}, ctx => ctx.Memo = "Call Contract");
Assert.NotNull(setRecord);
Assert.Equal(ResponseCode.Success, setRecord.Status);
Assert.False(setRecord.Hash.IsEmpty);
Assert.NotNull(setRecord.Concensus);
Assert.Equal("Call Contract", setRecord.Memo);
Assert.InRange(setRecord.Fee, 0UL, ulong.MaxValue);
Assert.Empty(setRecord.CallResult.Error);
Assert.True(setRecord.CallResult.Bloom.IsEmpty);
Assert.InRange(setRecord.CallResult.Gas, 0UL, 50_000UL);
Assert.Empty(setRecord.CallResult.Events);
Assert.Empty(setRecord.CallResult.CreatedContracts);
var getRecord = await fx.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "get_message"
});
Assert.NotNull(getRecord);
Assert.Equal(ResponseCode.Success, getRecord.Status);
Assert.False(getRecord.Hash.IsEmpty);
Assert.NotNull(getRecord.Concensus);
Assert.Empty(getRecord.Memo);
Assert.InRange(getRecord.Fee, 0UL, ulong.MaxValue);
Assert.Empty(getRecord.CallResult.Error);
Assert.True(getRecord.CallResult.Bloom.IsEmpty);
Assert.InRange(getRecord.CallResult.Gas, 0UL, 30_000UL);
Assert.Empty(getRecord.CallResult.Events);
Assert.Empty(getRecord.CallResult.CreatedContracts);
Assert.Equal(newMessage, getRecord.CallResult.Result.As <string>());
Assert.InRange(getRecord.CallResult.Gas, 0UL, 30_000UL);
}
public async Task CanCreateAContractWithStateAsync()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var result = await fx.Client.QueryContractAsync(new QueryContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
ReturnValueCharge = await _network.TinybarsFromGas(400),
FunctionName = "get_message"
});
Assert.NotNull(result);
Assert.Empty(result.Error);
Assert.True(result.Bloom.IsEmpty);
Assert.InRange(result.Gas, 0UL, ulong.MaxValue);
Assert.Empty(result.Events);
Assert.Equal(fx.ContractParams.Arguments[0] as string, result.Result.As <string>());
}
public async Task CanCreateAContractAndSetStateAsync()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var newMessage = Generator.Code(50);
var qex = await Assert.ThrowsAsync <ContractException>(async() =>
{
await fx.Client.QueryContractAsync(new QueryContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = 30000,
FunctionName = "set_message",
FunctionArgs = new object[] { newMessage },
ReturnValueCharge = 900
});
});
Assert.Equal(ResponseCode.LocalCallModificationException, qex.Status);
Assert.StartsWith("Contract Query Failed with Code: LocalCallModificationException", qex.Message);
}
public async Task CanCreateAContractAndSetStateAsync()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var newMessage = Generator.Code(50);
var pex = await Assert.ThrowsAsync <PrecheckException>(async() =>
{
await fx.Client.QueryContractAsync(new QueryContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "set_message",
FunctionArgs = new object[] { newMessage },
ReturnValueCharge = 900
});
});
Assert.Equal(ResponseCode.LocalCallModificationException, pex.Status);
Assert.StartsWith("Transaction Failed Pre-Check: LocalCallModificationException", pex.Message);
}
public async Task CanRetrieveRecordsFromContractMethodCalls()
{
await using var fxContract = await StatefulContract.CreateAsync(_network);
var transactionCount = Generator.Integer(2, 3);
for (int i = 0; i < transactionCount; i++)
{
await fxContract.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fxContract.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "get_message"
});
}
var records = await fxContract.Client.GetContractRecordsAsync(fxContract.ContractRecord.Contract);
Assert.NotNull(records);
Assert.Empty(records);
}
public async Task CanCreateAContractWithParameters()
{
await using var fx = await StatefulContract.CreateAsync(_network);
Assert.NotNull(fx.ContractRecord);
Assert.NotNull(fx.ContractRecord.Contract);
Assert.Equal(ResponseCode.Success, fx.ContractRecord.Status);
Assert.NotEmpty(fx.ContractRecord.Hash.ToArray());
Assert.NotNull(fx.ContractRecord.Concensus);
Assert.NotNull(fx.ContractRecord.Memo);
Assert.InRange(fx.ContractRecord.Fee, 0UL, ulong.MaxValue);
Assert.Empty(fx.ContractRecord.CallResult.Error);
Assert.True(fx.ContractRecord.CallResult.Bloom.IsEmpty);
Assert.InRange(fx.ContractRecord.CallResult.Gas, 0UL, (ulong)fx.ContractParams.Gas);
Assert.Empty(fx.ContractRecord.CallResult.Events);
Assert.Empty(fx.ContractRecord.CallResult.CreatedContracts);
Assert.Equal(0, fx.ContractRecord.CallResult.Result.Size);
Assert.True(fx.ContractRecord.CallResult.Result.Data.IsEmpty);
}
public async Task ErrorQueryContractWithoutFlagReturnsWithoutError()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var result = await fx.Client.QueryContractAsync(new QueryContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = 1,
ReturnValueCharge = 4000,
FunctionName = "get_message",
ThrowOnFail = false
});
Assert.NotNull(result);
Assert.Equal("INSUFFICIENT_GAS", result.Error);
Assert.False(result.Bloom.IsEmpty);
Assert.InRange(result.Gas, 0UL, ulong.MaxValue);
Assert.Empty(result.Events);
Assert.Equal(0, result.Result.Size);
Assert.Empty(result.CreatedContracts);
}
public async Task ErrorQueryContractWithoutFlagReturnsWithoutError()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var result = await fx.Client.QueryContractAsync(new QueryContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = 1,
ReturnValueCharge = await _network.TinybarsFromGas(400),
FunctionName = "get_message",
ThrowOnFail = false
});
Assert.NotNull(result);
Assert.Equal("Not enough gas for 'PUSH1' cause spending: invokeGas[1], gas[3], usedGas[0];", result.Error);
Assert.True(result.Bloom.IsEmpty);
Assert.InRange(result.Gas, 0UL, ulong.MaxValue);
Assert.Empty(result.Events);
Assert.Equal(0, result.Result.Size);
Assert.Empty(result.CreatedContracts);
}
public async Task CanGetImutableStatefulContractInfo()
{
await using var fx = await StatefulContract.CreateAsync(_network, f =>
{
f.ContractParams.Administrator = null;
});
var info = await fx.Client.GetContractInfoAsync(fx.ContractRecord.Contract);
Assert.NotNull(info);
Assert.Equal(fx.ContractRecord.Contract, info.Contract);
Assert.Equal(fx.ContractRecord.Contract, info.Address); // Assume for now they are equal
Assert.NotNull(info.SmartContractId);
// Immutable Contracts list their "contract" key as the administrator Key.
Assert.Equal(KeyType.Contract, info.Administrator.Type);
Assert.Equal(Abi.EncodeAddressPart(info.Contract).ToArray(), info.Administrator.PublicKey.ToArray());
Assert.InRange(info.Expiration, DateTime.UtcNow, DateTime.MaxValue);
Assert.Equal(fx.ContractParams.RenewPeriod, info.RenewPeriod);
Assert.InRange(info.Size, 0, fx.FileParams.Contents.Length);
Assert.StartsWith(fx.ContractParams.Memo, info.Memo);
Assert.Equal((ulong)fx.ContractParams.InitialBalance, info.Balance);
}
public async Task CanNotScheduleCallContract()
{
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
await using var fxContract = await StatefulContract.CreateAsync(_network);
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxContract.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fxContract.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "get_message",
Signatory = new PendingParams {
PendingPayer = fxPayer
}
});
});
Assert.Equal(ResponseCode.ScheduledTransactionNotInWhitelist, tex.Status);
Assert.StartsWith("Unable to schedule transaction, status: ScheduledTransactionNotInWhitelist", tex.Message);
}
public async Task CanCreateAContractWithStateAsync()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var record = await fx.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "get_message"
}, ctx => ctx.Memo = "Call Contract");
Assert.NotNull(record);
Assert.Equal(ResponseCode.Success, record.Status);
Assert.False(record.Hash.IsEmpty);
Assert.NotNull(record.Concensus);
Assert.Equal("Call Contract", record.Memo);
Assert.InRange(record.Fee, 0UL, ulong.MaxValue);
Assert.Empty(record.CallResult.Error);
Assert.True(record.CallResult.Bloom.IsEmpty);
Assert.InRange(record.CallResult.Gas, 0UL, 30_000UL);
Assert.Empty(record.CallResult.Events);
Assert.Equal(fx.ContractParams.Arguments[0] as string, record.CallResult.Result.As <string>());
}
public async Task CallQueryAttemptingStateChangeFailsWithoutErrorWhenThrowOnFailFalse()
{
await using var fx = await StatefulContract.CreateAsync(_network);
var newMessage = Generator.Code(50);
var result = await fx.Client.QueryContractAsync(new QueryContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = 30000,
FunctionName = "set_message",
FunctionArgs = new object[] { newMessage },
ReturnValueCharge = 900,
ThrowOnFail = false
});
Assert.NotNull(result);
Assert.Equal("ILLEGAL_STATE_CHANGE", result.Error);
Assert.False(result.Bloom.IsEmpty);
Assert.InRange(result.Gas, 0UL, ulong.MaxValue);
Assert.Empty(result.Events);
Assert.Equal(0, result.Result.Size);
Assert.Empty(result.CreatedContracts);
}
