public VaspSessionsManager(
VaspClient vaspClient,
IVaspCallbacks vaspCallbacks)
{
_vaspClient = vaspClient;
_originatorVaspCallbacks = new OriginatorVaspCallbacks(
async(message, originatorSession) =>
{
await vaspCallbacks.SessionReplyMessageReceivedAsync(originatorSession.SessionId, message);
},
async(message, originatorSession) =>
{
await vaspCallbacks.TransferReplyMessageReceivedAsync(originatorSession.SessionId, message);
if (message.Message.MessageCode == "5") //todo: handle properly.
{
await originatorSession.TerminateAsync(TerminationMessage.TerminationMessageCode.SessionClosedTransferOccured);
originatorSession.Wait();
}
},
async(message, originatorSession) =>
{
await vaspCallbacks.TransferConfirmationMessageReceivedAsync(originatorSession.SessionId, message);
await originatorSession.TerminateAsync(TerminationMessage.TerminationMessageCode.SessionClosedTransferOccured);
originatorSession.Wait();
});
IVaspMessageHandler vaspMessageHandler = new VaspMessageHandlerCallbacks(
vaspInfo => Task.FromResult(true),
async(request, currentSession) =>
{
_beneficiarySessions[currentSession.SessionId] = currentSession as BeneficiarySession;
await vaspCallbacks.TransferRequestMessageReceivedAsync(currentSession.SessionId, request);
return(null);
},
async(dispatch, currentSession) =>
{
await vaspCallbacks.TransferDispatchMessageReceivedAsync(currentSession.SessionId, dispatch);
return(null);
});
_vaspClient.RunListener(vaspMessageHandler);
}
/// <summary>
/// Create a session and send a request session message to beneficiary Vasp.
/// </summary>
/// <param name="originator">Information about a client who sends a transfer</param>
/// <param name="beneficiaryVaan">Information about a receiver of the transfer</param>
/// <returns>OriginatorSession through which transfer request and transfer dispatch should be requested.</returns>
public async Task <OriginatorSession> CreateSessionAsync(
Originator originator,
VirtualAssetsAccountNumber beneficiaryVaan,
IOriginatorVaspCallbacks _originatorVaspCallbacks)
{
string counterPartyVaspContractAddress = await _ensProvider.GetContractAddressByVaspCodeAsync(beneficiaryVaan.VaspCode);
var contractInfo = await _ethereumRpc.GetVaspContractInfoAync(counterPartyVaspContractAddress);
var sessionKey = ECDH_Key.GenerateKey();
var sharedKey = sessionKey.GenerateSharedSecretHex(contractInfo.HandshakeKey);
var session = new OriginatorSession(
originator,
this._vaspContractInfo,
this.VaspInfo,
beneficiaryVaan,
contractInfo.SigningKey,
contractInfo.HandshakeKey,
sharedKey,
sessionKey.PublicKey,
this._signatureKey,
_whisperRpc,
_transportClient,
_signService,
_originatorVaspCallbacks);
if (_originatorSessionsDict.TryAdd(session.SessionId, session))
{
this.NotifySessionCreated(session);
session.OnSessionTermination += this.ProcessSessionTermination;
await session.StartAsync();
return(session);
}
await session.TerminateAsync(TerminationMessage.TerminationMessageCode
.SessionClosedTransferCancelledByOriginator);
//TODO: process it as exception or retry
return(null);
}
public OriginatorSession(
Originator originator,
VaspContractInfo originatorVaspContractInfo,
VaspInformation originatorVasp,
VirtualAssetsAccountNumber beneficiaryVaan,
string beneficiaryPubSigningKey,
string beneficiaryPubHandshakeKey,
string sharedEncryptionKey,
string pubEncryptionKey,
string privateSigningKey,
IWhisperRpc whisperRpc,
ITransportClient transportClient,
ISignService signService,
IOriginatorVaspCallbacks originatorVaspCallbacks)
//IEnsProvider ensProvider)
: base(
originatorVaspContractInfo,
originatorVasp,
beneficiaryPubSigningKey,
sharedEncryptionKey,
privateSigningKey,
whisperRpc,
transportClient,
signService)
{
this._beneficiaryVaan = beneficiaryVaan;
this.SessionId = Guid.NewGuid().ToString();
this._beneficiaryPubHandshakeKey = beneficiaryPubHandshakeKey;
this._pubEncryptionKey = pubEncryptionKey;
this._originatorVaspCallbacks = originatorVaspCallbacks;
//this._ensProvider = ensProvider;
this._originator = originator;
_messageHandlerResolverBuilder.AddHandler(typeof(SessionReplyMessage),
new SessionReplyMessageHandler((sessionReplyMessage, token) =>
{
this.CounterPartyTopic = sessionReplyMessage.HandShake.TopicB;
return(_originatorVaspCallbacks.SessionReplyMessageHandlerAsync(sessionReplyMessage, this));
}));
_messageHandlerResolverBuilder.AddHandler(typeof(TransferReplyMessage),
new TransferReplyMessageHandler((transferReplyMessage, token) =>
{
return(_originatorVaspCallbacks.TransferReplyMessageHandlerAsync(transferReplyMessage, this));
}));
_messageHandlerResolverBuilder.AddHandler(typeof(TransferConfirmationMessage),
new TransferConfirmationMessageHandler((transferDispatchMessage, token) =>
{
return(_originatorVaspCallbacks.TransferConfirmationMessageHandlerAsync(transferDispatchMessage,
this));
}));
_messageHandlerResolverBuilder.AddHandler(typeof(TerminationMessage),
new TerminationMessageHandler(async(message, token) =>
{
_hasReceivedTerminationMessage = true;
await TerminateAsync(message.GetMessageCode());
}));
}
