public void ProcessesFiles(string pdfPath)
{
var csvFile = Path.Combine(
Path.GetDirectoryName(pdfPath),
Path.GetFileNameWithoutExtension(pdfPath) + ".csv");
var expectedResult = File.ReadAllText(csvFile);
var statement = _fileProcessor.Process(pdfPath)
.ShouldHaveSingleItem();
var actualResult = _transactionSerializer
.Serialize(statement.Transactions.ToArray());
actualResult.ShouldBe(expectedResult);
}
public void Serialize_WithSupportedTransaction_ShouldInvokePayloadSerializer(
int version,
int id,
params byte[] expected)
{
// Arrange.
var tx = new FakeTransaction(null, null, id, version);
var serializer = new FakeTransactionPayloadSerializer(tx.Id);
var subject = new TransactionSerializer(new[] { serializer });
var writer = new ArrayBufferWriter <byte>();
serializer.StubbedSerialize
.Setup(f => f(It.IsAny <IBufferWriter <byte> >(), It.IsAny <Elysium.Transaction>()))
.Callback((IBufferWriter <byte> writer, Elysium.Transaction tx) =>
{
writer.Write(new ReadOnlySpan <byte>(expected, 4, expected.Length - 4));
});
// Act.
subject.Serialize(writer, tx);
// Assert.
Assert.Equal(expected, writer.WrittenSpan.ToArray());
serializer.StubbedSerialize.Verify(f => f(writer, tx), Times.Once());
}
public async Task <Hash32> Invoke(Transaction tx)
{
var ts = new TransactionSerializer();
var request = new SendTransactionRequestMessage(ts.Serialize(tx));
var response = await Invoke(request);
return(response.Result);
}
public async Task <Hash32> Invoke(Transaction tx)
{
var ts = new TransactionSerializer();
var request = new SendTransactionRequestMessage(ts.Serialize(tx));
var response = await Invoke(request);
if (response.IsSuccess)
{
return(new Hash32(response.result.Replace("0x", "")));
}
throw new Exception(response.Error.Message);
}
public async Task <IActionResult> BuildClaim([FromBody] BuildClaimTransactionRequest request)
{
if (request == null)
{
return(BadRequest(ErrorResponse.Create("Unable to deserialize request")));
}
var addressValid = _addressValidator.IsAddressValid(request.Address);
if (!addressValid)
{
return(BadRequest(ErrorResponse.Create("Invalid address")));
}
var built = await _transactionBuilder.BuildClaimTransactions(request.Address);
var aggregate = await _operationRepository.GetOrInsert(request.OperationId,
() => OperationAggregate.StartNew(request.OperationId,
fromAddress: request.Address,
toAddress: request.Address,
amount: built.availiableGas,
assetId: Constants.Assets.Gas.AssetId,
fee: 0,
includeFee: false));
if (aggregate.IsBroadcasted)
{
return(Conflict());
}
if (!built.tx.Claims.Any())
{
return(Accepted(new BuiltClaimTransactionResponse
{
ClaimedGas = MoneyConversionHelper.ToContract(built.availiableGas, Constants.Assets.Gas.AssetId),
AllGas = MoneyConversionHelper.ToContract(built.unclaimedGas, Constants.Assets.Gas.AssetId),
TransactionContext = TransactionSerializer.Serialize(built.tx, TransactionType.ClaimTransaction)
}));
}
return(Ok(new BuiltClaimTransactionResponse
{
ClaimedGas = MoneyConversionHelper.ToContract(built.availiableGas, Constants.Assets.Gas.AssetId),
AllGas = MoneyConversionHelper.ToContract(built.unclaimedGas, Constants.Assets.Gas.AssetId),
TransactionContext = TransactionSerializer.Serialize(built.tx, TransactionType.ClaimTransaction)
}));
}
public IActionResult Sign([FromBody] SignTransactionRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
try
{
var txWrapper = TransactionSerializer.Deserialize(request.TransactionContext);
var tx = txWrapper.transaction;
var keyPair = new KeyPair(Wallet.GetPrivateKeyFromWif(request.PrivateKeys.Single()));
var signature = Transaction.Sign(keyPair, tx, false);
var invocationScript = NeoModules.Core.Helper.HexToBytes(("40" + signature.ToHexString()));
var verificationScript = Helper.CreateSignatureRedeemScript(keyPair.PublicKey);
tx.Witnesses = new[]
{
new Witness
{
InvocationScript = invocationScript,
VerificationScript = verificationScript
}
};
return(Ok(new SignedTransactionResponse
{
SignedTransaction = TransactionSerializer.Serialize(tx, txWrapper.type)
}));
}
catch (Exception e)
{
return(BadRequest(ErrorResponse.Create(e.ToAsyncString())));
}
}
public async Task <IActionResult> BuildSingle([FromBody] BuildSingleTransactionRequest request)
{
if (request == null)
{
return(BadRequest(ErrorResponse.Create("Unable to deserialize request")));
}
if (!new [] { Constants.Assets.Neo.AssetId, Constants.Assets.Gas.AssetId }.Contains(request.AssetId))
{
return(BadRequest(ErrorResponse.Create("Invalid assetId")));
}
var amount = MoneyConversionHelper.FromContract(request.Amount, request.AssetId);
if (amount <= 0)
{
return(BadRequest(ErrorResponse.Create($"Amount can't be less or equal to zero: {amount}")));
}
if (request.AssetId == Constants.Assets.Neo.AssetId && amount % 1 != 0)
{
return(BadRequest($"The minimum unit of NEO is 1 and tokens cannot be subdivided.: {amount}"));
}
var toAddressValid = _addressValidator.IsAddressValid(request.ToAddress);
if (!toAddressValid)
{
return(BadRequest(ErrorResponse.Create("Invalid toAddress")));
}
var fromAddressValid = _addressValidator.IsAddressValid(request.FromAddress);
if (!fromAddressValid)
{
return(BadRequest(ErrorResponse.Create("Invalid fromAddress")));
}
if (!ModelState.IsValidOperationId(request.OperationId))
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
if ((await _operationRepository.GetOrDefault(request.OperationId))?.IsBroadcasted ?? false)
{
return(Conflict());
}
Transaction tx;
decimal fee = 0;
switch (request.AssetId)
{
case Constants.Assets.Neo.AssetId:
(tx, fee) = await _transactionBuilder.BuildNeoContractTransactionAsync(request.FromAddress,
request.ToAddress,
amount,
request.IncludeFee);
break;
case Constants.Assets.Gas.AssetId:
tx = await _transactionBuilder.BuildGasTransactionAsync(request.FromAddress,
request.ToAddress,
amount);
break;
default:
throw new ArgumentException("Unknown switch", nameof(request.AssetId));
}
await _operationRepository.GetOrInsert(request.OperationId,
() => OperationAggregate.StartNew(request.OperationId,
fromAddress: request.FromAddress,
toAddress: request.ToAddress,
amount: amount,
assetId: request.AssetId,
fee: fee,
includeFee: request.IncludeFee));
return(Ok(new BuildTransactionResponse
{
TransactionContext = TransactionSerializer.Serialize(tx, TransactionType.ContractTransaction)
}));
}