public async Task CanExecuteMultiTransferTokens()
{
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, fxAccount1, fxAccount2);
var xferAmount = fxToken.Params.Circulation / 3;
var expectedTreasury = fxToken.Params.Circulation - 2 * xferAmount;
var transfers = new TransferParams
{
TokenTransfers = new TokenTransfer[]
{
new TokenTransfer(fxToken, fxAccount1, (long)xferAmount),
new TokenTransfer(fxToken, fxAccount2, (long)xferAmount),
new TokenTransfer(fxToken, fxToken.TreasuryAccount, -2 * (long)xferAmount)
},
Signatory = fxToken.TreasuryAccount.PrivateKey
};
var receipt = await fxToken.Client.TransferAsync(transfers);
Assert.Equal(ResponseCode.Success, receipt.Status);
Assert.Equal(xferAmount, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(xferAmount, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
Assert.Equal(expectedTreasury, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
}
public async Task DeletingAssetPreventsAssetTransfers()
{
await using var fxAccount = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount);
var transferParams = new TransferParams
{
AssetTransfers = new AssetTransfer[] { new AssetTransfer(new Asset(fxAsset.Record.Token, 1), 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);
transferParams = new TransferParams
{
AssetTransfers = new AssetTransfer[] { new AssetTransfer(new Asset(fxAsset.Record.Token, 2), fxAsset.TreasuryAccount, fxAccount) },
Signatory = fxAsset.TreasuryAccount
};
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAsset.Client.TransferAsync(transferParams);
});
Assert.Equal(ResponseCode.TokenWasDeleted, tex.Status);
Assert.Equal(ResponseCode.TokenWasDeleted, tex.Receipt.Status);
Assert.StartsWith("Unable to execute transfers, status: TokenWasDeleted", tex.Message);
}
public async Task NetZeroTransactionIsAllowed()
{
var fx1 = await TestAccount.CreateAsync(_network);
var fx2 = await TestAccount.CreateAsync(_network);
var payer = _network.Payer;
var account1 = fx1.Record.Address;
var account2 = fx2.Record.Address;
var sig1 = new Signatory(fx1.PrivateKey);
var sig2 = new Signatory(fx2.PrivateKey);
var transferAmount = (long)Generator.Integer(100, 200);
var transfers = new TransferParams
{
CryptoTransfers = new Dictionary <AddressOrAlias, long>
{
{ account1, 0 },
{ account2, 0 },
},
Signatory = sig1
};
var aor = await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() =>
{
await fx1.Client.TransferWithRecordAsync(transfers);
});
Assert.Equal("CryptoTransfers", aor.ParamName);
Assert.StartsWith($"The amount to transfer crypto to/from 0.0.{account1.AccountNum} must be a value, negative for transfers out, and positive for transfers in. A value of zero is not allowed.", aor.Message);
Assert.Equal(fx1.CreateParams.InitialBalance, await fx1.Client.GetAccountBalanceAsync(account1));
Assert.Equal(fx2.CreateParams.InitialBalance, await fx2.Client.GetAccountBalanceAsync(account2));
}
public async Task UnblancedMultiTransferRequestsRaiseError()
{
var fx1 = await TestAccount.CreateAsync(_network);
var fx2 = await TestAccount.CreateAsync(_network);
var payer = _network.Payer;
var account1 = fx1.Record.Address;
var account2 = fx2.Record.Address;
var sig1 = new Signatory(fx1.PrivateKey);
var sig2 = new Signatory(fx2.PrivateKey);
var transferAmount = (long)Generator.Integer(100, 200);
var transfers = new TransferParams
{
CryptoTransfers = new Dictionary <AddressOrAlias, long>
{
{ payer, -transferAmount },
{ account1, transferAmount },
{ account2, transferAmount }
}
};
var aor = await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() =>
{
await fx1.Client.TransferWithRecordAsync(transfers);
});
Assert.Equal("CryptoTransfers", aor.ParamName);
Assert.StartsWith("The sum of crypto sends and receives does not balance.", aor.Message);
}
public async Task CanExecuteMultiTransferAssets()
{
await using var fxAccount1 = await TestAccount.CreateAsync(_network);
await using var fxAccount2 = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount1, fxAccount2);
var transfers = new TransferParams
{
AssetTransfers = new AssetTransfer[]
{
new AssetTransfer(new Asset(fxAsset, 1), fxAsset.TreasuryAccount, fxAccount1),
new AssetTransfer(new Asset(fxAsset, 2), fxAsset.TreasuryAccount, fxAccount2)
},
Signatory = fxAsset.TreasuryAccount.PrivateKey
};
var receipt = await fxAsset.Client.TransferAsync(transfers);
Assert.Equal(ResponseCode.Success, receipt.Status);
Assert.Equal(1UL, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxAsset));
Assert.Equal(1UL, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxAsset));
Assert.Equal((ulong)fxAsset.Metadata.Length - 2, await fxAsset.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
}
public async Task CanNotBurnSingleAssetTheTreasuryDoesNotOwn()
{
await using var fxAccount = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount);
var amountToTransfer = 2 * fxAsset.Metadata.Length / 3;
var expectedTreasury = fxAsset.Metadata.Length - amountToTransfer;
var serialNumbersTransfered = Enumerable.Range(1, amountToTransfer).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);
Assert.Equal((ulong)amountToTransfer, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal((ulong)expectedTreasury, await fxAsset.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal((ulong)fxAsset.Metadata.Length, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAsset.Client.BurnAssetAsync(new Asset(fxAsset.Record.Token, 1), fxAsset.SupplyPrivateKey);
});
Assert.Equal(ResponseCode.TreasuryMustOwnBurnedNft, tex.Status);
Assert.Equal(ResponseCode.TreasuryMustOwnBurnedNft, tex.Receipt.Status);
Assert.StartsWith("Unable to Burn Token Coins, status: TreasuryMustOwnBurnedNft", tex.Message);
Assert.Equal((ulong)amountToTransfer, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal((ulong)expectedTreasury, await fxAsset.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal((ulong)fxAsset.Metadata.Length, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
}
public async Task CanConfiscateASingleAsset()
{
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);
Assert.Equal(xferAmount, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(expectedTreasury, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(initialCirculation, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
var receipt = await fxAsset.Client.ConfiscateAssetAsync(new Asset(fxAsset.Record.Token, 1), fxAccount, fxAsset.ConfiscatePrivateKey);
Assert.Equal(ResponseCode.Success, receipt.Status);
Assert.Equal(initialCirculation - 1, receipt.Circulation);
Assert.Equal(1ul, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(expectedTreasury, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(initialCirculation - 1, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
}
async Task MetadataAndSerialNumbersTransferProperly()
{
await using var fxAccount = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount);
var circulation = (ulong)fxAsset.Metadata.Length;
var serialNumbers = Enumerable.Range(1, fxAsset.Metadata.Length).Where(i => i % 2 == 0).Select(i => (long)i).ToArray();
var xferCount = (ulong)serialNumbers.Length;
var expectedTreasury = circulation - xferCount;
var transfers = new TransferParams
{
AssetTransfers = serialNumbers.Select(sn => new AssetTransfer(new Asset(fxAsset, sn), fxAsset.TreasuryAccount, fxAccount)),
Signatory = fxAsset.TreasuryAccount.PrivateKey
};
var receipt = await fxAsset.Client.TransferAsync(transfers);
// Double check balances.
Assert.Equal(xferCount, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(circulation - xferCount, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
// Double Check Metadata
for (long sn = 1; sn <= (long)circulation; sn++)
{
var id = new Asset(fxAsset.Record.Token, sn);
var asset = await fxAccount.Client.GetAssetInfoAsync(id);
Assert.Equal(sn, asset.Asset.SerialNum);
Assert.Equal(fxAsset.Record.Token, asset.Asset);
Assert.Equal(asset.Asset.SerialNum % 2 == 0 ? fxAccount.Record.Address : fxAsset.TreasuryAccount.Record.Address, asset.Owner);
Assert.True(fxAsset.Metadata[sn - 1].Span.SequenceEqual(asset.Metadata.Span));
}
}
internal async Task <PaymentStatus> Pay(string id, int blockNumber, string address, decimal amount)
{
// sale_details -----------------------------------------
var dapiSaleDetailsParams = new DapiSaleDetailsParams
{
PaymentId = id,
BlockNumber = blockNumber
};
var saleDetailsResult = await _dapi.SaleDetails(dapiSaleDetailsParams);
// prepare payment
var destinations = new List <Destination>();
// add fee for each node in the AuthSample
ulong totalAuthSampleFee = 0;
foreach (var item in saleDetailsResult.AuthSample)
{
destinations.Add(new Destination {
Amount = item.Fee, Address = item.Address
});
totalAuthSampleFee += item.Fee;
}
// destination - ServiceProvider
destinations.Add(new Destination
{
Amount = GraftConvert.ToAtomicUnits(amount) - totalAuthSampleFee,
Address = address
});
var transferParams = new TransferParams
{
Destinations = destinations.ToArray(),
DoNotRelay = true,
GetTxHex = true,
GetTxMetadata = true,
GetTxKey = true
};
var transferResult = await _wallet.TransferRta(transferParams);
// DAPI pay
var payParams = new DapiPayParams
{
Address = address,
PaymentId = id,
BlockNumber = blockNumber,
Amount = GraftConvert.ToAtomicUnits(amount),
Transactions = new string[] { transferResult.TxBlob }
};
var payResult = await _dapi.Pay(payParams);
return(await GetSaleStatus(id, blockNumber));
}
public async Task CanExecuteMultiTransferTokensWithRecord()
{
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, fxAccount1, fxAccount2);
var xferAmount = fxToken.Params.Circulation / 3;
var expectedTreasury = fxToken.Params.Circulation - 2 * xferAmount;
var transfers = new TransferParams
{
TokenTransfers = new TokenTransfer[]
{
new TokenTransfer(fxToken, fxAccount1, (long)xferAmount),
new TokenTransfer(fxToken, fxAccount2, (long)xferAmount),
new TokenTransfer(fxToken, fxToken.TreasuryAccount, -2 * (long)xferAmount)
},
Signatory = fxToken.TreasuryAccount.PrivateKey
};
var record = await fxToken.Client.TransferWithRecordAsync(transfers);
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(3, 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(-2 * (long)xferAmount, xferFrom.Amount);
var xferTo1 = record.TokenTransfers.First(x => x.Address == fxAccount1.Record.Address);
Assert.NotNull(xferTo1);
Assert.Equal(fxToken.Record.Token, xferFrom.Token);
Assert.Equal((long)xferAmount, xferTo1.Amount);
var xferTo2 = record.TokenTransfers.First(x => x.Address == fxAccount2.Record.Address);
Assert.NotNull(xferTo2);
Assert.Equal(fxToken.Record.Token, xferFrom.Token);
Assert.Equal((long)xferAmount, xferTo2.Amount);
Assert.Equal(xferAmount, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(xferAmount, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
Assert.Equal(expectedTreasury, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
}
public async Task CanExecuteMultiTransferAssetsWithRecord()
{
await using var fxAccount1 = await TestAccount.CreateAsync(_network);
await using var fxAccount2 = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount1, fxAccount2);
var transfers = new TransferParams
{
AssetTransfers = new AssetTransfer[]
{
new AssetTransfer(new Asset(fxAsset, 1), fxAsset.TreasuryAccount, fxAccount1),
new AssetTransfer(new Asset(fxAsset, 2), fxAsset.TreasuryAccount, fxAccount2)
},
Signatory = fxAsset.TreasuryAccount.PrivateKey
};
var record = await fxAsset.Client.TransferWithRecordAsync(transfers);
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.AssetTransfers.Count);
Assert.Null(record.ParentTransactionConcensus);
var xferTo1 = record.AssetTransfers.First(x => x.To == fxAccount1.Record.Address);
Assert.NotNull(xferTo1);
Assert.Equal(fxAsset.Record.Token, xferTo1.Asset);
Assert.Equal(fxAsset.TreasuryAccount.Record.Address, xferTo1.From);
Assert.Equal(1U, xferTo1.Asset.SerialNum);
var xferTo2 = record.AssetTransfers.First(x => x.To == fxAccount2.Record.Address);
Assert.NotNull(xferTo2);
Assert.Equal(fxAsset.Record.Token, xferTo2.Asset);
Assert.Equal(fxAsset.TreasuryAccount.Record.Address, xferTo2.From);
Assert.Equal(2U, xferTo2.Asset.SerialNum);
Assert.Equal(1UL, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxAsset));
Assert.Equal(1UL, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxAsset));
Assert.Equal((ulong)fxAsset.Metadata.Length - 2, await fxAsset.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
}
public async Task CanScheduleMultiTransferTokenCoins()
{
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
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, fxAccount1, fxAccount2);
var xferAmount = fxToken.Params.Circulation / 3;
var expectedTreasury = fxToken.Params.Circulation - 2 * xferAmount;
var transfers = new TransferParams
{
TokenTransfers = new TokenTransfer[]
{
new TokenTransfer(fxToken, fxAccount1, (long)xferAmount),
new TokenTransfer(fxToken, fxAccount2, (long)xferAmount),
new TokenTransfer(fxToken, fxToken.TreasuryAccount, -2 * (long)xferAmount)
},
Signatory = new Signatory(
fxToken.TreasuryAccount.PrivateKey,
new PendingParams
{
PendingPayer = fxPayer
})
};
var schedulingReceipt = await fxToken.Client.TransferAsync(transfers);
Assert.Equal(ResponseCode.Success, schedulingReceipt.Status);
Assert.Equal(0UL, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(0UL, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
Assert.Equal(fxToken.Params.Circulation, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
var counterReceipt = await fxPayer.Client.SignPendingTransactionAsync(schedulingReceipt.Pending.Id, fxPayer);
Assert.Equal(ResponseCode.Success, counterReceipt.Status);
var transferReceipt = await fxPayer.Client.GetReceiptAsync(schedulingReceipt.Pending.TxId);
Assert.Equal(ResponseCode.Success, schedulingReceipt.Status);
Assert.Equal(xferAmount, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(xferAmount, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
Assert.Equal(expectedTreasury, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
}
public async Task NullSendDictionaryRaisesError()
{
var fx1 = await TestAccount.CreateAsync(_network);
var fx2 = await TestAccount.CreateAsync(_network);
var payer = _network.Payer;
var transferAmount = (long)Generator.Integer(100, 200);
TransferParams testParams = null;
var and = await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await fx1.Client.TransferWithRecordAsync(testParams);
});
Assert.Equal("transfers", and.ParamName);
Assert.StartsWith("The transfer parametes cannot not be null.", and.Message);
}
public async Task CanNotScheduleConfiscateAssetCoins()
{
await using var fxPayer = await TestAccount.CreateAsync(_network);
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);
Assert.Equal(xferAmount, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(expectedTreasury, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(initialCirculation, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAsset.Client.ConfiscateAssetsAsync(
fxAsset,
new long[] { 1 },
fxAccount,
new Signatory(
fxAsset.ConfiscatePrivateKey,
new PendingParams
{
PendingPayer = fxPayer
})
);
});
Assert.Equal(ResponseCode.ScheduledTransactionNotInWhitelist, tex.Status);
Assert.Equal(ResponseCode.ScheduledTransactionNotInWhitelist, tex.Receipt.Status);
Assert.StartsWith("Unable to schedule transaction, status: ScheduledTransactionNotInWhitelist", tex.Message);
}
public async Task CanSendAndReceiveMultipleAccounts()
{
var fx1 = await TestAccount.CreateAsync(_network);
var fx2 = await TestAccount.CreateAsync(_network);
var payer = _network.Payer;
var account1 = fx1.Record.Address;
var account2 = fx2.Record.Address;
var sig1 = new Signatory(fx1.PrivateKey);
var sig2 = new Signatory(fx2.PrivateKey);
var transferAmount = (long)Generator.Integer(100, 200);
var transfers = new TransferParams
{
CryptoTransfers = new Dictionary <AddressOrAlias, long>
{
{ payer, -2 * transferAmount },
{ account1, transferAmount },
{ account2, transferAmount }
}
};
var sendRecord = await fx1.Client.TransferWithRecordAsync(transfers);
Assert.Equal(ResponseCode.Success, sendRecord.Status);
Assert.Equal((ulong)transferAmount + fx1.CreateParams.InitialBalance, await fx1.Client.GetAccountBalanceAsync(account1));
Assert.Equal((ulong)transferAmount + fx2.CreateParams.InitialBalance, await fx2.Client.GetAccountBalanceAsync(account2));
transfers = new TransferParams
{
CryptoTransfers = new Dictionary <AddressOrAlias, long>
{
{ account1, -transferAmount },
{ account2, -transferAmount },
{ payer, 2 * transferAmount }
},
Signatory = new Signatory(sig1, sig2)
};
var returnRecord = await fx1.Client.TransferWithRecordAsync(transfers, ctx => ctx.FeeLimit = 1_000_000);
Assert.Equal(ResponseCode.Success, returnRecord.Status);
Assert.Equal(fx1.CreateParams.InitialBalance, await fx1.Client.GetAccountBalanceAsync(account1));
Assert.Equal(fx2.CreateParams.InitialBalance, await fx2.Client.GetAccountBalanceAsync(account2));
}
public async Task CanScheduleMultiTransferAssetCoins()
{
await using var fxPayer = await TestAccount.CreateAsync(_network, fx => fx.CreateParams.InitialBalance = 20_00_000_000);
await using var fxAccount1 = await TestAccount.CreateAsync(_network);
await using var fxAccount2 = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount1, fxAccount2);
var transfers = new TransferParams
{
AssetTransfers = new AssetTransfer[]
{
new AssetTransfer(new Asset(fxAsset, 1), fxAsset.TreasuryAccount, fxAccount1),
new AssetTransfer(new Asset(fxAsset, 2), fxAsset.TreasuryAccount, fxAccount2)
},
Signatory = new Signatory(
fxAsset.TreasuryAccount.PrivateKey,
new PendingParams
{
PendingPayer = fxPayer
})
};
var schedulingReceipt = await fxAsset.Client.TransferAsync(transfers);
Assert.Equal(ResponseCode.Success, schedulingReceipt.Status);
Assert.Equal(0UL, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxAsset));
Assert.Equal(0UL, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxAsset));
Assert.Equal((ulong)fxAsset.Metadata.Length, await fxAsset.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
var counterReceipt = await fxPayer.Client.SignPendingTransactionAsync(schedulingReceipt.Pending.Id, fxPayer);
Assert.Equal(ResponseCode.Success, counterReceipt.Status);
var transferReceipt = await fxPayer.Client.GetReceiptAsync(schedulingReceipt.Pending.TxId);
Assert.Equal(ResponseCode.Success, schedulingReceipt.Status);
Assert.Equal(1UL, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxAsset));
Assert.Equal(1UL, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxAsset));
Assert.Equal((ulong)fxAsset.Metadata.Length - 2, await fxAsset.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
}
public async Task MissingSendDictionaryRaisesError()
{
var fx1 = await TestAccount.CreateAsync(_network);
var payer = _network.Payer;
var transferAmount = (long)Generator.Integer(100, 200);
var transfers = new TransferParams {
CryptoTransfers = new Dictionary <AddressOrAlias, long> {
}
};
var aor = await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() =>
{
await fx1.Client.TransferWithRecordAsync(transfers);
});
Assert.Equal("CryptoTransfers", aor.ParamName);
Assert.StartsWith("The dictionary of crypto transfers can not be empty", aor.Message);
}
private void SensorCallBack(TransferParams param, object userToken)
{
Action action = new Action(() =>
{
try
{
ExecSensorData(CommandTextParser.GetDeJsonSerialization <PeripheralsLocateInfo>(param.Content));
}
catch (Exception ex)
{
_fLogService.Error("ExistCatch：Auto Sensor CallBack Error:" + ex.ToString());
}
finally
{
_autoReadEvent.Set();
}
});
action.BeginInvoke(null, null);
}
public async Task CanMultiTransferCryptoToNewAccount()
{
await using var fx = await TestAccount.CreateAsync(_network);
var transferAmount = (long)Generator.Integer(10, 100);
var newBalance = await fx.Client.GetAccountBalanceAsync(fx.Record.Address);
Assert.Equal(fx.CreateParams.InitialBalance, newBalance);
var transfers = new TransferParams
{
CryptoTransfers = new Dictionary <AddressOrAlias, long> {
{ _network.Payer, -transferAmount }, { fx.Record.Address, transferAmount }
}
};
var receipt = await fx.Client.TransferAsync(transfers);
var newBalanceAfterTransfer = await fx.Client.GetAccountBalanceAsync(fx.Record.Address);
Assert.Equal(fx.CreateParams.InitialBalance + (ulong)transferAmount, newBalanceAfterTransfer);
}
public async Task CanConfiscateAnAssetGetRecord()
{
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);
Assert.Equal(xferAmount, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(expectedTreasury, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(initialCirculation, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
var record = await fxAsset.Client.ConfiscateAssetWithRecordAsync(new Asset(fxAsset.Record.Token, 1), fxAccount, fxAsset.ConfiscatePrivateKey);
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(initialCirculation - 1, record.Circulation);
Assert.Equal(1ul, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(expectedTreasury, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(initialCirculation - 1, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
Assert.Null(record.ParentTransactionConcensus);
}
public async Task CanExecuteMultiTransferTokensAndCrypto()
{
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, fxAccount1, fxAccount2);
var tokenAmount = fxToken.Params.Circulation / 3;
var expectedTreasury = fxToken.Params.Circulation - 2 * tokenAmount;
var cryptoAmount = (long)Generator.Integer(100, 200);
var transfers = new TransferParams
{
CryptoTransfers = new Dictionary <Address, long>
{
{ _network.Payer, -2 * cryptoAmount },
{ fxAccount1, cryptoAmount },
{ fxAccount2, cryptoAmount }
},
TokenTransfers = new TokenTransfer[]
{
new TokenTransfer(fxToken, fxAccount1, (long)tokenAmount),
new TokenTransfer(fxToken, fxAccount2, (long)tokenAmount),
new TokenTransfer(fxToken, fxToken.TreasuryAccount, -2 * (long)tokenAmount)
},
Signatory = new Signatory(_network.Signatory, fxToken.TreasuryAccount.PrivateKey)
};
var receipt = await fxToken.Client.TransferAsync(transfers);
Assert.Equal(ResponseCode.Success, receipt.Status);
Assert.NotNull(receipt.CurrentExchangeRate);
Assert.NotNull(receipt.NextExchangeRate);
Assert.Equal(_network.Payer, receipt.Id.Address);
Assert.Equal(fxAccount1.CreateParams.InitialBalance + (ulong)cryptoAmount, await fxAccount1.Client.GetAccountBalanceAsync(fxAccount1));
Assert.Equal(fxAccount2.CreateParams.InitialBalance + (ulong)cryptoAmount, await fxAccount2.Client.GetAccountBalanceAsync(fxAccount2));
Assert.Equal(tokenAmount, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(tokenAmount, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
Assert.Equal(expectedTreasury, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
}
public async Task CannotConfiscateWhenNoConfiscationEndorsement()
{
await using var fxAccount = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx =>
{
fx.Params.GrantKycEndorsement = null;
fx.Params.ConfiscateEndorsement = 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);
Assert.Equal(xferAmount, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(expectedTreasury, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(initialCirculation, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAsset.Client.ConfiscateAssetAsync(new Asset(fxAsset, 1), fxAccount, fxAsset.ConfiscatePrivateKey);
});
Assert.Equal(ResponseCode.TokenHasNoWipeKey, tex.Status);
Assert.Equal(ResponseCode.TokenHasNoWipeKey, tex.Receipt.Status);
Assert.StartsWith("Unable to Confiscate Token, status: TokenHasNoWipeKey", tex.Message);
Assert.Equal(xferAmount, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(expectedTreasury, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(initialCirculation, (await fxAsset.Client.GetTokenInfoAsync(fxAsset)).Circulation);
}
public async Task CanExecuteMultiTransferAssetsAndCrypto()
{
await using var fxAccount1 = await TestAccount.CreateAsync(_network);
await using var fxAccount2 = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount1, fxAccount2);
var cryptoAmount = (long)Generator.Integer(100, 200);
var transfers = new TransferParams
{
CryptoTransfers = new Dictionary <AddressOrAlias, long>
{
{ _network.Payer, -2 * cryptoAmount },
{ fxAccount1, cryptoAmount },
{ fxAccount2, cryptoAmount }
},
AssetTransfers = new AssetTransfer[]
{
new AssetTransfer(new Asset(fxAsset, 1), fxAsset.TreasuryAccount, fxAccount1),
new AssetTransfer(new Asset(fxAsset, 2), fxAsset.TreasuryAccount, fxAccount2)
},
Signatory = new Signatory(_network.Signatory, fxAsset.TreasuryAccount.PrivateKey)
};
var receipt = await fxAsset.Client.TransferAsync(transfers);
Assert.Equal(ResponseCode.Success, receipt.Status);
Assert.NotNull(receipt.CurrentExchangeRate);
Assert.NotNull(receipt.NextExchangeRate);
Assert.Equal(_network.Payer, receipt.Id.Address);
Assert.Equal(fxAccount1.CreateParams.InitialBalance + (ulong)cryptoAmount, await fxAccount1.Client.GetAccountBalanceAsync(fxAccount1));
Assert.Equal(fxAccount2.CreateParams.InitialBalance + (ulong)cryptoAmount, await fxAccount2.Client.GetAccountBalanceAsync(fxAccount2));
Assert.Equal(1UL, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxAsset));
Assert.Equal(1UL, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxAsset));
Assert.Equal((ulong)fxAsset.Metadata.Length - 2, await fxAsset.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
}
public async Task CanTransferCryptoFromNewAccountViaDictionary()
{
await using var fx = await TestAccount.CreateAsync(_network);
var transferAmount = (long)(fx.CreateParams.InitialBalance / 2);
await using var client = _network.NewClient();
var info = await client.GetAccountInfoAsync(fx.Record.Address);
Assert.Equal(fx.CreateParams.InitialBalance, info.Balance);
Assert.Equal(new Endorsement(fx.PublicKey), info.Endorsement);
var transfers = new TransferParams
{
CryptoTransfers = new Dictionary <AddressOrAlias, long> {
{ fx.Record.Address, -transferAmount }, { _network.Payer, transferAmount }
},
Signatory = fx.PrivateKey
};
var receipt = await client.TransferAsync(transfers);
var newBalanceAfterTransfer = await client.GetAccountBalanceAsync(fx.Record.Address);
Assert.Equal(fx.CreateParams.InitialBalance - (ulong)transferAmount, newBalanceAfterTransfer);
}
private void TransFerDataHandlerCallback(TransferType type, string content, object userToken)
{
_fLogService.Info("return type..." + type.ToString());
TransferParams param = new TransferParams()
{
TranType = type,
Content = content
};
lock (_lockCallBack)
{
if (userToken != null && _dicCallBack.ContainsKey(userToken.ToString()))
{
_dicCallBack[userToken.ToString()].TransFerParamsCallBack(param, _dicCallBack[userToken.ToString()].UserToKen);
_dicCallBack.Remove(userToken.ToString());
}
}
}
private void UpdateScreenConfig(TransferParams param)
{
OnEquipmentChangeEvent(null, EventArgs.Empty);
}
public void ExecuteCommandCallBack(TransferParams param, TransFerParamsDataHandler callback, object userToken)
{
string userParam = System.Guid.NewGuid().ToString();
try
{
if (_serverProxy == null || !_serverProxy.IsRegisted)
{
return;
}
lock (_lockCallBack)
{
_dicCallBack.Add(userParam, new OpreateCallBack() { UserToKen = userToken, TransFerParamsCallBack = callback });
}
switch (param.TranType)
{
case TransferType.M3_PeripheralsInfo:
_fLogService.Info("开始提供光探头。。。");
PeripheralsFinderAccessor peripherals = new PeripheralsFinderAccessor(_serverProxy);
peripherals.ReadAllPeripheralsOnSenderOrPortFuncCard(ReadPeripheralsResultCallback, userParam);
break;
case TransferType.M3_FunctionCardMonitor:
_fLogService.Info("开始提供多功能卡信息。。。");
FunctionCardFinderAccessor funCard = new FunctionCardFinderAccessor(_serverProxy);
funCard.ReadAllFunctionCardOnPort(ReadFunctionCardCallBack, userParam);
break;
case TransferType.M3_ReadSmartLightHWConfig:
_fLogService.Info("Read HW Bright Exec...");
if (!_smartLightAccessor.ReadHWSmartLightData(param.Content, 0, ReadSmartLightHWConfigCallBack, userParam))
{
ReadSmartLightHWConfigCallBack(new ReadSmartLightDataParams(), userParam);
}
_fLogService.Info("Read HW Bright Finish...");
break;
case TransferType.M3_BlackScreen:
//TODO:黑屏
string commPort1 = string.Empty;
ILEDDisplayInfo leds1 = null;
GetScreenInfoByUDID(param.Content, out commPort1, out leds1);
if (string.IsNullOrEmpty(commPort1) || leds1 == null)
{
TransFerDataHandlerCallback(TransferType.M3_BlackScreen, "false", userParam);
return;
}
SetBlackScreen(TransferType.M3_BlackScreen, commPort1, leds1, 0, userParam);
break;
case TransferType.M3_NormalScreen:
//TODO:正常显示
string commPort2 = string.Empty;
ILEDDisplayInfo leds2 = null;
GetScreenInfoByUDID(param.Content, out commPort1, out leds1);
if (string.IsNullOrEmpty(commPort1) || leds1 == null)
{
TransFerDataHandlerCallback(TransferType.M3_NormalScreen, "false", userParam);
return;
}
SetNormalScreen(TransferType.M3_NormalScreen, commPort2, leds2, 0, userParam);
break;
case TransferType.M3_ReadBrightness:
_fLogService.Info("读取亮度值。。。");
break;
}
}
catch (Exception ex)
{
try
{
lock (_lockCallBack)
{
_dicCallBack.Remove(userParam);
}
}
catch (Exception exc)
{
_fLogService.Error("ExistCatch:去除字典中的ID时出现异常:" + exc.ToString());
}
_fLogService.Error("ExistCatch:CommandBack Exception:" + ex.ToString());
}
}
public async Task CanChangeTreasuryAfterEmptying()
{
await using var fxAccount = await TestAccount.CreateAsync(_network);
await using var fxNewTreasury = await TestAccount.CreateAsync(_network);
await using var fxAsset = await TestAsset.CreateAsync(_network, fx =>
{
fx.Params.GrantKycEndorsement = null;
fx.Params.ConfiscateEndorsement = null;
}, fxAccount, fxNewTreasury);
var serialNumbers = Enumerable.Range(1, fxAsset.Metadata.Length).Select(i => (long)i);
var transfers = new TransferParams
{
AssetTransfers = serialNumbers.Select(sn => new AssetTransfer(new Asset(fxAsset, sn), fxAsset.TreasuryAccount, fxAccount)),
Signatory = fxAsset.TreasuryAccount.PrivateKey
};
var receipt = await fxAsset.Client.TransferAsync(transfers);
// Double check balances.
Assert.Equal((ulong)fxAsset.Metadata.Length, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(0UL, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(0UL, await fxAccount.Client.GetAccountTokenBalanceAsync(fxNewTreasury, fxAsset));
// Can Not move the treasury to an existing account already having tokens
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAsset.Client.UpdateTokenAsync(new UpdateTokenParams
{
Token = fxAsset,
Treasury = fxAccount,
Signatory = new Signatory(fxAsset.AdminPrivateKey, fxAccount.PrivateKey)
});
});
Assert.Equal(ResponseCode.TransactionRequiresZeroTokenBalances, tex.Status);
Assert.Equal(ResponseCode.TransactionRequiresZeroTokenBalances, tex.Receipt.Status);
Assert.StartsWith("Unable to update Token, status: TransactionRequiresZeroTokenBalances", tex.Message);
// Coins have not moved.
Assert.Equal((ulong)fxAsset.Metadata.Length, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(0UL, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(0UL, await fxAccount.Client.GetAccountTokenBalanceAsync(fxNewTreasury, fxAsset));
// Move the treasury to a new account having zero token balance
await fxAsset.Client.UpdateTokenAsync(new UpdateTokenParams
{
Token = fxAsset,
Treasury = fxNewTreasury,
Signatory = new Signatory(fxAsset.AdminPrivateKey, fxNewTreasury.PrivateKey)
});
// Coins have not moved.
Assert.Equal((ulong)fxAsset.Metadata.Length, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAccount, fxAsset));
Assert.Equal(0UL, await fxAccount.Client.GetAccountTokenBalanceAsync(fxAsset.TreasuryAccount, fxAsset));
Assert.Equal(0UL, await fxAccount.Client.GetAccountTokenBalanceAsync(fxNewTreasury, fxAsset));
// What does the info say now?
var info = await fxAsset.Client.GetTokenInfoAsync(fxAsset.Record.Token);
Assert.Equal(fxAsset.Record.Token, info.Token);
Assert.Equal(TokenType.Asset, info.Type);
Assert.Equal(fxAsset.Params.Symbol, info.Symbol);
Assert.Equal(fxNewTreasury.Record.Address, info.Treasury);
Assert.Equal((ulong)fxAsset.Metadata.Length, 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.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 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 CannotDeleteTreasuryWhileAttachedToAsset()
{
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 fxAsset = await TestAsset.CreateAsync(_network, fx => fx.Params.GrantKycEndorsement = null, fxAccount1, fxAccount2);
var circulation = (ulong)fxAsset.Metadata.Length;
var tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAccount1.Client.DeleteAccountAsync(fxAsset.TreasuryAccount, fxAccount1, ctx =>
{
ctx.Payer = fxAccount1;
ctx.Signatory = new Signatory(fxAccount1, fxAsset.TreasuryAccount);
});
});
Assert.Equal(ResponseCode.AccountIsTreasury, tex.Status);
Assert.Equal(ResponseCode.AccountIsTreasury, tex.Receipt.Status);
Assert.StartsWith("Unable to delete account, status: AccountIsTreasury", tex.Message);
var serialNumbersTransfered = Enumerable.Range(1, (int)circulation).Select(i => (long)i);
var transferParams = new TransferParams
{
AssetTransfers = serialNumbersTransfered.Select(sn => new AssetTransfer(new Asset(fxAsset.Record.Token, sn), fxAsset.TreasuryAccount, fxAccount2)),
Signatory = fxAsset.TreasuryAccount
};
await fxAsset.Client.TransferAsync(transferParams);
tex = await Assert.ThrowsAsync <TransactionException>(async() =>
{
await fxAccount1.Client.DeleteAccountAsync(fxAsset.TreasuryAccount, fxAccount1, ctx =>
{
ctx.Payer = fxAccount1;
ctx.Signatory = new Signatory(fxAccount1, fxAsset.TreasuryAccount);
});
});
Assert.Equal(ResponseCode.AccountIsTreasury, tex.Status);
Assert.Equal(ResponseCode.AccountIsTreasury, tex.Receipt.Status);
Assert.StartsWith("Unable to delete account, status: AccountIsTreasury", tex.Message);
// Confirm Assets still exist in account 2
Assert.Equal(0ul, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxAsset));
Assert.Equal(circulation, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxAsset));
// What does the info say,
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(circulation, 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.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 ^^^^
// Move the Treasury, hmm...don't need treasury key?
await fxAsset.Client.UpdateTokenAsync(new UpdateTokenParams
{
Token = fxAsset,
Treasury = fxAccount1,
Signatory = new Signatory(fxAsset.AdminPrivateKey, fxAccount1.PrivateKey)
});
// Double check balances
Assert.Equal(0ul, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxAsset));
Assert.Equal(circulation, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxAsset));
// What does the info say now?
info = await fxAsset.Client.GetTokenInfoAsync(fxAsset.Record.Token);
Assert.Equal(fxAsset.Record.Token, info.Token);
Assert.Equal(fxAsset.Params.Symbol, info.Symbol);
Assert.Equal(fxAccount1.Record.Address, info.Treasury);
Assert.Equal(circulation, 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.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 ^^^^
}
internal static (TransferList?, IEnumerable <TokenTransferList>?) CryptoAndTransferList(TransferParams transfers)
{
if (transfers == null)
{
throw new ArgumentNullException(nameof(transfers), "The transfer parametes cannot not be null.");
}
var cryptoTransfers = transfers.CryptoTransfers == null ? null : RequireInputParameter.CryptoTransferList(transfers.CryptoTransfers);
var tokenTransfers = transfers.TokenTransfers == null ? null : RequireInputParameter.TokenTransferList(transfers.TokenTransfers);
if (cryptoTransfers == null && tokenTransfers == null)
{
throw new ArgumentException(nameof(transfers), "Both crypto and token transfer lists are null. At least one must include transfers.");
}
return(cryptoTransfers, tokenTransfers);
}
public static async void Run()
{
try
{
//var wallet = new Wallet("http://54.84.187.74:29982/", "", "");
var wallet = new Wallet("http://54.84.187.74:29817/", "", "");
//var wallet = new Wallet("http://100.24.50.163:28682/", "", "");
var address = await wallet.GetAddress();
var balance = await wallet.GetBalance();
Console.WriteLine($"Wallet {address} \nbalance: {GraftConvert.FromAtomicUnits(balance.Balance)}\nUnlocked balance: {GraftConvert.FromAtomicUnits(balance.UnlockedBalance)}");
// params
ulong amount = GraftConvert.ToAtomicUnits(1.23M);
string merchantWalletAddress = "FAPnEQ1ev195ntzFnZGtHWDocyDaDPxUyV9SLp1e4seE1QDewvnMotsUwBYLFU5RsDBnJqpQFSsYjZUfP7g1urucLoiSPCv";
string paymentId = Guid.NewGuid().ToString();
//18.214.197.224 rta - alpha1
//18.214.197.50 rta - alpha2
//35.169.179.171 rta - alpha3
//34.192.115.160 rta - alpha4
var dapi = new GraftDapi("http://18.214.197.224:28690/dapi/v2.0/");
//var dapi = new GraftDapi("http://100.24.50.163:28690/dapi/v2.0/");
// sale -----------------------------------------
var dapiParams = new DapiSaleParams
{
PaymentId = paymentId,
SaleDetails = "sale details string",
Address = merchantWalletAddress,
Amount = amount
};
var saleResult = await dapi.Sale(dapiParams);
Console.WriteLine($">>> Sale result: {saleResult.PaymentId}, {saleResult.BlockNumber}");
// sale_status -----------------------------------------
var dapiStatusParams = new DapiSaleStatusParams
{
PaymentId = paymentId,
BlockNumber = saleResult.BlockNumber
};
var saleStatusResult = await dapi.GetSaleStatus(dapiStatusParams);
Console.WriteLine($"Sale status: {saleStatusResult.Status}");
// sale_details -----------------------------------------
var dapiSaleDetailsParams = new DapiSaleDetailsParams
{
PaymentId = paymentId,
BlockNumber = saleResult.BlockNumber
};
var saleDetailsResult = await dapi.SaleDetails(dapiSaleDetailsParams);
var json = JsonConvert.SerializeObject(saleDetailsResult, Formatting.Indented);
Console.WriteLine($"Sale Details:\n{json}");
// prepare payment
var destinations = new List <Destination>();
ulong totalAuthSampleFee = 0;
foreach (var item in saleDetailsResult.AuthSample)
{
destinations.Add(new Destination {
Amount = item.Fee, Address = item.Address
});
totalAuthSampleFee += item.Fee;
}
destinations.Add(new Destination {
Amount = amount - totalAuthSampleFee, Address = merchantWalletAddress
});
var transferParams = new TransferParams
{
Destinations = destinations.ToArray(),
//PaymentId = paymentId,
DoNotRelay = true,
GetTxHex = true,
GetTxMetadata = true,
GetTxKey = true
};
var transferResult = await wallet.TransferRta(transferParams);
json = JsonConvert.SerializeObject(transferResult, Formatting.Indented);
//Console.WriteLine($"Transfer Result:\n{json}");
Console.WriteLine($"Transfer Result: {transferResult.Amount}");
// DAPI pay
var payParams = new DapiPayParams
{
Address = merchantWalletAddress,
PaymentId = paymentId,
BlockNumber = saleResult.BlockNumber,
Amount = amount,
Transactions = new string[] { transferResult.TxBlob }
};
json = JsonConvert.SerializeObject(payParams, Formatting.Indented);
Debug.WriteLine($"Pay Parameters:\n{json}");
var payResult = await dapi.Pay(payParams);
json = JsonConvert.SerializeObject(payResult, Formatting.Indented);
Console.WriteLine($"Pay Result:\n{json}");
while (true)
{
saleStatusResult = await dapi.GetSaleStatus(dapiStatusParams);
Console.WriteLine($"Sale status: {saleStatusResult.Status}");
await Task.Delay(1000);
//saleDetailsResult = await dapi.SaleDetails(dapiSaleDetailsParams);
//json = JsonConvert.SerializeObject(saleDetailsResult, Formatting.Indented);
//Console.WriteLine($"Sale Details:\n{json}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void UpdateConfigMessage(TransferType configType, string comText)
{
TransferParams param = new TransferParams()
{
TranType = configType,
Content = comText
};
_moniDatareader.UpdateConfigMessage(CommandTextParser.SerialCmdTextParamTo(param));
}
private void TransFerParamsDataHandlerCallBack(TransferParams param, object userToken)
{
switch (param.TranType)
{
case TransferType.M3_PeripheralsInfo:
WriteLog("返回光探头数据");
_fLogService.Info("返回光探头数据");
SendData("UpdateOpticalProbeInfo", param.Content);
break;
case TransferType.M3_FunctionCardMonitor:
WriteLog("返回多功能卡信息");
_fLogService.Info("返回多功能卡信息");
SendData("UpdateFunctionCardInfo", param.Content);
break;
case TransferType.M3_ReadSmartLightHWConfig:
WriteLog("返回硬件亮度配置信息");
_fLogService.Info("返回硬件亮度配置信息");
SmartLightConfigInfo smartLight = new SmartLightConfigInfo();
ReadSmartLightDataParams smartparam = CommandTextParser.GetDeJsonSerialization<ReadSmartLightDataParams>(param.Content);
smartLight.DisplayHardcareConfig = smartparam.DisplayConfigBase;
smartLight.HwExecTypeValue = smartparam.BrightHWExecType;
smartLight.ScreenSN = userToken.ToString().Split('|')[1];
if (!_dicHwBrightConfig.ContainsKey(userToken.ToString().Split('|')[0]))
{
_dicHwBrightConfig.Add(userToken.ToString().Split('|')[0], smartparam);
}
_autoResetHWEvent.Set();
SendData("ReadSmartLightHWconfigInfo", CommandTextParser.GetJsonSerialization<SmartLightConfigInfo>(smartLight));
break;
default:
break;
}
}
public async Task CanExecuteMultiTransferTokensAndCryptoWithRecord()
{
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, fxAccount1, fxAccount2);
var tokenAmount = fxToken.Params.Circulation / 3;
var expectedTreasury = fxToken.Params.Circulation - 2 * tokenAmount;
var cryptoAmount = (long)Generator.Integer(100, 200);
var transfers = new TransferParams
{
CryptoTransfers = new Dictionary <Address, long>
{
{ _network.Payer, -2 * cryptoAmount },
{ fxAccount1, cryptoAmount },
{ fxAccount2, cryptoAmount }
},
TokenTransfers = new TokenTransfer[]
{
new TokenTransfer(fxToken, fxAccount1, (long)tokenAmount),
new TokenTransfer(fxToken, fxAccount2, (long)tokenAmount),
new TokenTransfer(fxToken, fxToken.TreasuryAccount, -2 * (long)tokenAmount)
},
Signatory = new Signatory(_network.Signatory, fxToken.TreasuryAccount.PrivateKey)
};
var record = await fxToken.Client.TransferWithRecordAsync(transfers);
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(5, record.Transfers.Count);
Assert.Equal(3, record.TokenTransfers.Count);
Assert.Equal(cryptoAmount, record.Transfers[fxAccount1]);
Assert.Equal(cryptoAmount, record.Transfers[fxAccount2]);
var xferFrom = record.TokenTransfers.First(x => x.Address == fxToken.TreasuryAccount.Record.Address);
Assert.NotNull(xferFrom);
Assert.Equal(fxToken.Record.Token, xferFrom.Token);
Assert.Equal(-2 * (long)tokenAmount, xferFrom.Amount);
var xferTo1 = record.TokenTransfers.First(x => x.Address == fxAccount1.Record.Address);
Assert.NotNull(xferTo1);
Assert.Equal(fxToken.Record.Token, xferFrom.Token);
Assert.Equal((long)tokenAmount, xferTo1.Amount);
var xferTo2 = record.TokenTransfers.First(x => x.Address == fxAccount2.Record.Address);
Assert.NotNull(xferTo2);
Assert.Equal(fxToken.Record.Token, xferFrom.Token);
Assert.Equal((long)tokenAmount, xferTo2.Amount);
Assert.Equal(fxAccount1.CreateParams.InitialBalance + (ulong)cryptoAmount, await fxAccount1.Client.GetAccountBalanceAsync(fxAccount1));
Assert.Equal(fxAccount2.CreateParams.InitialBalance + (ulong)cryptoAmount, await fxAccount2.Client.GetAccountBalanceAsync(fxAccount2));
Assert.Equal(tokenAmount, await fxAccount1.Client.GetAccountTokenBalanceAsync(fxAccount1, fxToken));
Assert.Equal(tokenAmount, await fxAccount2.Client.GetAccountTokenBalanceAsync(fxAccount2, fxToken));
Assert.Equal(expectedTreasury, await fxToken.Client.GetAccountTokenBalanceAsync(fxToken.TreasuryAccount, fxToken));
}
