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)); }