static int _CreateTestAccount(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 3)
{
int arg0 = (int)LuaDLL.luaL_checknumber(L, 1);
string arg1 = ToLua.CheckString(L, 2);
int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
TestAccount obj = new TestAccount(arg0, arg1, arg2);
ToLua.PushObject(L, obj);
return 1;
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: TestAccount.New");
}
return 0;
}
public static async Task CryptoBalanceAsync(TestAccount fxAccount, ulong expectedBalance)
{
var balance = await fxAccount.Client.GetAccountBalanceAsync(fxAccount);
Assert.Equal(expectedBalance, balance);
}
internal static async Task <TokenBalance> AssetIsAssociatedAsync(TestAsset fxAsset, TestAccount fxAccount)
{
var info = await fxAccount.Client.GetAccountInfoAsync(fxAccount);
Assert.NotNull(info);
var association = info.Tokens.FirstOrDefault(t => t.Token == fxAsset.Record.Token);
Assert.NotNull(association);
return(association);
}
public static async Task TokenBalanceAsync(TestToken fxToken, TestAccount fxAccount, ulong expectedBalance)
{
var balance = await fxToken.Client.GetAccountTokenBalanceAsync(fxAccount, fxToken);
Assert.Equal(expectedBalance, balance);
}
public async Task DeletingDoesNotRemoveTokenRecords()
{
await using var fxAccount = await TestAccount.CreateAsync(_network);
await using var fxToken = await TestToken.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount);
var totalTinytokens = fxToken.Params.Circulation;
var xferAmount = totalTinytokens / 3;
await fxToken.Client.TransferTokensAsync(fxToken.Record.Token, fxToken.TreasuryAccount.Record.Address, fxAccount.Record.Address, (long)xferAmount, fxToken.TreasuryAccount.PrivateKey);
var record = await fxAccount.Client.DeleteTokenAsync(fxToken.Record.Token, fxToken.AdminPrivateKey);
Assert.Equal(ResponseCode.Success, record.Status);
var info = await fxToken.Client.GetTokenInfoAsync(fxToken.Record.Token);
Assert.Equal(fxToken.Record.Token, info.Token);
Assert.Equal(fxToken.Params.Symbol, info.Symbol);
Assert.Equal(fxToken.TreasuryAccount.Record.Address, info.Treasury);
Assert.Equal(fxToken.Params.Circulation, info.Circulation);
Assert.Equal(fxToken.Params.Decimals, info.Decimals);
Assert.Equal(fxToken.Params.Ceiling, info.Ceiling);
Assert.Equal(fxToken.Params.Administrator, info.Administrator);
Assert.Equal(fxToken.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxToken.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxToken.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxToken.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(fxToken.Params.RoyaltiesEndorsement, info.RoyaltiesEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenTradableStatus.Tradable, info.PauseStatus);
Assert.Equal(TokenKycStatus.NotApplicable, info.KycStatus);
Assert.Empty(info.Royalties);
Assert.True(info.Deleted);
Assert.Equal(fxToken.Params.Memo, info.Memo);
// NETWORK V0.21.0 UNSUPPORTED vvvv
// NOT IMPLEMENTED YET
Assert.Empty(info.Ledger.ToArray());
// NETWORK V0.21.0 UNSUPPORTED ^^^^
var accountInfo = await fxToken.Client.GetAccountInfoAsync(fxAccount.Record.Address);
var token = accountInfo.Tokens.FirstOrDefault(t => t.Token == fxToken.Record.Token);
Assert.NotNull(token);
Assert.Equal(fxToken.Record.Token, token.Token);
Assert.Equal(fxToken.Params.Symbol, token.Symbol);
Assert.Equal(xferAmount, token.Balance);
Assert.Equal(fxToken.Params.Decimals, token.Decimals);
Assert.Equal(TokenTradableStatus.Tradable, token.TradableStatus);
Assert.False(token.AutoAssociated);
Assert.Equal(TokenKycStatus.NotApplicable, token.KycStatus);
var treasuryInfo = await fxToken.Client.GetAccountInfoAsync(fxToken.TreasuryAccount.Record.Address);
token = treasuryInfo.Tokens.FirstOrDefault(t => t.Token == fxToken.Record.Token);
Assert.NotNull(token);
Assert.Equal(fxToken.Record.Token, token.Token);
Assert.Equal(fxToken.Params.Symbol, token.Symbol);
Assert.Equal(totalTinytokens - xferAmount, token.Balance);
Assert.Equal(fxToken.Params.Decimals, token.Decimals);
Assert.Equal(TokenTradableStatus.Tradable, token.TradableStatus);
Assert.False(token.AutoAssociated);
Assert.Equal(TokenKycStatus.NotApplicable, token.KycStatus);
}
public async Task DeletingDoesNotRemoveAssetRecords()
{
await using var fxAccount = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount);
var initialCirculation = (ulong)fxAsset.Metadata.Length;
var xferAmount = 2ul;
var expectedTreasury = initialCirculation - xferAmount;
var serialNumbersTransfered = Enumerable.Range(1, 2).Select(i => (long)i);
var transferParams = new TransferParams
{
AssetTransfers = serialNumbersTransfered.Select(sn => new AssetTransfer(new Asset(fxAsset.Record.Token, sn), fxAsset.TreasuryAccount, fxAccount)),
Signatory = fxAsset.TreasuryAccount
};
await fxAsset.Client.TransferAsync(transferParams);
var record = await fxAccount.Client.DeleteTokenAsync(fxAsset.Record.Token, fxAsset.AdminPrivateKey);
Assert.Equal(ResponseCode.Success, record.Status);
var info = await fxAsset.Client.GetTokenInfoAsync(fxAsset.Record.Token);
Assert.Equal(fxAsset.Record.Token, info.Token);
Assert.Equal(fxAsset.Params.Symbol, info.Symbol);
Assert.Equal(fxAsset.TreasuryAccount.Record.Address, info.Treasury);
Assert.Equal(initialCirculation, info.Circulation);
Assert.Equal(0U, info.Decimals);
Assert.Equal(fxAsset.Params.Ceiling, info.Ceiling);
Assert.Equal(fxAsset.Params.Administrator, info.Administrator);
Assert.Equal(fxAsset.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxAsset.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxAsset.Params.PauseEndorsement, info.PauseEndorsement);
Assert.Equal(fxAsset.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxAsset.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenTradableStatus.Tradable, info.PauseStatus);
Assert.Equal(TokenKycStatus.NotApplicable, info.KycStatus);
Assert.True(info.Deleted);
Assert.Equal(fxAsset.Params.Memo, info.Memo);
// NETWORK V0.21.0 UNSUPPORTED vvvv
// NOT IMPLEMENTED YET
Assert.Empty(info.Ledger.ToArray());
// NETWORK V0.21.0 UNSUPPORTED ^^^^
var accountInfo = await fxAsset.Client.GetAccountInfoAsync(fxAccount.Record.Address);
var asset = accountInfo.Tokens.FirstOrDefault(t => t.Token == fxAsset.Record.Token);
Assert.NotNull(asset);
Assert.Equal(fxAsset.Record.Token, asset.Token);
Assert.Equal(fxAsset.Params.Symbol, asset.Symbol);
Assert.Equal(xferAmount, asset.Balance);
Assert.Equal(0U, asset.Decimals);
Assert.Equal(TokenTradableStatus.Tradable, asset.TradableStatus);
Assert.False(asset.AutoAssociated);
Assert.Equal(TokenKycStatus.NotApplicable, asset.KycStatus);
var treasuryInfo = await fxAsset.Client.GetAccountInfoAsync(fxAsset.TreasuryAccount.Record.Address);
asset = treasuryInfo.Tokens.FirstOrDefault(t => t.Token == fxAsset.Record.Token);
Assert.NotNull(asset);
Assert.Equal(fxAsset.Record.Token, asset.Token);
Assert.Equal(fxAsset.Params.Symbol, asset.Symbol);
Assert.Equal(expectedTreasury, asset.Balance);
Assert.Equal(0U, asset.Decimals);
Assert.Equal(TokenTradableStatus.Tradable, asset.TradableStatus);
Assert.False(asset.AutoAssociated);
Assert.Equal(TokenKycStatus.NotApplicable, asset.KycStatus);
}
public async Task AttemptsToMisplaceHbarsThruPayableContractShouldFail()
{
// Setup the Simple Payable Contract and An account for "send to".
await using var fxAccount1 = await TestAccount.CreateAsync(_network);
await using var fxAccount2 = await TestAccount.CreateAsync(_network);
await using var fxContract = await PayableContract.CreateAsync(_network);
// Get the Info for the account state and then delete the account.
var info1Before = await fxAccount1.Client.GetAccountInfoAsync(fxAccount1.Record.Address);
var info2Before = await fxAccount2.Client.GetAccountInfoAsync(fxAccount2.Record.Address);
var delete1Receipt = await fxAccount1.Client.DeleteAccountAsync(fxAccount1.Record.Address, fxAccount1.Network.Payer, fxAccount1.PrivateKey);
Assert.Equal(ResponseCode.Success, delete1Receipt.Status);
// Double check the balance on the contract, confirm it has hbars
var contractBalanceBefore = await fxContract.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fxContract.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(600),
FunctionName = "get_balance"
});
Assert.NotNull(contractBalanceBefore);
Assert.InRange(fxContract.ContractParams.InitialBalance, 1, int.MaxValue);
Assert.Equal(fxContract.ContractParams.InitialBalance, contractBalanceBefore.CallResult.Result.As <long>());
// Ensure matches API vesion.
var apiBalance = await fxContract.Client.GetContractBalanceAsync(fxContract.ContractRecord.Contract);
Assert.Equal((ulong)fxContract.ContractParams.InitialBalance, apiBalance);
// Call the contract, sending to the address of the now deleted account
// Call the contract, sending to the address of the now deleted account
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxContract.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fxContract.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(600),
FunctionName = "send_to",
FunctionArgs = new[] { fxAccount1.Record.Address }
});
});
Assert.Equal(ResponseCode.InvalidSolidityAddress, tex.Status);
Assert.StartsWith("Contract call failed, status: InvalidSolidityAddress", tex.Message);
// Confirm that the balance on the contract did not change.
var contractBalanceAfter = await fxContract.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fxContract.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "get_balance"
});
Assert.NotNull(contractBalanceAfter);
Assert.Equal(fxContract.ContractParams.InitialBalance, contractBalanceAfter.CallResult.Result.As <long>());
// Ensure matches API vesion.
apiBalance = await fxContract.Client.GetContractBalanceAsync(fxContract.ContractRecord.Contract);
Assert.Equal((ulong)fxContract.ContractParams.InitialBalance, apiBalance);
// Try to get info on the deleted account, but this will fail because the
// account is already deleted.
var pex = await Assert.ThrowsAsync <PrecheckException>(async() =>
{
// So if this throws an error, why did the above call not fail?
await fxAccount1.Client.GetAccountInfoAsync(fxAccount1.Record.Address);
});
// Delete the Contract, returning any hidden hbars to account number 2
var deleteContractRecord = await fxContract.Client.DeleteContractAsync(fxContract.ContractRecord.Contract, fxAccount2.Record.Address, fxContract.PrivateKey);
Assert.Equal(ResponseCode.Success, deleteContractRecord.Status);
// Check the balance of account number 2, the hBars should be there?
var info2After = await fxAccount2.Client.GetAccountInfoAsync(fxAccount2.Record.Address);
Assert.Equal((ulong)fxContract.ContractParams.InitialBalance + info2Before.Balance, info2After.Balance); // NOPE!
}
public static async Task <TestAsset> CreateAsync(NetworkCredentials networkCredentials, Action <TestAsset> customize = null, params TestAccount[] associate)
{
var maxSupply = (long)(Generator.Integer(10, 20) * 1000);
var fx = new TestAsset
{
Network = networkCredentials
};
fx.Network.Output?.WriteLine("STARTING SETUP: Test Asset Instance");
(fx.AdminPublicKey, fx.AdminPrivateKey) = Generator.KeyPair();
(fx.GrantPublicKey, fx.GrantPrivateKey) = Generator.KeyPair();
(fx.SuspendPublicKey, fx.SuspendPrivateKey) = Generator.KeyPair();
(fx.PausePublicKey, fx.PausePrivateKey) = Generator.KeyPair();
(fx.ConfiscatePublicKey, fx.ConfiscatePrivateKey) = Generator.KeyPair();
(fx.SupplyPublicKey, fx.SupplyPrivateKey) = Generator.KeyPair();
(fx.RoyaltiesPublickKey, fx.RoyaltiesPrivateKey) = Generator.KeyPair();
fx.Payer = networkCredentials.Payer;
fx.Client = networkCredentials.NewClient();
fx.TreasuryAccount = await TestAccount.CreateAsync(networkCredentials);
fx.RenewAccount = await TestAccount.CreateAsync(networkCredentials);
fx.Metadata = Enumerable.Range(1, Generator.Integer(3, 9)).Select(_ => Generator.SHA384Hash()).ToArray();
fx.Params = new CreateAssetParams
{
Name = Generator.Code(50),
Symbol = Generator.UppercaseAlphaCode(20),
Treasury = fx.TreasuryAccount.Record.Address,
Ceiling = maxSupply,
Administrator = fx.AdminPublicKey,
GrantKycEndorsement = fx.GrantPublicKey,
SuspendEndorsement = fx.SuspendPublicKey,
PauseEndorsement = fx.PausePublicKey,
ConfiscateEndorsement = fx.ConfiscatePublicKey,
SupplyEndorsement = fx.SupplyPublicKey,
RoyaltiesEndorsement = fx.RoyaltiesPublickKey,
InitializeSuspended = false,
Expiration = Generator.TruncatedFutureDate(2000, 3000),
RenewAccount = fx.RenewAccount.Record.Address,
RenewPeriod = TimeSpan.FromDays(90),
Signatory = new Signatory(fx.AdminPrivateKey, fx.RenewAccount.PrivateKey, fx.TreasuryAccount.PrivateKey),
Memo = "Test Asset: " + Generator.Code(20)
};
customize?.Invoke(fx);
fx.Record = await fx.Client.RetryKnownNetworkIssues(async client =>
{
return(await fx.Client.CreateTokenWithRecordAsync(fx.Params, ctx =>
{
ctx.Memo = "TestAsset Setup: " + fx.Params.Symbol ?? "(null symbol)";
}));
});
Assert.Equal(ResponseCode.Success, fx.Record.Status);
await fx.AssociateAccounts(associate);
if (fx.Metadata is not null && fx.Metadata.Length > 0)
{
fx.MintRecord = await fx.Client.MintAssetWithRecordAsync(fx.Record.Token, fx.Metadata, fx.SupplyPrivateKey);
}
networkCredentials.Output?.WriteLine("SETUP COMPLETED: Test Asset Instance");
return(fx);
}
public TestAccountWrapper(TestAccount account)
{
this.account = account;
}
public async Task CanScheduleCreateAccountAsync()
{
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
var initialPayment = 1_00_000_000;
var(publicKey, privateKey) = Generator.KeyPair();
var alias = new Alias(publicKey);
var client = _network.NewClient();
var receipt = await client.TransferAsync(_network.Payer, alias, initialPayment, new PendingParams { PendingPayer = fxPayer });
Assert.NotNull(receipt);
Assert.NotNull(receipt.Pending);
var signingReceipt = await client.SignPendingTransactionAsync(receipt.Pending.Id, fxPayer);
Assert.Equal(ResponseCode.Success, signingReceipt.Status);
// If an account was created by the alias, the receipt
// with the address is a "child receipt" of the transfer
// receipt and must be explictly asked for.
var allReceipts = await client.GetAllReceiptsAsync(receipt.Pending.TxId);
Assert.Equal(2, allReceipts.Count);
Assert.Equal(receipt.Pending.TxId, allReceipts[0].Id);
var createReceipt = allReceipts[1] as CreateAccountReceipt;
Assert.NotNull(createReceipt);
Assert.NotNull(createReceipt.Address);
Assert.Equal(_network.ServerRealm, createReceipt.Address.RealmNum);
Assert.Equal(_network.ServerShard, createReceipt.Address.ShardNum);
Assert.True(createReceipt.Address.AccountNum > 0);
Assert.Equal(1, createReceipt.Id.Nonce);
var createReceiptByTx = await client.GetReceiptAsync(createReceipt.Id) as CreateAccountReceipt;
Assert.NotNull(createReceiptByTx);
Assert.NotNull(createReceiptByTx.Address);
Assert.Equal(_network.ServerRealm, createReceiptByTx.Address.RealmNum);
Assert.Equal(_network.ServerShard, createReceiptByTx.Address.ShardNum);
Assert.Equal(createReceipt.Address, createReceiptByTx.Address);
Assert.Equal(createReceipt.Id, createReceiptByTx.Id);
var balances = await client.GetAccountBalancesAsync(alias);
Assert.NotNull(balances);
Assert.Equal(createReceipt.Address, balances.Address);
Assert.True(balances.Crypto > 0);
Assert.Empty(balances.Tokens);
var infoFromAccount = await client.GetAccountInfoAsync(createReceipt.Address);
Assert.Equal(createReceipt.Address, infoFromAccount.Address);
Assert.Equal(alias, infoFromAccount.Alias);
Assert.NotNull(infoFromAccount.SmartContractId);
Assert.False(infoFromAccount.Deleted);
Assert.NotNull(infoFromAccount.Proxy);
Assert.Equal(0, infoFromAccount.ProxiedToAccount);
Assert.Equal(new Endorsement(publicKey), infoFromAccount.Endorsement);
Assert.True(infoFromAccount.Balance > 0);
Assert.False(infoFromAccount.ReceiveSignatureRequired);
Assert.True(infoFromAccount.AutoRenewPeriod.TotalSeconds > 0);
Assert.True(infoFromAccount.Expiration > DateTime.MinValue);
Assert.Equal(0, infoFromAccount.AssetCount);
Assert.Equal(0, infoFromAccount.AutoAssociationLimit);
Assert.Equal("auto-created account", infoFromAccount.Memo);
AssertHg.NotEmpty(infoFromAccount.Ledger);
var infoFromAlias = await client.GetAccountInfoAsync(alias);
Assert.Equal(createReceipt.Address, infoFromAlias.Address);
Assert.Equal(alias, infoFromAlias.Alias);
Assert.NotNull(infoFromAlias.SmartContractId);
Assert.False(infoFromAlias.Deleted);
Assert.NotNull(infoFromAlias.Proxy);
Assert.Equal(0, infoFromAlias.ProxiedToAccount);
Assert.Equal(new Endorsement(publicKey), infoFromAlias.Endorsement);
Assert.True(infoFromAlias.Balance > 0);
Assert.False(infoFromAlias.ReceiveSignatureRequired);
Assert.True(infoFromAlias.AutoRenewPeriod.TotalSeconds > 0);
Assert.True(infoFromAlias.Expiration > DateTime.MinValue);
Assert.Equal(0, infoFromAlias.AssetCount);
Assert.Equal(0, infoFromAlias.AutoAssociationLimit);
Assert.Equal("auto-created account", infoFromAlias.Memo);
AssertHg.Equal(infoFromAccount.Ledger, infoFromAlias.Ledger);
}
public static async Task <TestToken> CreateAsync(NetworkCredentials networkCredentials, Action <TestToken> customize = null, params TestAccount[] associate)
{
var wholeTokens = (ulong)(Generator.Integer(10, 20) * 100000);
var decimals = (uint)Generator.Integer(2, 5);
var circulation = wholeTokens * (ulong)Math.Pow(10, decimals);
var maxSupply = (long)(circulation * Generator.Double(2.1, 2.8));
var fx = new TestToken
{
Network = networkCredentials
};
fx.Network.Output?.WriteLine("STARTING SETUP: Test Token Instance");
(fx.AdminPublicKey, fx.AdminPrivateKey) = Generator.KeyPair();
(fx.GrantPublicKey, fx.GrantPrivateKey) = Generator.KeyPair();
(fx.SuspendPublicKey, fx.SuspendPrivateKey) = Generator.KeyPair();
(fx.PausePublicKey, fx.PausePrivateKey) = Generator.KeyPair();
(fx.ConfiscatePublicKey, fx.ConfiscatePrivateKey) = Generator.KeyPair();
(fx.SupplyPublicKey, fx.SupplyPrivateKey) = Generator.KeyPair();
(fx.RoyaltiesPublicKey, fx.RoyaltiesPrivateKey) = Generator.KeyPair();
fx.Payer = networkCredentials.Payer;
fx.Client = networkCredentials.NewClient();
fx.TreasuryAccount = await TestAccount.CreateAsync(networkCredentials);
fx.RenewAccount = await TestAccount.CreateAsync(networkCredentials);
fx.Params = new CreateTokenParams
{
Name = Generator.Code(50),
Symbol = Generator.UppercaseAlphaCode(20),
Circulation = circulation,
Decimals = decimals,
Ceiling = maxSupply,
Treasury = fx.TreasuryAccount.Record.Address,
Administrator = fx.AdminPublicKey,
GrantKycEndorsement = fx.GrantPublicKey,
SuspendEndorsement = fx.SuspendPublicKey,
PauseEndorsement = fx.PausePublicKey,
ConfiscateEndorsement = fx.ConfiscatePublicKey,
SupplyEndorsement = fx.SupplyPublicKey,
RoyaltiesEndorsement = fx.RoyaltiesPublicKey,
InitializeSuspended = false,
Expiration = Generator.TruncatedFutureDate(2000, 3000),
RenewAccount = fx.RenewAccount.Record.Address,
RenewPeriod = TimeSpan.FromDays(90),
Signatory = new Signatory(fx.AdminPrivateKey, fx.RenewAccount.PrivateKey, fx.TreasuryAccount.PrivateKey),
Memo = "Test Token: " + Generator.Code(20)
};
customize?.Invoke(fx);
fx.Record = await fx.Client.RetryKnownNetworkIssues(async client =>
{
return(await fx.Client.CreateTokenWithRecordAsync(fx.Params, ctx =>
{
ctx.Memo = "TestToken Setup: " + fx.Params.Symbol ?? "(null symbol)";
}));
});
Assert.Equal(ResponseCode.Success, fx.Record.Status);
await fx.AssociateAccounts(associate);
networkCredentials.Output?.WriteLine("SETUP COMPLETED: Test Token Instance");
return(fx);
}
public async Task CanScheduleMintAssetCoins()
{
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
await using var fxAsset = await TestAsset.CreateAsync(_network);
var metadata = Enumerable.Range(1, Generator.Integer(2, 10)).Select(_ => Generator.SHA384Hash()).ToArray();
var pendingReceipt = await fxAsset.Client.MintAssetAsync(
fxAsset.Record.Token,
metadata,
new Signatory(
fxAsset.SupplyPrivateKey,
new PendingParams
{
PendingPayer = fxPayer
}));
await AssertHg.AssetBalanceAsync(fxAsset, fxAsset.TreasuryAccount, (ulong)fxAsset.Metadata.Length);
var schedulingReceipt = await fxAsset.Client.SignPendingTransactionAsync(pendingReceipt.Pending.Id, fxPayer.PrivateKey);
Assert.Equal(ResponseCode.Success, schedulingReceipt.Status);
// Can get receipt for original scheduled tx.
var executedReceipt = await fxAsset.Client.GetReceiptAsync(pendingReceipt.Pending.TxId) as AssetMintReceipt;
Assert.Equal(ResponseCode.Success, executedReceipt.Status);
Assert.Equal(metadata.Length, executedReceipt.SerialNumbers.Count);
foreach (var serialNumber in executedReceipt.SerialNumbers)
{
Assert.True(serialNumber > 0);
}
Assert.Equal((ulong)(fxAsset.Metadata.Length + metadata.Length), executedReceipt.Circulation);
// Can get record for original scheduled tx.
var record = await fxAsset.Client.GetTransactionRecordAsync(pendingReceipt.Pending.TxId) as AssetMintRecord;
Assert.Equal(metadata.Length, record.SerialNumbers.Count);
foreach (var serialNumber in record.SerialNumbers)
{
Assert.True(serialNumber > 0);
}
Assert.Equal((ulong)(fxAsset.Metadata.Length + metadata.Length), record.Circulation);
await AssertHg.AssetBalanceAsync(fxAsset, fxAsset.TreasuryAccount, (ulong)(metadata.Length + fxAsset.Metadata.Length));
var info = await fxAsset.Client.GetTokenInfoAsync(fxAsset.Record.Token);
Assert.Equal(fxAsset.Record.Token, info.Token);
Assert.Equal(fxAsset.Params.Symbol, info.Symbol);
Assert.Equal(TokenType.Asset, info.Type);
Assert.Equal(fxAsset.TreasuryAccount.Record.Address, info.Treasury);
Assert.Equal((ulong)(metadata.Length + fxAsset.Metadata.Length), info.Circulation);
Assert.Equal(fxAsset.Params.Ceiling, info.Ceiling);
Assert.Equal(fxAsset.Params.Administrator, info.Administrator);
Assert.Equal(fxAsset.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxAsset.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxAsset.Params.PauseEndorsement, info.PauseEndorsement);
Assert.Equal(fxAsset.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxAsset.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(fxAsset.Params.RoyaltiesEndorsement, info.RoyaltiesEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenTradableStatus.Tradable, info.PauseStatus);
Assert.Equal(TokenKycStatus.Revoked, info.KycStatus);
Assert.Empty(info.Royalties);
Assert.False(info.Deleted);
Assert.Equal(fxAsset.Params.Memo, info.Memo);
// NETWORK V0.21.0 UNSUPPORTED vvvv
// NOT IMPLEMENTED YET
Assert.Empty(info.Ledger.ToArray());
// NETWORK V0.21.0 UNSUPPORTED ^^^^
}
public async Task CanScheduleMintTokenCoins()
{
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
await using var fxToken = await TestToken.CreateAsync(_network);
var pendingReceipt = await fxToken.Client.MintTokenAsync(
fxToken.Record.Token,
fxToken.Params.Circulation,
new Signatory(
fxToken.SupplyPrivateKey,
new PendingParams
{
PendingPayer = fxPayer
}));
Assert.Equal(fxToken.Params.Circulation, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
// This should be considered a network bug.
Assert.Equal(0UL, pendingReceipt.Circulation);
var schedulingReceipt = await fxToken.Client.SignPendingTransactionAsync(pendingReceipt.Pending.Id, fxPayer.PrivateKey); // as TokenReceipt
Assert.Equal(ResponseCode.Success, schedulingReceipt.Status);
// Can get receipt for original scheduled tx.
var executedReceipt = await fxToken.Client.GetReceiptAsync(pendingReceipt.Pending.TxId) as TokenReceipt;
var expectedTreasury = 2 * fxToken.Params.Circulation;
Assert.Equal(ResponseCode.Success, executedReceipt.Status);
Assert.Equal(expectedTreasury, executedReceipt.Circulation);
// Can get record for original scheduled tx.
var record = await fxToken.Client.GetTransactionRecordAsync(pendingReceipt.Pending.TxId) as TokenRecord;
Assert.Equal(expectedTreasury, record.Circulation);
var info = await fxToken.Client.GetTokenInfoAsync(fxToken.Record.Token);
Assert.Equal(fxToken.Record.Token, info.Token);
Assert.Equal(TokenType.Fungible, info.Type);
Assert.Equal(fxToken.Params.Symbol, info.Symbol);
Assert.Equal(fxToken.TreasuryAccount.Record.Address, info.Treasury);
// Note: we doubled the circulation
Assert.Equal(fxToken.Params.Circulation * 2, info.Circulation);
Assert.Equal(fxToken.Params.Decimals, info.Decimals);
Assert.Equal(fxToken.Params.Ceiling, info.Ceiling);
Assert.Equal(fxToken.Params.Administrator, info.Administrator);
Assert.Equal(fxToken.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxToken.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxToken.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxToken.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(fxToken.Params.RoyaltiesEndorsement, info.RoyaltiesEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenTradableStatus.Tradable, info.PauseStatus);
Assert.Equal(TokenKycStatus.Revoked, info.KycStatus);
Assert.Empty(info.Royalties);
Assert.False(info.Deleted);
Assert.Equal(fxToken.Params.Memo, info.Memo);
// NETWORK V0.21.0 UNSUPPORTED vvvv
// NOT IMPLEMENTED YET
Assert.Empty(info.Ledger.ToArray());
// NETWORK V0.21.0 UNSUPPORTED ^^^^
Assert.Equal(expectedTreasury, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
}
public async Task CanMoveCoinsByMovingTheTreasury()
{
await using var fxAccount = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 120_00_000_000);
await using var fxToken = await TestToken.CreateAsync(_network, fx =>
{
fx.Params.GrantKycEndorsement = null;
fx.Params.ConfiscateEndorsement = null;
}, fxAccount);
var circulation = fxToken.Params.Circulation;
var xferAmount = circulation / 3;
var partialTreasury = circulation - xferAmount;
// Transfer a third of the treasury to the other account.
await fxToken.Client.TransferTokensAsync(fxToken, fxToken.TreasuryAccount, fxAccount, (long)xferAmount, fxToken.TreasuryAccount.PrivateKey);
// Double check balances.
Assert.Equal(xferAmount, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxToken));
Assert.Equal(partialTreasury, await fxAccount.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
// Move the treasury to an existing account
await fxToken.Client.UpdateTokenAsync(new UpdateTokenParams
{
Token = fxToken,
Treasury = fxAccount,
Signatory = new Signatory(fxToken.AdminPrivateKey, fxAccount.PrivateKey)
});
// All coins swept into new treasury account.
Assert.Equal(circulation, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxToken));
Assert.Equal(0UL, await fxAccount.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
// What does the info say now?
var info = await fxToken.Client.GetTokenInfoAsync(fxToken.Record.Token);
Assert.Equal(fxToken.Record.Token, info.Token);
Assert.Equal(fxToken.Params.Symbol, info.Symbol);
Assert.Equal(fxAccount.Record.Address, info.Treasury);
Assert.Equal(fxToken.Params.Circulation, info.Circulation);
Assert.Equal(fxToken.Params.Decimals, info.Decimals);
Assert.Equal(fxToken.Params.Administrator, info.Administrator);
Assert.Equal(fxToken.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxToken.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxToken.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxToken.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenKycStatus.NotApplicable, info.KycStatus);
Assert.False(info.Deleted);
// Move the treasury back
await fxToken.Client.UpdateTokenAsync(new UpdateTokenParams
{
Token = fxToken,
Treasury = fxToken.TreasuryAccount,
Signatory = new Signatory(fxToken.AdminPrivateKey, fxToken.TreasuryAccount.PrivateKey)
});
// All coins swept back to original treasury.
Assert.Equal(0UL, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxToken));
Assert.Equal(circulation, await fxAccount.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
}
public async Task CanTransferTokensAndGetRecord()
{
await using var fxAccount = await TestAccount.CreateAsync(_network);
await using var fxToken = await TestToken.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount);
var xferAmount = 2 * fxToken.Params.Circulation / 3;
var record = await fxToken.Client.TransferTokensWithRecordAsync(fxToken.Record.Token, fxToken.TreasuryAccount.Record.Address, fxAccount.Record.Address, (long)xferAmount, fxToken.TreasuryAccount.PrivateKey);
Assert.Equal(ResponseCode.Success, record.Status);
Assert.False(record.Hash.IsEmpty);
Assert.NotNull(record.Concensus);
Assert.NotNull(record.CurrentExchangeRate);
Assert.NotNull(record.NextExchangeRate);
Assert.NotEmpty(record.Hash.ToArray());
Assert.Empty(record.Memo);
Assert.InRange(record.Fee, 0UL, ulong.MaxValue);
Assert.Equal(_network.Payer, record.Id.Address);
Assert.Equal(2, record.TokenTransfers.Count);
var xferFrom = record.TokenTransfers.First(x => x.Address == fxToken.TreasuryAccount.Record.Address);
Assert.NotNull(xferFrom);
Assert.Equal(fxToken.Record.Token, xferFrom.Token);
Assert.Equal(-(long)xferAmount, xferFrom.Amount);
var xferTo = record.TokenTransfers.First(x => x.Address == fxAccount.Record.Address);
Assert.NotNull(xferTo);
Assert.Equal(fxToken.Record.Token, xferFrom.Token);
Assert.Equal((long)xferAmount, xferTo.Amount);
var info = await fxToken.Client.GetTokenInfoAsync(fxToken.Record.Token);
Assert.Equal(fxToken.Record.Token, info.Token);
Assert.Equal(fxToken.Params.Symbol, info.Symbol);
Assert.Equal(fxToken.TreasuryAccount.Record.Address, info.Treasury);
Assert.Equal(fxToken.Params.Circulation, info.Circulation);
Assert.Equal(fxToken.Params.Decimals, info.Decimals);
Assert.Equal(fxToken.Params.Administrator, info.Administrator);
Assert.Equal(fxToken.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxToken.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxToken.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxToken.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenKycStatus.NotApplicable, info.KycStatus);
Assert.False(info.Deleted);
var balances = await fxAccount.Client.GetAccountBalancesAsync(fxAccount.Record.Address);
Assert.Equal(fxAccount.Record.Address, balances.Address);
Assert.Equal(fxAccount.CreateParams.InitialBalance, balances.Crypto);
Assert.Single(balances.Tokens);
Assert.Equal(xferAmount, balances.Tokens[fxToken.Record.Token]);
balances = await fxAccount.Client.GetAccountBalancesAsync(fxToken.TreasuryAccount.Record.Address);
Assert.Equal(fxToken.TreasuryAccount.Record.Address, balances.Address);
Assert.Equal(fxToken.TreasuryAccount.CreateParams.InitialBalance, balances.Crypto);
Assert.Single(balances.Tokens);
Assert.Equal(fxToken.Params.Circulation - xferAmount, balances.Tokens[fxToken.Record.Token]);
}
public async Task CannotTransferTokensAfterSuspend()
{
await using var fxAccount1 = await TestAccount.CreateAsync(_network);
await using var fxAccount2 = await TestAccount.CreateAsync(_network);
await using var fxToken = await TestToken.CreateAsync(_network, fx =>
{
fx.Params.GrantKycEndorsement = null;
fx.Params.InitializeSuspended = false;
}, fxAccount1, fxAccount2);
var circulation = fxToken.Params.Circulation;
var xferAmount = circulation / 3;
// Move coins to account 2 via 1
await fxToken.Client.TransferTokensAsync(fxToken, fxToken.TreasuryAccount, fxAccount1, (long)xferAmount, fxToken.TreasuryAccount);
await fxToken.Client.TransferTokensAsync(fxToken, fxAccount1, fxAccount2, (long)xferAmount, fxAccount1);
// Check our Balances
Assert.Equal(circulation - xferAmount, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
Assert.Equal(0UL, await fxToken.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(xferAmount, await fxToken.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
// Suppend Account One from Receiving Coins
await fxToken.Client.SuspendTokenAsync(fxToken.Record.Token, fxAccount1, fxToken.SuspendPrivateKey);
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxToken.Client.TransferTokensAsync(fxToken, fxAccount2, fxAccount1, (long)xferAmount, fxAccount2);
});
Assert.Equal(ResponseCode.AccountFrozenForToken, tex.Status);
Assert.StartsWith("Unable to execute transfers, status: AccountFrozenForToken", tex.Message);
// Can we suspend the treasury?
await fxToken.Client.SuspendTokenAsync(fxToken, fxToken.TreasuryAccount, fxToken.SuspendPrivateKey);
tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxToken.Client.TransferTokensAsync(fxToken, fxAccount2, fxToken.TreasuryAccount, (long)xferAmount, fxAccount2);
});
Assert.Equal(ResponseCode.AccountFrozenForToken, tex.Status);
Assert.StartsWith("Unable to execute transfers, status: AccountFrozenForToken", tex.Message);
// Double Check can't send from frozen treasury.
tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxToken.Client.TransferTokensAsync(fxToken, fxToken.TreasuryAccount, fxAccount2, (long)xferAmount, fxToken.TreasuryAccount);
});
Assert.Equal(ResponseCode.AccountFrozenForToken, tex.Status);
Assert.StartsWith("Unable to execute transfers, status: AccountFrozenForToken", tex.Message);
// Balances should not have changed
Assert.Equal(circulation - xferAmount, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
Assert.Equal(0UL, await fxToken.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(xferAmount, await fxToken.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
// Resume Participating Accounts
await fxToken.Client.ResumeTokenAsync(fxToken, fxAccount1, fxToken.SuspendPrivateKey);
await fxToken.Client.ResumeTokenAsync(fxToken, fxToken.TreasuryAccount, fxToken.SuspendPrivateKey);
// Move coins to back via 1
await fxToken.Client.TransferTokensAsync(fxToken, fxAccount2, fxAccount1, (long)xferAmount, fxAccount2);
await fxToken.Client.TransferTokensAsync(fxToken, fxAccount1, fxToken.TreasuryAccount, (long)xferAmount, fxAccount1);
// Check our Final Balances
Assert.Equal(circulation, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
Assert.Equal(0UL, await fxToken.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(0UL, await fxToken.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
}
public TestFakeClient(TestAccount account)
: base(account)
{
}
public void setAccount(TestAccount account)
{
this.account = account;
}
public async Task SendFundsToDeletedAccountRaisesError()
{
// Setup the Simple Payable Contract and An account for "send to".
await using var fxContract = await PayableContract.CreateAsync(_network);
await using var fxAccount = await TestAccount.CreateAsync(_network);
// Get the Info for the account state and then delete the account.
var infoBefore = await fxAccount.Client.GetAccountInfoAsync(fxAccount.Record.Address);
var deleteReceipt = await fxAccount.Client.DeleteAccountAsync(fxAccount.Record.Address, fxAccount.Network.Payer, fxAccount.PrivateKey);
Assert.Equal(ResponseCode.Success, deleteReceipt.Status);
// Double check the balance on the contract, confirm it has hbars
var contractBalanceBefore = await fxContract.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fxContract.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(600),
FunctionName = "get_balance"
});
Assert.NotNull(contractBalanceBefore);
Assert.InRange(fxContract.ContractParams.InitialBalance, 1, int.MaxValue);
Assert.Equal(fxContract.ContractParams.InitialBalance, contractBalanceBefore.CallResult.Result.As <long>());
// Ensure matches API vesion.
var apiBalance = await fxContract.Client.GetContractBalanceAsync(fxContract.ContractRecord.Contract);
Assert.Equal((ulong)fxContract.ContractParams.InitialBalance, apiBalance);
// Ensure matches Info version
var info = await fxContract.Client.GetContractInfoAsync(fxContract.ContractRecord.Contract);
Assert.Equal((ulong)fxContract.ContractParams.InitialBalance, info.Balance);
// Call the contract, sending to the address of the now deleted account
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxContract.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fxContract.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(600),
FunctionName = "send_to",
FunctionArgs = new[] { fxAccount.Record.Address }
});
});
Assert.Equal(ResponseCode.InvalidSolidityAddress, tex.Status);
Assert.StartsWith("Contract call failed, status: InvalidSolidityAddress", tex.Message);
// Confirm that the balance on the contract remained unchanged.
var contractBalanceAfter = await fxContract.Client.CallContractWithRecordAsync(new CallContractParams
{
Contract = fxContract.ContractRecord.Contract,
Gas = await _network.TinybarsFromGas(400),
FunctionName = "get_balance"
});
Assert.NotNull(contractBalanceAfter);
Assert.Equal(fxContract.ContractParams.InitialBalance, contractBalanceAfter.CallResult.Result.As <long>());
// Ensure matches API vesion.
apiBalance = await fxContract.Client.GetContractBalanceAsync(fxContract.ContractRecord.Contract);
Assert.Equal((ulong)fxContract.ContractParams.InitialBalance, apiBalance);
// Ensure matches Info version
info = await fxContract.Client.GetContractInfoAsync(fxContract.ContractRecord.Contract);
Assert.Equal((ulong)fxContract.ContractParams.InitialBalance, info.Balance);
}
async Task TransferringAssetAppliesSingleFixedCommision()
{
await using var fxBuyer = await TestAccount.CreateAsync(_network);
await using var fxSeller = await TestAccount.CreateAsync(_network);
await using var fxBenefactor = await TestAccount.CreateAsync(_network);
await using var fxPaymentToken = await TestToken.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxBenefactor, fxBuyer, fxSeller);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx =>
{
fx.Params.Royalties = new FixedRoyalty[]
{
new FixedRoyalty(fxBenefactor, fxPaymentToken, 10)
};
fx.Params.GrantKycEndorsement = null;
}, fxBuyer, fxSeller);
Assert.Equal(ResponseCode.Success, fxAsset.Record.Status);
var movedAsset = new Asset(fxAsset, 1);
await fxPaymentToken.Client.TransferTokensAsync(fxPaymentToken, fxPaymentToken.TreasuryAccount, fxBuyer, 100, fxPaymentToken.TreasuryAccount);
await fxPaymentToken.Client.TransferAssetAsync(movedAsset, fxAsset.TreasuryAccount, fxSeller, fxAsset.TreasuryAccount);
await AssertHg.AssetBalanceAsync(fxAsset, fxBuyer, 0);
await AssertHg.AssetBalanceAsync(fxAsset, fxSeller, 1);
await AssertHg.AssetBalanceAsync(fxAsset, fxBenefactor, 0);
await AssertHg.AssetBalanceAsync(fxAsset, fxAsset.TreasuryAccount, fxAsset.Metadata.Length - 1);
await AssertHg.AssetBalanceAsync(fxAsset, fxPaymentToken.TreasuryAccount, 0);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxBuyer, 100);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxSeller, 0);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxBenefactor, 0);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxAsset.TreasuryAccount, 0);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxPaymentToken.TreasuryAccount, fxPaymentToken.Params.Circulation - 100);
var record = await fxAsset.Client.TransferWithRecordAsync(new TransferParams
{
AssetTransfers = new[] {
new AssetTransfer(movedAsset, fxSeller, fxBuyer)
},
TokenTransfers = new[] {
new TokenTransfer(fxPaymentToken, fxBuyer, -100),
new TokenTransfer(fxPaymentToken, fxSeller, 100),
},
Signatory = new Signatory(fxBuyer, fxSeller)
});
Assert.Equal(ResponseCode.Success, record.Status);
Assert.False(record.Hash.IsEmpty);
Assert.NotNull(record.Concensus);
Assert.NotNull(record.CurrentExchangeRate);
Assert.NotNull(record.NextExchangeRate);
Assert.Empty(record.Memo);
Assert.InRange(record.Fee, 0UL, ulong.MaxValue);
Assert.Equal(_network.Payer, record.Id.Address);
Assert.Equal(3, record.TokenTransfers.Count);
Assert.Contains(new TokenTransfer(fxPaymentToken, fxBuyer, -100), record.TokenTransfers);
Assert.Contains(new TokenTransfer(fxPaymentToken, fxSeller, 90), record.TokenTransfers);
Assert.Contains(new TokenTransfer(fxPaymentToken, fxBenefactor, 10), record.TokenTransfers);
Assert.Single(record.AssetTransfers);
Assert.Contains(new AssetTransfer(movedAsset, fxSeller, fxBuyer), record.AssetTransfers);
Assert.Empty(record.Associations);
Assert.Single(record.Royalties);
AssertHg.ContainsRoyalty(fxPaymentToken, fxSeller, fxBenefactor, 10, record.Royalties);
await AssertHg.AssetBalanceAsync(fxAsset, fxBuyer, 1);
await AssertHg.AssetBalanceAsync(fxAsset, fxSeller, 0);
await AssertHg.AssetBalanceAsync(fxAsset, fxBenefactor, 0);
await AssertHg.AssetBalanceAsync(fxAsset, fxAsset.TreasuryAccount, fxAsset.Metadata.Length - 1);
await AssertHg.AssetBalanceAsync(fxAsset, fxPaymentToken.TreasuryAccount, 0);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxBuyer, 0);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxSeller, 90);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxBenefactor, 10);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxAsset.TreasuryAccount, 0);
await AssertHg.TokenBalanceAsync(fxPaymentToken, fxPaymentToken.TreasuryAccount, fxPaymentToken.Params.Circulation - 100);
}
public async Task CanScheduleBurnAssetCoins()
{
await using var fxPayer = await TestAccount.CreateAsync(_network, ctx => ctx.CreateParams.InitialBalance = 40_00_000_000);
await using var fxAsset = await TestAsset.CreateAsync(_network);
var amountToDestory = fxAsset.Metadata.Length / 3 + 1;
var expectedCirculation = (ulong)(fxAsset.Metadata.Length - amountToDestory);
var serialNumbers = Enumerable.Range(1, amountToDestory).Select(i => (long)i);
var pendingReceipt = await fxAsset.Client.BurnAssetsAsync(
fxAsset.Record.Token,
serialNumbers,
new Signatory(
fxAsset.SupplyPrivateKey,
new PendingParams
{
PendingPayer = fxPayer
}));
Assert.Equal(ResponseCode.Success, pendingReceipt.Status);
// This should be considered a network bug.
Assert.Equal(0UL, pendingReceipt.Circulation);
await AssertHg.AssetBalanceAsync(fxAsset, fxAsset.TreasuryAccount, (ulong)fxAsset.Metadata.Length);
var signingReceipt = await fxPayer.Client.SignPendingTransactionAsync(pendingReceipt.Pending.Id, fxPayer.PrivateKey); // As TokenReceipt
Assert.Equal(ResponseCode.Success, signingReceipt.Status);
var executedReceipt = await fxPayer.Client.GetReceiptAsync(pendingReceipt.Pending.TxId) as TokenReceipt;
Assert.Equal(ResponseCode.Success, executedReceipt.Status);
Assert.Equal(expectedCirculation, executedReceipt.Circulation);
var executedRecord = await fxPayer.Client.GetTransactionRecordAsync(pendingReceipt.Pending.TxId) as TokenRecord;
Assert.Equal(ResponseCode.Success, executedRecord.Status);
Assert.Equal(expectedCirculation, executedRecord.Circulation);
await AssertHg.AssetBalanceAsync(fxAsset, fxAsset.TreasuryAccount, expectedCirculation);
var info = await fxAsset.Client.GetTokenInfoAsync(fxAsset);
Assert.Equal(fxAsset.Record.Token, info.Token);
Assert.Equal(fxAsset.Params.Symbol, info.Symbol);
Assert.Equal(fxAsset.TreasuryAccount.Record.Address, info.Treasury);
Assert.Equal(expectedCirculation, info.Circulation);
Assert.Equal(0ul, info.Decimals);
Assert.Equal(fxAsset.Params.Ceiling, info.Ceiling);
Assert.Equal(fxAsset.Params.Administrator, info.Administrator);
Assert.Equal(fxAsset.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxAsset.Params.PauseEndorsement, info.PauseEndorsement);
Assert.Equal(fxAsset.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxAsset.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxAsset.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(fxAsset.Params.RoyaltiesEndorsement, info.RoyaltiesEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenTradableStatus.Tradable, info.PauseStatus);
Assert.Equal(TokenKycStatus.Revoked, info.KycStatus);
Assert.Empty(info.Royalties);
Assert.False(info.Deleted);
Assert.Equal(fxAsset.Params.Memo, info.Memo);
// NETWORK V0.21.0 UNSUPPORTED vvvv
// NOT IMPLEMENTED YET
Assert.Empty(info.Ledger.ToArray());
// NETWORK V0.21.0 UNSUPPORTED ^^^^
}
public void Withdraw_cannot_exceed_1000()
{
var account = new TestAccount(testOwner, testBalance);
Assert.Throws <ArgumentException>(() => account.Withdraw(oneThousand));
}
public async Task CannotDeleteTreasuryWhileAttachedToToken()
{
await using var fxAccount1 = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 120_00_000_000);
await using var fxAccount2 = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 120_00_000_000);
await using var fxToken = await TestToken.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount1, fxAccount2);
var circulation = fxToken.Params.Circulation;
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAccount1.Client.DeleteAccountAsync(fxToken.TreasuryAccount, fxAccount1, ctx =>
{
ctx.Payer = fxAccount1;
ctx.Signatory = new Signatory(fxAccount1, fxToken.TreasuryAccount);
});
});
Assert.Equal(ResponseCode.AccountIsTreasury, tex.Status);
Assert.StartsWith("Unable to delete account, status: AccountIsTreasury", tex.Message);
await fxAccount1.Client.TransferTokensAsync(fxToken, fxToken.TreasuryAccount, fxAccount2, (long)fxToken.Params.Circulation, fxToken.TreasuryAccount);
tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAccount1.Client.DeleteAccountAsync(fxToken.TreasuryAccount, fxAccount1, ctx =>
{
ctx.Payer = fxAccount1;
ctx.Signatory = new Signatory(fxAccount1, fxToken.TreasuryAccount);
});
});
Assert.Equal(ResponseCode.AccountIsTreasury, tex.Status);
Assert.StartsWith("Unable to delete account, status: AccountIsTreasury", tex.Message);
// Confirm Tokens still exist in account 2
Assert.Equal(0ul, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(fxToken.Params.Circulation, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
// What does the info say,
var info = await fxToken.Client.GetTokenInfoAsync(fxToken.Record.Token);
Assert.Equal(fxToken.Record.Token, info.Token);
Assert.Equal(fxToken.Params.Symbol, info.Symbol);
Assert.Equal(fxToken.TreasuryAccount.Record.Address, info.Treasury);
Assert.Equal(fxToken.Params.Circulation, info.Circulation);
Assert.Equal(fxToken.Params.Decimals, info.Decimals);
Assert.Equal(fxToken.Params.Ceiling, info.Ceiling);
Assert.Equal(fxToken.Params.Administrator, info.Administrator);
Assert.Equal(fxToken.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxToken.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxToken.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxToken.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(fxToken.Params.RoyaltiesEndorsement, info.RoyaltiesEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenTradableStatus.Tradable, info.PauseStatus);
Assert.Equal(TokenKycStatus.NotApplicable, info.KycStatus);
Assert.Empty(info.Royalties);
Assert.False(info.Deleted);
Assert.Equal(fxToken.Params.Memo, info.Memo);
// NETWORK V0.21.0 UNSUPPORTED vvvv
// NOT IMPLEMENTED YET
Assert.Empty(info.Ledger.ToArray());
// NETWORK V0.21.0 UNSUPPORTED ^^^^
// Move the Treasury, hmm...don't need treasury key?
await fxToken.Client.UpdateTokenAsync(new UpdateTokenParams
{
Token = fxToken,
Treasury = fxAccount1,
Signatory = new Signatory(fxToken.AdminPrivateKey, fxAccount1.PrivateKey)
});
// Double check balances
Assert.Equal(0ul, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(fxToken.Params.Circulation, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
// What does the info say now?
info = await fxToken.Client.GetTokenInfoAsync(fxToken.Record.Token);
Assert.Equal(fxToken.Record.Token, info.Token);
Assert.Equal(fxToken.Params.Symbol, info.Symbol);
Assert.Equal(fxAccount1.Record.Address, info.Treasury);
Assert.Equal(fxToken.Params.Circulation, info.Circulation);
Assert.Equal(fxToken.Params.Decimals, info.Decimals);
Assert.Equal(fxToken.Params.Ceiling, info.Ceiling);
Assert.Equal(fxToken.Params.Administrator, info.Administrator);
Assert.Equal(fxToken.Params.GrantKycEndorsement, info.GrantKycEndorsement);
Assert.Equal(fxToken.Params.SuspendEndorsement, info.SuspendEndorsement);
Assert.Equal(fxToken.Params.ConfiscateEndorsement, info.ConfiscateEndorsement);
Assert.Equal(fxToken.Params.SupplyEndorsement, info.SupplyEndorsement);
Assert.Equal(fxToken.Params.RoyaltiesEndorsement, info.RoyaltiesEndorsement);
Assert.Equal(TokenTradableStatus.Tradable, info.TradableStatus);
Assert.Equal(TokenTradableStatus.Tradable, info.PauseStatus);
Assert.Equal(TokenKycStatus.NotApplicable, info.KycStatus);
Assert.Empty(info.Royalties);
Assert.False(info.Deleted);
Assert.Equal(fxToken.Params.Memo, info.Memo);
// NETWORK V0.21.0 UNSUPPORTED vvvv
// NOT IMPLEMENTED YET
Assert.Empty(info.Ledger.ToArray());
// NETWORK V0.21.0 UNSUPPORTED ^^^^
}
public void Test_ImportFromXml_RenewSchema_TypeAndProperty()
{
Version currentVersion = new Version(1, 0, 0, 0);
Version legacyVersion = new Version(0, 9, 0, 0);
TestUser user = new TestUser();
user.ID = Guid.NewGuid();
user.FirstName = "Test";
user.LastName = "Test";
TestRole role = new TestRole();
role.ID = Guid.NewGuid();
role.Name = "Test Role";
user.Roles = new TestRole[] { role };
DataExporter exporter = (DataExporter)DataAccess.Data.InitializeDataExporter();
exporter.ExportDirectoryPath = TestUtilities.GetTestingPath(this) + Path.DirectorySeparatorChar + "Exported";
// IMPORTANT: Export the references before the entities, because the references are stripped from the entities upon export
// Alternative is to reactivate the entities and their references using DataAccess.Data.Activator.
EntityReferenceCollection references = DataAccess.Data.Referencer.GetActiveReferences(user);
exporter.ExportEntity(references[0]);
exporter.ExportEntity(user);
exporter.ExportEntity(role);
DataSchema schema = (DataSchema)DataAccess.Data.Schema;
schema.LegacyVersion = legacyVersion;
schema.ApplicationVersion = currentVersion;
schema.SchemaCommandDirectoryPath = TestUtilities.GetTestingPath(this) + Path.DirectorySeparatorChar + "Schema";
RenamePropertyCommand command1 = new RenamePropertyCommand();
command1.TypeName = user.ShortTypeName;
command1.PropertyName = "Roles";
command1.NewPropertyName = "GrantedRoles";
RenameTypeCommand command2 = new RenameTypeCommand();
command2.TypeName = user.ShortTypeName;
command2.NewTypeName = typeof(TestAccount).Name;
RenamePropertyCommand command3 = new RenamePropertyCommand();
command3.TypeName = role.ShortTypeName;
command3.PropertyName = "Users";
command3.NewPropertyName = "Accounts";
DataSchemaCommandCollection commands = new DataSchemaCommandCollection();
commands.Add(command1);
commands.Add(command2);
commands.Add(command3);
schema.SchemaCommands = commands;
DataImporter importer = (DataImporter)DataAccess.Data.Importer;
importer.ImportableDirectoryPath = exporter.ExportDirectoryPath;
importer.ImportedDirectoryPath = TestUtilities.GetTestingPath(this) + Path.DirectorySeparatorChar + "Imported";
importer.ImportFromXml();
TestAccount foundAccount = DataAccess.Data.Reader.GetEntity <TestAccount>("ID", user.ID);
Assert.IsNotNull(foundAccount, "foundAccount == null");
Assert.AreEqual(user.ID.ToString(), foundAccount.ID.ToString(), "The ID of the found account doesn't match the ID of the original user.");
DataAccess.Data.Activator.Activate(foundAccount, "GrantedRoles");
Assert.IsNotNull(foundAccount.GrantedRoles, "user.GrantedRoles == null");
Assert.AreEqual(1, foundAccount.GrantedRoles.Length, "Invalid number of roles found.");
TestRole foundRole = DataAccess.Data.Reader.GetEntity <TestRole>("ID", role.ID);
Assert.IsNotNull(foundRole, "foundRole == null");
Assert.AreEqual(role.ID.ToString(), foundRole.ID.ToString(), "The ID of the found role doesn't match the ID of the original role.");
}
public void RemoteTest()
{
try {
//int, String and return String testing
int Id = 18;
String name = "JimT";
String result = manager.sayHello(Id, name);
Logging.LogDebug("result: " + result);
//no parameter, void return testing
manager.doSomething();
//object parameter, object return testing
TestAccount account = new TestAccount();
account.setId(1000);
account.setName("JimT");
account = manager.getAccount(account);
Logging.LogDebug(account);
//all primitive type parameter, object return testing
AllTypeBean allTypeBean = manager.getAllTypeBean(true, (byte)25, (short)-2, 'T', 3, (long)4, 5.5f, 6.66d, DateTime.Now, "Hello JimT!");
Logging.LogDebug("allTypeBean: " + allTypeBean);
//int array and string array, string array return testing
int[] intarr = new int[3];
intarr[0] = 1;
intarr[1] = 2;
intarr[2] = 3;
String[] strarr = new String[3];
strarr[0] = "Jim ";
strarr[1] = "Tang ";
strarr[2] = "Toronto ";
strarr = manager.getArray(intarr, strarr);
if (strarr != null)
{
for (int i = 0; i < strarr.Length; i++)
{
Logging.LogDebug("strarr: " + strarr[i]);
}
}
//below two are not for performance test
//compress testing
account = new TestAccount();
account.setId(1000);
string str = "";
for (int i = 0; i < 50; i++)
{
str += "The quick brown fox jumps over the lazy dog. ";
}
account.setName(str);
account = manager.getAccountCompress(account);
Logging.LogDebug(account);
//asychronous testing
account = new TestAccount();
account.setId(1000);
account.setName("JimT");
account = manager.getAccountAsynchronous(account);
Logging.LogDebug(account);
} catch (Exception ex) {
Logging.LogError(ex.ToString());
}
}
public void TestCharacterListUpdate()
{
var firstMobile = new Mobile(0x1);
firstMobile.DefaultMobileInit();
firstMobile.Name = "Test Mobile";
var account = new TestAccount(new[] { firstMobile, null, null, null, null });
var data = new CharacterListUpdate(account).Compile();
Span <byte> expectedData = stackalloc byte[4 + account.Length * 60];
var pos = 0;
expectedData.Write(ref pos, (byte)0x86); // Packet ID
expectedData.Write(ref pos, (ushort)expectedData.Length); // Length
var highSlot = -1;
for (var i = account.Length - 1; i >= 0; i--)
{
if (account[i] != null)
{
highSlot = i;
break;
}
}
var count = Math.Max(Math.Max(highSlot + 1, account.Limit), 5);
expectedData.Write(ref pos, (byte)count);
for (var i = 0; i < count; i++)
{
var m = account[i];
if (m != null)
{
expectedData.WriteAsciiFixed(ref pos, m.Name, 30);
#if NO_LOCAL_INIT
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, 0);
expectedData.Write(ref pos, (ushort)0);
#else
pos += 30;
#endif
}
else
{
#if NO_LOCAL_INIT
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, 0);
#else
pos += 60;
#endif
}
}
AssertThat.Equal(data, expectedData);
}
public static async Task AssetBalanceAsync(TestAsset fxAsset, TestAccount fxAccount, int expectedBalance)
{
var balance = await fxAsset.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset);
Assert.Equal((ulong)expectedBalance, balance);
}
public void TestCharacterListOld()
{
var firstMobile = new Mobile(0x1);
firstMobile.DefaultMobileInit();
firstMobile.Name = "Test Mobile";
var account = new TestAccount(new[] { firstMobile, null, null, null, null });
var info = new[]
{
new CityInfo("Test City", "Test Building", 50, 100, 10, -10)
};
var data = new CharacterListOld(account, info).Compile();
Span <byte> expectedData = stackalloc byte[9 + account.Length * 60 + info.Length * 63];
var pos = 0;
expectedData.Write(ref pos, (byte)0xA9); // Packet ID
expectedData.Write(ref pos, (ushort)expectedData.Length); // Length
var highSlot = -1;
for (var i = account.Length - 1; i >= 0; i--)
{
if (account[i] != null)
{
highSlot = i;
break;
}
}
var count = Math.Max(Math.Max(highSlot + 1, account.Limit), 5);
expectedData.Write(ref pos, (byte)count);
for (var i = 0; i < count; i++)
{
var m = account[i];
if (m != null)
{
expectedData.WriteAsciiFixed(ref pos, m.Name, 30);
#if NO_LOCAL_INIT
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, 0);
expectedData.Write(ref pos, (ushort)0);
#else
pos += 30;
#endif
}
else
{
#if NO_LOCAL_INIT
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, (ulong)0);
expectedData.Write(ref pos, 0);
#else
pos += 60;
#endif
}
}
expectedData.Write(ref pos, (byte)info.Length);
for (var i = 0; i < info.Length; i++)
{
var ci = info[i];
expectedData.Write(ref pos, (byte)i);
expectedData.WriteAsciiFixed(ref pos, ci.City, 31);
expectedData.WriteAsciiFixed(ref pos, ci.Building, 31);
}
var flags = ExpansionInfo.GetInfo(Expansion.EJ).CharacterListFlags;
if (count > 6)
{
flags |= CharacterListFlags.SeventhCharacterSlot |
CharacterListFlags.SixthCharacterSlot; // 7th Character Slot
}
else if (count == 6)
{
flags |= CharacterListFlags.SixthCharacterSlot; // 6th Character Slot
}
else if (account.Limit == 1)
{
flags |= CharacterListFlags.SlotLimit &
CharacterListFlags.OneCharacterSlot; // Limit Characters & One Character
}
expectedData.Write(ref pos, (int)flags);
AssertThat.Equal(data, expectedData);
}
public static Task CryptoBalanceAsync(TestAccount fxAccount, int expectedBalance)
{
return(CryptoBalanceAsync(fxAccount, (ulong)expectedBalance));
}
public int CompareTo(TestAccount other) => other == null ? 1 : Username.CompareTo(other.Username);
public async Task CanScheduleATransferThatShouldImmediatelyExecute()
{
var initialBalance = (ulong)Generator.Integer(100, 1000);
var transferAmount = initialBalance / 2;
await using var fxSender = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = initialBalance);
await using var fxReceiver = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = initialBalance);
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
var pendingSignatory = new Signatory(fxPayer.PrivateKey, fxSender.PrivateKey, new PendingParams {
PendingPayer = fxPayer
});
var record = await fxSender.Client.TransferWithRecordAsync(fxSender, fxReceiver, (long)transferAmount, pendingSignatory);
var info = await fxPayer.Client.GetPendingTransactionInfoAsync(record.Pending.Id);
Assert.Equal(record.Pending.Id, info.Id);
Assert.Equal(record.Pending.TxId, info.TxId);
Assert.Equal(_network.Payer, info.Creator);
Assert.Equal(fxPayer.Record.Address, info.Payer);
Assert.Equal(2, info.Endorsements.Length);
Assert.Equal(new Endorsement(fxPayer.PublicKey), info.Endorsements[0]);
Assert.Null(info.Administrator);
Assert.Empty(info.Memo);
Assert.True(info.Expiration > DateTime.MinValue);
Assert.True(record.Concensus <= info.Executed);
Assert.Null(info.Deleted);
Assert.False(info.PendingTransactionBody.IsEmpty);
AssertHg.NotEmpty(info.Ledger);
await AssertHg.CryptoBalanceAsync(fxSender, initialBalance - transferAmount);
await AssertHg.CryptoBalanceAsync(fxReceiver, initialBalance + transferAmount);
Assert.True(await fxPayer.Client.GetAccountBalanceAsync(fxPayer) < fxPayer.CreateParams.InitialBalance);
var executedReceipt = await fxPayer.Client.GetReceiptAsync(record.Pending.TxId);
Assert.Equal(ResponseCode.Success, executedReceipt.Status);
Assert.Equal(record.Pending.TxId, executedReceipt.Id);
Assert.NotNull(executedReceipt.CurrentExchangeRate);
Assert.NotNull(executedReceipt.NextExchangeRate);
Assert.Null(executedReceipt.Pending);
var executedRecord = await fxPayer.Client.GetTransactionRecordAsync(record.Pending.TxId);
Assert.Equal(ResponseCode.Success, executedRecord.Status);
Assert.Equal(record.Pending.TxId, executedRecord.Id);
Assert.InRange(executedRecord.Fee, 0UL, ulong.MaxValue);
Assert.Equal(executedRecord.Transfers[fxSender], -(long)transferAmount);
Assert.Equal(executedRecord.Transfers[fxReceiver], (long)transferAmount);
Assert.True(executedRecord.Transfers[fxPayer] < 0);
Assert.Empty(executedRecord.TokenTransfers);
Assert.False(executedRecord.Hash.IsEmpty);
Assert.NotNull(executedRecord.Concensus);
Assert.NotNull(executedRecord.CurrentExchangeRate);
Assert.NotNull(executedRecord.NextExchangeRate);
Assert.Empty(executedRecord.Memo);
Assert.Null(executedRecord.Pending);
}
static int _CreateTestAccount(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 3)
{
int arg0 = (int)LuaDLL.luaL_checknumber(L, 1);
string arg1 = ToLua.CheckString(L, 2);
int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
TestAccount obj = new TestAccount(arg0, arg1, arg2);
ToLua.PushObject(L, obj);
return 1;
}
else
{
return LuaDLL.luaL_throw(L, "invalid arguments to ctor method: TestAccount.New");
}
}
catch(Exception e)
{
return LuaDLL.toluaL_exception(L, e);
}
}
