public void TestGreetingContract()
{
var serializer = new MyNoSqlTcpSerializer();
var testContract = new GreetingContract
{
Name = "Test"
};
var rawData = serializer.Serialize(testContract);
var memStream = new MemoryStream(rawData.ToArray())
{
Position = 0
};
var dataReader = new TcpDataReader();
dataReader.NewPackage(memStream.ToArray());
var result
= (GreetingContract)serializer
.DeserializeAsync(dataReader)
.AsTestResult();
Assert.AreEqual(testContract.Name, result.Name);
}
protected override ValueTask OnConnectAsync()
{
var readerVersion = GetReaderVersion.Value;
readerVersion = readerVersion == null ? "" : ";ReaderVersion:" + readerVersion;
var greetingsContract = new GreetingContract
{
Name = _appName + readerVersion
};
SendDataToSocket(greetingsContract);
foreach (var tableToSubscribe in _subscriber.GetTablesToSubscribe())
{
var subscribePacket = new SubscribeContract
{
TableName = tableToSubscribe
};
SendDataToSocket(subscribePacket);
Console.WriteLine("Subscribed to MyNoSql table: " + tableToSubscribe);
}
return(new ValueTask());
}
public async Task UpdateContractExpirationDate()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var oldExpiration = (await fx.Client.GetContractInfoAsync(fx.ContractRecord.Contract)).Expiration;
var newExpiration = oldExpiration.AddMonths(12);
var record = await fx.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Contract = fx.ContractRecord.Contract,
Expiration = newExpiration
});
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);
// This is what it should be.
//Assert.Equal(newExpiration, info.Expiration);
// This is what it is
Assert.Equal(oldExpiration, info.Expiration);
Assert.Equal(_network.PublicKey, info.Administrator);
Assert.Equal(fx.ContractParams.RenewPeriod, info.RenewPeriod);
Assert.Equal(fx.Memo, info.Memo);
}
public async Task CanAssociateTokenWithContract()
{
await using var fxContract = await GreetingContract.CreateAsync(_network);
await using var fxToken = await TestToken.CreateAsync(_network);
// Assert Not Associated
var info = await fxContract.Client.GetContractInfoAsync(fxContract);
Assert.Null(info.Tokens.FirstOrDefault(t => t.Token == fxToken.Record.Token));
var receipt = await fxContract.Client.AssociateTokenAsync(fxToken.Record.Token, fxContract.ContractRecord.Contract, fxContract.PrivateKey);
Assert.Equal(ResponseCode.Success, receipt.Status);
info = await fxContract.Client.GetContractInfoAsync(fxContract);
var association = info.Tokens.FirstOrDefault(t => t.Token == fxToken.Record.Token);
Assert.NotNull(association);
Assert.Equal(fxToken.Record.Token, association.Token);
Assert.Equal(fxToken.Params.Symbol, association.Symbol);
Assert.Equal(0UL, association.Balance);
Assert.Equal(TokenKycStatus.Revoked, association.KycStatus);
Assert.Equal(TokenTradableStatus.Tradable, association.TradableStatus);
}
public async Task CanUpdateContractBytecode()
{
await using var fx = await GreetingContract.CreateAsync(_network);
await using var fx2 = await StatefulContract.SetupAsync(_network);
var record = await fx.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Contract = fx.ContractRecord.Contract,
File = fx2.FileRecord.File
});
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);
Assert.Equal(fx.ContractParams.Administrator, info.Administrator);
Assert.Equal(fx.ContractParams.RenewPeriod, info.RenewPeriod);
Assert.Equal(fx.Memo, info.Memo);
// Call a method that was not part of the original contract to check update.
// Note, this is a bug with the network, the call returned success but we are still
// able to call the old contract method which should no longer exist.
var callRecord = await fx.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = 30_000,
FunctionName = "greet",
});
public async Task CanUpdateAdminKey()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var(newPublicKey, newPrivateKey) = Generator.KeyPair();
var newEndorsement = new Endorsement(newPublicKey);
var updatedSignatory = new Signatory(_network.Signatory, newPrivateKey);
fx.Client.Configure(ctx => ctx.Signatory = updatedSignatory);
var record = await fx.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Contract = fx.ContractRecord.Contract,
Administrator = newEndorsement,
});
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);
Assert.Equal(newEndorsement, info.Administrator);
Assert.Equal(fx.ContractParams.RenewPeriod, info.RenewPeriod);
Assert.Equal(fx.Memo, info.Memo);
Assert.Equal((ulong)fx.ContractParams.InitialBalance, info.Balance);
}
public async Task CanUpdateRenewPeriod()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var newRenewal = TimeSpan.FromDays(Generator.Integer(180, 365));
var pex = await Assert.ThrowsAsync <PrecheckException>(async() =>
{
var record = await fx.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Contract = fx.ContractRecord.Contract,
RenewPeriod = newRenewal,
});
});
Assert.Equal(ResponseCode.AutorenewDurationNotInRange, pex.Status);
Assert.StartsWith("Transaction Failed Pre-Check: AutorenewDurationNotInRange", pex.Message);
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);
Assert.Equal(fx.ContractParams.Administrator, info.Administrator);
Assert.Equal(fx.ContractParams.RenewPeriod, info.RenewPeriod);
Assert.Equal(fx.Memo, info.Memo);
Assert.Equal((ulong)fx.ContractParams.InitialBalance, info.Balance);
}
public async Task CanGetCallContractRecord()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var record1 = await fx.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "greet"
}, ctx => ctx.Memo = "Call Contract");
var record2 = await fx.Client.GetTransactionRecordAsync(record1.Id);
var callRecord = Assert.IsType <CallContractRecord>(record2);
Assert.Equal(record1.Id, callRecord.Id);
Assert.Equal(record1.Status, callRecord.Status);
Assert.Equal(record1.CurrentExchangeRate, callRecord.CurrentExchangeRate);
Assert.Equal(record1.NextExchangeRate, callRecord.NextExchangeRate);
Assert.Equal(record1.Hash.ToArray(), callRecord.Hash.ToArray());
Assert.Equal(record1.Concensus, callRecord.Concensus);
Assert.Equal(record1.Memo, callRecord.Memo);
Assert.Equal(record1.Fee, callRecord.Fee);
Assert.Equal(record1.CallResult.Error, callRecord.CallResult.Error);
Assert.Equal(record1.CallResult.Bloom, callRecord.CallResult.Bloom);
Assert.Equal(record1.CallResult.Gas, callRecord.CallResult.Gas);
Assert.Equal(record1.CallResult.Events, callRecord.CallResult.Events);
Assert.Equal(record1.CallResult.CreatedContracts, callRecord.CallResult.CreatedContracts);
Assert.Equal(record1.CallResult.Result.As <string>(), callRecord.CallResult.Result.As <string>());
}
public async Task CanUpdateTreasuryToContract()
{
await using var fxContract = await GreetingContract.CreateAsync(_network);
await using var fxToken = await TestToken.CreateAsync(_network);
// Note: Contract did not need to sign.
await fxContract.Client.AssociateTokenAsync(fxToken, fxContract, fxContract.PrivateKey);
var updateParams = new UpdateTokenParams
{
Token = fxToken.Record.Token,
Treasury = fxContract.ContractRecord.Contract,
Signatory = new Signatory(fxToken.AdminPrivateKey, fxContract.PrivateKey)
};
var receipt = await fxToken.Client.UpdateTokenAsync(updateParams);
Assert.Equal(ResponseCode.Success, receipt.Status);
var info = await fxToken.Client.GetTokenInfoAsync(fxToken.Record.Token);
Assert.Equal(fxContract.ContractRecord.Contract, info.Treasury);
Assert.Equal(fxToken.Params.Circulation, await fxToken.Client.GetContractTokenBalanceAsync(fxContract, fxToken));
}
public async Task CanUpdateMultiplePropertiesInOneCall()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var(newPublicKey, newPrivateKey) = Generator.KeyPair();
var newExpiration = Generator.TruncatedFutureDate(2400, 4800);
var newEndorsement = new Endorsement(newPublicKey);
var newRenewal = TimeSpan.FromDays(Generator.Integer(60, 90));
var updatedPayer = _network.PayerWithKeys(newPrivateKey);
var newMemo = Generator.Code(50);
fx.Client.Configure(ctx => ctx.Payer = updatedPayer);
var record = await fx.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Contract = fx.ContractRecord.Contract,
Expiration = newExpiration,
Administrator = newEndorsement,
RenewPeriod = newRenewal,
Memo = newMemo
});
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);
//Assert.Equal(newExpiration, info.Expiration);
Assert.Equal(newEndorsement, info.Administrator);
Assert.Equal(newRenewal, info.RenewPeriod);
Assert.Equal(newMemo, info.Memo);
}
public async Task CanNotScheduleDelete()
{
var systemAddress = await _network.GetSystemDeleteAdminAddress();
if (systemAddress is null)
{
_network.Output?.WriteLine("TEST SKIPPED: No access to System Delete Administrator Account.");
return;
}
await using var fxContract = await GreetingContract.CreateAsync(_network);
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxContract.Client.SystemDeleteContractAsync(
fxContract.ContractRecord.Contract,
ctx =>
{
ctx.Payer = systemAddress;
ctx.Signatory = new Signatory(
_network.PrivateKey,
new PendingParams {
PendingPayer = fxPayer
}
);
});
});
Assert.Equal(ResponseCode.ScheduledTransactionNotInWhitelist, tex.Status);
Assert.StartsWith("Unable to schedule transaction, status: ScheduledTransactionNotInWhitelist", tex.Message);
}
public async Task CanNotScheduleUpdate()
{
await using var fxContract = await GreetingContract.CreateAsync(_network);
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
var newMemo = Generator.Code(50);
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxContract.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Contract = fxContract.ContractRecord.Contract,
Memo = newMemo,
Signatory = new Signatory(
fxContract.PrivateKey,
new PendingParams {
PendingPayer = fxPayer
}
)
});
});
Assert.Equal(ResponseCode.ScheduledTransactionNotInWhitelist, tex.Status);
Assert.StartsWith("Unable to schedule transaction, status: ScheduledTransactionNotInWhitelist", tex.Message);
}
public async Task CanTransferTokensToContract()
{
await using var fxContract = await GreetingContract.CreateAsync(_network);
await using var fxToken = await TestToken.CreateAsync(_network, fx =>
{
fx.Params.GrantKycEndorsement = null;
fx.Params.InitializeSuspended = false;
});
await fxContract.Client.AssociateTokenAsync(fxToken.Record.Token, fxContract.ContractRecord.Contract, fxContract.PrivateKey);
var xferAmount = fxToken.Params.Circulation / 3;
var receipt = await fxContract.Client.TransferTokensAsync(fxToken, fxToken.TreasuryAccount, fxContract.ContractRecord.Contract, (long)xferAmount, fxToken.TreasuryAccount.PrivateKey);
Assert.Equal(ResponseCode.Success, receipt.Status);
var info = await fxContract.Client.GetContractInfoAsync(fxContract);
var association = info.Tokens.FirstOrDefault(t => t.Token == fxToken.Record.Token);
Assert.NotNull(association);
Assert.Equal(fxToken.Record.Token, association.Token);
Assert.Equal(fxToken.Params.Symbol, association.Symbol);
Assert.Equal(xferAmount, association.Balance);
Assert.Equal(TokenKycStatus.NotApplicable, association.KycStatus);
Assert.Equal(TokenTradableStatus.Tradable, association.TradableStatus);
}
public async Task CanDeleteContract()
{
var systemAddress = await _network.GetSystemDeleteAdminAddress();
if (systemAddress is null)
{
_network.Output?.WriteLine("TEST SKIPPED: No access to System Delete Administrator Account.");
return;
}
await using var fx = await GreetingContract.CreateAsync(_network);
var receipt = await fx.Client.SystemDeleteContractAsync(fx.ContractRecord.Contract, ctx => ctx.Payer = systemAddress);
Assert.Equal(ResponseCode.Success, receipt.Status);
// But you still can't get the info
var pex = await Assert.ThrowsAsync <PrecheckException>(async() =>
{
await fx.Client.GetContractInfoAsync(fx.ContractRecord.Contract);
});
Assert.Equal(ResponseCode.ContractDeleted, pex.Status);
Assert.StartsWith("Transaction Failed Pre-Check: ContractDeleted", pex.Message);
}
public async Task CanUpdateMultiplePropertiesInOneCall()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var(newPublicKey, newPrivateKey) = Generator.KeyPair();
var newExpiration = Generator.TruncatedFutureDate(2400, 4800);
var newEndorsement = new Endorsement(newPublicKey);
var updatedSignatory = new Signatory(_network.Signatory, newPrivateKey);
var newMemo = Generator.Code(50);
fx.Client.Configure(ctx => ctx.Signatory = updatedSignatory);
var record = await fx.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Contract = fx.ContractRecord.Contract,
Expiration = newExpiration,
Administrator = newEndorsement,
Memo = newMemo
});
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);
Assert.Equal(newExpiration, info.Expiration);
Assert.Equal(newEndorsement, info.Administrator);
Assert.Equal(fx.ContractParams.RenewPeriod, info.RenewPeriod);
Assert.Equal(newMemo, info.Memo);
Assert.Equal((ulong)fx.ContractParams.InitialBalance, info.Balance);
}
public async Task UpdatingContractWithoutAdminKeyRaisesError()
{
var(publicKey, privateKey) = Generator.KeyPair();
await using var fx = await GreetingContract.SetupAsync(_network);
fx.ContractParams.Administrator = publicKey;
fx.Client.Configure(ctx => ctx.Signatory = new Signatory(ctx.Signatory, privateKey));
await fx.CompleteCreateAsync();
// First, Remove admin key from Payer's Account
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
fx.Client.Configure(ctx => ctx.Signatory = new Signatory(_network.PrivateKey));
await fx.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Contract = fx.ContractRecord.Contract,
Memo = Generator.Code(50)
});
});
Assert.Equal(ResponseCode.InvalidSignature, tex.Status);
Assert.StartsWith("Unable to update Contract, status: InvalidSignature", tex.Message);
// Try again with the admin key to prove we have the keys right
var record = await fx.Client.UpdateContractWithRecordAsync(new UpdateContractParams
{
Signatory = new Signatory(_network.PrivateKey, privateKey),
Contract = fx.ContractRecord.Contract,
Memo = Generator.Code(50)
});
Assert.Equal(ResponseCode.Success, record.Status);
}
public async Task CanDeleteContractUsingSignatory()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var record = await fx.Client.DeleteContractAsync(fx.ContractRecord.Contract, _network.Payer, fx.PrivateKey);
Assert.Equal(ResponseCode.Success, record.Status);
}
public async Task CanGetStatelessContractBytecode()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var bytecode = await fx.Client.GetContractBytecodeAsync(fx.ContractRecord.Contract);
Assert.False(bytecode.IsEmpty);
}
public async Task DeleteContractNotYetSupported()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var record = await fx.Client.DeleteContractAsync(fx.ContractRecord.Contract, _network.Payer);
Assert.Equal(ResponseCode.Success, record.Status);
}
public async Task CanGetStatelessContractBytecode()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var bytecode = await fx.Client.GetContractBytecodeAsync(fx.ContractRecord.Contract);
_network.Output.WriteLine($"Size {fx.FileParams.Contents.Length}");
Assert.False(bytecode.IsEmpty);
}
public async Task CanCreateContractWithoutReturningRecordData()
{
await using var fx = await GreetingContract.SetupAsync(_network);
var receipt = await fx.Client.CreateContractAsync(fx.ContractParams);
Assert.NotNull(receipt);
Assert.NotNull(receipt.Contract);
Assert.Equal(ResponseCode.Success, receipt.Status);
}
public async Task CanGetStatelessContractAddressFromSmartContractAddress()
{
await using var fx = await GreetingContract.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 CanCreateAContractAsync()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var record = await fx.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fx.ContractRecord.Contract,
Gas = 30_000,
FunctionName = "greet"
});
public async Task DeleteContractWithMissingReturnToAddressRaisesError()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var ane = await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await fx.Client.DeleteContractAsync(fx.ContractRecord.Contract, null);
});
Assert.Equal("transferToAddress", ane.ParamName);
Assert.StartsWith("Transfer address is missing. Please check that it is not null.", ane.Message);
}
public async Task ContractAddressForTokenSymbolRaisesError()
{
await using var fx = await GreetingContract.CreateAsync(_network);
var pex = await Assert.ThrowsAsync <PrecheckException>(async() =>
{
await fx.Client.GetTokenInfoAsync(fx.ContractRecord.Contract);
});
Assert.Equal(ResponseCode.InvalidTokenId, pex.Status);
Assert.StartsWith("Transaction Failed Pre-Check: InvalidTokenId", pex.Message);
}
public async Task MissingFileAddressRaisesError()
{
await using var fx = await GreetingContract.SetupAsync(_network);
fx.ContractParams.File = null;
var ex = await Assert.ThrowsAsync <ArgumentNullException>(async() => {
await fx.Client.CreateContractAsync(fx.ContractParams);
});
Assert.StartsWith("The File Address containing the contract is missing, it cannot be null.", ex.Message);
Assert.Equal("File", ex.ParamName);
}
public async Task MissingGasRaisesError()
{
await using var fx = await GreetingContract.SetupAsync(_network);
fx.ContractParams.Gas = 0;
var ex = await Assert.ThrowsAsync <TransactionException>(async() => {
await fx.Client.CreateContractAsync(fx.ContractParams);
});
Assert.StartsWith("Unable to create contract, status: InsufficientGas", ex.Message);
Assert.Equal(ResponseCode.InsufficientGas, ex.Status);
}
public async Task SendingCryptoToNonPayableContractRaisesError()
{
await using var fx = await GreetingContract.SetupAsync(_network);
fx.ContractParams.InitialBalance = 10;
var ex = await Assert.ThrowsAsync <TransactionException>(async() => {
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 InvalidRenewPeriodRaisesError()
{
await using var fx = await GreetingContract.SetupAsync(_network);
fx.ContractParams.RenewPeriod = TimeSpan.FromTicks(1);
var ex = await Assert.ThrowsAsync <PrecheckException>(async() => {
await fx.Client.CreateContractAsync(fx.ContractParams);
});
Assert.StartsWith("Transaction Failed Pre-Check: AutorenewDurationNotInRange", ex.Message);
Assert.Equal(ResponseCode.AutorenewDurationNotInRange, ex.Status);
}
public async Task CanCreateAContractAsync()
{
await using var fx = await GreetingContract.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);
}
