static void TestSpiDataTransfer(ISpiDataTransfer spi)
{
Console.Write("*** Test SPI data transfer: ");
try {
// cancel the current transfer
spi.CancelCurrentTransfer();
// release the SPI bus, and setthe release status bit to 1
spi.RequestSpiBusRelease(true);
// read the status
SpiEngineStatus response1 = spi.ReadEngineStatus();
// send a SPI word
byte[] data = new byte[NumberOfBytes];
TransferReply reply = spi.Transfer(data);
// cancel current spi transfer
SpiEngineStatus response0 = spi.CancelCurrentTransfer();
// release the spi bus
spi.RequestSpiBusRelease();
Console.WriteLine("completed successfully");
} catch (Exception ex) {
PrintException(ex);
}
}
public async Task TransferDispatchAsync(string sessionId, TransferReply transferReply, string transactionHash, string sendingAddress)
{
await _originatorSessions[sessionId]
.TransferDispatchAsync(
transferReply,
new Transaction(
transactionHash,
DateTime.UtcNow,
sendingAddress));
}
public TransferReplyMessage(
Message message,
Originator originator,
Beneficiary beneficiary,
TransferReply transfer,
VaspInformation vasp)
{
MessageType = MessageType.TransferReply;
Message = message;
Originator = originator;
Beneficiary = beneficiary;
Transfer = transfer;
VASP = vasp;
}
public TransferReplyMessage(
string sessionId,
TransferReplyMessageCode transferReplyMessageCode,
Originator originator,
Beneficiary beneficiary,
TransferReply transfer,
VaspInformation vasp)
{
MessageType = MessageType.TransferReply;
Message = new Message(Guid.NewGuid().ToString(), sessionId, GetMessageCode(transferReplyMessageCode));
Originator = originator;
Beneficiary = beneficiary;
Transfer = transfer;
VASP = vasp;
}
public TransferDispatchMessage(
Message message,
Originator originator,
Beneficiary beneficiary,
TransferReply transfer,
Transaction transaction,
VaspInformation vasp)
{
MessageType = MessageType.TransferDispatch;
Message = message;
Originator = originator;
Beneficiary = beneficiary;
Transfer = transfer;
Transaction = transaction;
VASP = vasp;
}
public TransferDispatchMessage(
string sessionId,
Originator originator,
Beneficiary beneficiary,
TransferReply transfer,
Transaction transaction,
VaspInformation vasp)
{
MessageType = MessageType.TransferDispatch;
Message = new Message(Guid.NewGuid().ToString(), sessionId, "1");
Originator = originator;
Beneficiary = beneficiary;
Transfer = transfer;
Transaction = transaction;
VASP = vasp;
}
public static TransferReply MapTransferFromProto(ProtoTransferReply messageTransfer)
{
if (messageTransfer == null)
{
return(null);
}
Enum.TryParse(messageTransfer.VirtualAssetName, out VirtualAssetType assetType);
var obj = new TransferReply(
assetType,
(TransferType)messageTransfer.TransferType,
messageTransfer.Amount,
messageTransfer.DestinationAddress);
return(obj);
}
public static ProtoTransferReply MapTransferToProto(TransferReply messageTransfer)
{
if (messageTransfer == null)
{
return(null);
}
var proto = new ProtoTransferReply()
{
Amount = messageTransfer.Amount,
TransferType = (int)messageTransfer.TransferType,
VirtualAssetName = messageTransfer.VirtualAssetType.ToString(),
DestinationAddress = messageTransfer.DestinationAddress
};
return(proto);
}
public async Task TransferDispatchAsync(TransferReply transferReply, Transaction transaction)
{
var transferRequest = new TransferDispatchMessage(
this.SessionId,
this._originator,
new Beneficiary("", _beneficiaryVaan.Vaan),
transferReply,
transaction,
_vaspInfo
);
await _transportClient.SendAsync(new MessageEnvelope()
{
Topic = this.CounterPartyTopic,
SigningKey = _privateSigningKey,
EncryptionType = EncryptionType.Symmetric,
EncryptionKey = _sharedSymKeyId
}, transferRequest);
}
public async Task <TransferConfirmationMessage> TransferDispatchAsync(TransferReply transferReply, Transaction transaction)
{
if (_transferConfirmationCompletionSource.Task.Status == TaskStatus.WaitingForActivation)
{
var transferRequest = new TransferDispatchMessage(
this.SessionId,
this._originator,
new Beneficiary("", _beneficiaryVaan.Vaan),
transferReply,
transaction,
_vaspInfo
);
await _transportClient.SendAsync(new MessageEnvelope()
{
Topic = this.CounterPartyTopic,
SigningKey = _privateSigningKey,
EncryptionType = EncryptionType.Symmetric,
EncryptionKey = _sharedSymKeyId
}, transferRequest);
}
return(await _transferConfirmationCompletionSource.Task);
}
private static TransferConfirmationMessage GetTransferConfirmationMessage()
{
//Should be a contract
var vaspKey = EthECKey.GenerateKey();
var message = new Message(
Guid.NewGuid().ToByteArray().ToHex(prefix: false),
Guid.NewGuid().ToByteArray().ToHex(prefix: false),
"1");
var postalAddress = new PostalAddress(
"TestingStreet",
61,
"Test Address Line",
"410000",
"TownN",
Country.List["DE"]
);
var placeOfBirth = new PlaceOfBirth(DateTime.UtcNow, "TownN", Country.List["DE"]);
var vaspInformation = new VaspInformation(
"Test test",
vaspKey.GetPublicAddress(),
vaspKey.GetPubKey().ToHex(prefix: false),
postalAddress,
placeOfBirth,
new NaturalPersonId[]
{
new NaturalPersonId("SomeId2", NaturalIdentificationType.AlienRegistrationNumber,
Country.List["DE"]),
},
new JuridicalPersonId[]
{
new JuridicalPersonId("SomeId1", JuridicalIdentificationType.BankPartyIdentification,
Country.List["DE"]),
},
"DEUTDEFF");
var originator = new Originator("Originator1", "VaaN", postalAddress, placeOfBirth,
new NaturalPersonId[]
{
new NaturalPersonId("SomeId2", NaturalIdentificationType.AlienRegistrationNumber,
Country.List["DE"]),
},
new JuridicalPersonId[]
{
new JuridicalPersonId("SomeId1", JuridicalIdentificationType.BankPartyIdentification,
Country.List["DE"]),
},
"DEUTDEFF");
var beneficiary = new Beneficiary("Ben1", "VaaN");
var transferReply = new TransferReply(VirtualAssetType.ETH, TransferType.BlockchainTransfer, "10000000", "0x0000001");
var transaction = new Transaction("txId", DateTime.UtcNow, "0x0000002");
var request = new TransferConfirmationMessage(message, originator, beneficiary, transferReply, transaction, vaspInformation)
{
Comment = "This is test message",
};
return(request);
}
//[Fact]
public async Task ConnectionBetweenTwoClientsSuccessful()
{
var vaspClient1 = VaspClient.Create(_settings1);
var vaspClient2 = VaspClient.Create(_settings2);
var sessionRequestSemaphore = new SemaphoreSlim(0, 1);
var sessionReplySemaphore = new SemaphoreSlim(0, 1);
var transferRequestSemaphore = new SemaphoreSlim(0, 1);
var transferReplySemaphore = new SemaphoreSlim(0, 1);
var transferDispatchSemaphore = new SemaphoreSlim(0, 1);
var transferConfirmSemaphore = new SemaphoreSlim(0, 1);
var terminationSemaphore = new SemaphoreSlim(0, 1);
var sessionRequestReceived = false;
var sessionReplyReceived = false;
var transferRequestReceived = false;
var transferReplyReceived = false;
var transferDispatchReceived = false;
var transferConfirmReceived = false;
var terminationReceived = false;
string session1 = null;
vaspClient1.OriginatorSessionApprovedEvent += async approved =>
{
sessionReplyReceived = true;
sessionReplySemaphore.Release();
var transferRequest = new TransferRequest
{
Transfer = new Transfer
{
Amount = 10
}
};
await vaspClient1.SendApplicationMessageAsync(session1, MessageType.TransferRequest, JObject.FromObject(transferRequest));
};
vaspClient1.ApplicationMessageReceivedEvent += async received =>
{
if (received.Type == MessageType.TransferReply)
{
transferReplyReceived = true;
transferReplySemaphore.Release();
var transferReply = received.Body.ToObject <TransferReply>();
Assert.Equal(TransferReplyMessageCode.TransferAccepted, transferReply.Code);
var transferDispatch = new TransferDispatch
{
Transfer = new Transaction
{
TransactionHash = "txhash"
}
};
await vaspClient1.SendApplicationMessageAsync(session1, MessageType.TransferDispatch, JObject.FromObject(transferDispatch));
}
if (received.Type == MessageType.TransferConfirmation)
{
transferConfirmReceived = true;
transferConfirmSemaphore.Release();
var transferConfirm = received.Body.ToObject <TransferConfirm>();
Assert.Equal(TransactionConfirmCode.TransferConfirmed, transferConfirm.Code);
await vaspClient1.SessionTerminateAsync(session1);
}
};
string session2 = null;
vaspClient2.BeneficiarySessionCreatedEvent += async created =>
{
sessionRequestReceived = true;
sessionRequestSemaphore.Release();
session2 = created.SessionId;
await vaspClient2.SessionReplyAsync(session2, true);
};
vaspClient2.SessionTerminatedEvent += terminated =>
{
terminationReceived = true;
terminationSemaphore.Release();
return(Task.CompletedTask);
};
vaspClient2.ApplicationMessageReceivedEvent += async received =>
{
if (received.Type == MessageType.TransferRequest)
{
transferRequestReceived = true;
transferRequestSemaphore.Release();
var transferRequest = received.Body.ToObject <TransferRequest>();
Assert.Equal(10, transferRequest.Transfer.Amount);
var transferReply = new TransferReply
{
Code = TransferReplyMessageCode.TransferAccepted
};
await vaspClient2.SendApplicationMessageAsync(session2, MessageType.TransferReply, JObject.FromObject(transferReply));
}
if (received.Type == MessageType.TransferDispatch)
{
transferDispatchReceived = true;
transferDispatchSemaphore.Release();
var transferDispatch = received.Body.ToObject <TransferDispatch>();
Assert.Equal("txhash", transferDispatch.Transfer.TransactionHash);
var transferConfirm = new TransferConfirm
{
Code = TransactionConfirmCode.TransferConfirmed
};
await vaspClient2.SendApplicationMessageAsync(session2, MessageType.TransferConfirmation,
JObject.FromObject(transferConfirm));
}
};
session1 = await vaspClient1.CreateSessionAsync(_settings2.VaspId);
await Task.WhenAny(
Task.Delay(TimeSpan.FromMinutes(2)),
Task.WhenAll(
sessionRequestSemaphore.WaitAsync(),
sessionReplySemaphore.WaitAsync(),
transferRequestSemaphore.WaitAsync(),
transferReplySemaphore.WaitAsync(),
transferDispatchSemaphore.WaitAsync(),
transferConfirmSemaphore.WaitAsync(),
terminationSemaphore.WaitAsync()));
Assert.True(sessionRequestReceived, "Session request message was not delivered");
Assert.True(sessionReplyReceived, "Session reply message was not delivered");
Assert.True(transferRequestReceived, "Transfer request message was not delivered");
Assert.True(transferReplyReceived, "Transfer reply message was not delivered");
Assert.True(transferDispatchReceived, "Transfer dispatch message was not delivered");
Assert.True(transferConfirmReceived, "Transfer confirm message was not delivered");
Assert.True(terminationReceived, "Termination message was not delivered");
}
