Exemplo n.º 1
0
        /// <inheritdoc />
        public virtual async Task <string> AcceptInvitationAsync(Wallet wallet, ConnectionInvitationMessage invitation)
        {
            Logger.LogInformation(LoggingEvents.AcceptInvitation, "Key {0}, Endpoint {1}",
                                  invitation.ConnectionKey, invitation.Endpoint.Uri);

            var my = await Did.CreateAndStoreMyDidAsync(wallet, "{}");

            var connection = new ConnectionRecord
            {
                Endpoint     = invitation.Endpoint,
                MyDid        = my.Did,
                MyVk         = my.VerKey,
                ConnectionId = Guid.NewGuid().ToString().ToLowerInvariant()
            };

            connection.Tags.Add(TagConstants.MyDid, my.Did);

            if (!string.IsNullOrEmpty(invitation.Name) || !string.IsNullOrEmpty(invitation.ImageUrl))
            {
                connection.Alias = new ConnectionAlias
                {
                    Name     = invitation.Name,
                    ImageUrl = invitation.ImageUrl
                };

                if (string.IsNullOrEmpty(invitation.Name))
                {
                    connection.Tags.Add(TagConstants.Alias, invitation.Name);
                }
            }

            await connection.TriggerAsync(ConnectionTrigger.InvitationAccept);

            await RecordService.AddAsync(wallet, connection);

            var provisioning = await ProvisioningService.GetProvisioningAsync(wallet);

            var connectionDetails = new ConnectionDetails
            {
                Did      = my.Did,
                Verkey   = my.VerKey,
                Endpoint = provisioning.Endpoint
            };

            var request = await MessageSerializer.PackSealedAsync <ConnectionRequestMessage>(connectionDetails, wallet,
                                                                                             my.VerKey, invitation.ConnectionKey);

            request.Key  = invitation.ConnectionKey;
            request.Type = MessageUtils.FormatKeyMessageType(invitation.ConnectionKey, MessageTypes.ConnectionRequest);

            var forwardMessage = new ForwardToKeyEnvelopeMessage
            {
                Type    = MessageUtils.FormatKeyMessageType(invitation.ConnectionKey, MessageTypes.ForwardToKey),
                Content = request.ToJson()
            };

            await RouterService.ForwardAsync(forwardMessage, invitation.Endpoint);

            return(connection.GetId());
        }
        public async Task AnonPrepareMessageRoutingAsync()
        {
            var message = new ConnectionInvitationMessage {
                RecipientKeys = new[] { "123" }
            };

            var recipient = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var routingRecipient = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var encrypted = await _messagingService.PrepareAsync(_wallet, message, recipient.VerKey, new [] { routingRecipient.VerKey });

            var unpackRes = await CryptoUtils.UnpackAsync(_wallet, encrypted);

            var unpackMsg = JsonConvert.DeserializeObject <ForwardMessage>(unpackRes.Message);

            Assert.NotNull(unpackMsg);
            Assert.True(string.IsNullOrEmpty(unpackRes.SenderVerkey));
            Assert.True(unpackRes.RecipientVerkey == routingRecipient.VerKey);
            Assert.Equal(recipient.VerKey, unpackMsg.To);

            var unpackRes1 = await CryptoUtils.UnpackAsync(_wallet, unpackMsg.Message.GetUTF8Bytes());

            var unpackMsg1 = JsonConvert.DeserializeObject <ConnectionInvitationMessage>(unpackRes1.Message);

            Assert.NotNull(unpackMsg1);
            Assert.True(string.IsNullOrEmpty(unpackRes1.SenderVerkey));
            Assert.True(unpackRes1.RecipientVerkey == recipient.VerKey);
            Assert.Equal("123", unpackMsg1.RecipientKeys[0]);
        }
Exemplo n.º 3
0
        private async Task CreateConnection(IAgentContext context, ConnectionInvitationMessage invite)
        {
            var logger = App.Container.Resolve <ILogger <AcceptInviteViewModel> >();
            var fmt    = new JsonSerializerSettings {
                Formatting = Formatting.Indented
            };

            logger.LogTrace($"context = {context.ToJson(fmt)}");
            logger.LogTrace($"_invite = {_invite.ToJson(fmt)}");

            var provisioningRecord = await _provisioningService.GetProvisioningAsync(context.Wallet);

            logger.LogTrace($"provisioningRecord = {provisioningRecord.ToJson(new JsonSerializerSettings{Formatting = Formatting.Indented})}");

            var isEndpointUriAbsent = provisioningRecord.Endpoint.Uri == null;

            var(msg, rec) = await _connectionService.CreateRequestAsync(context, _invite);

            msg.Label = DeviceInfo.Name + " osma agent";
            logger.LogTrace($"Connection Message (msg) being Sent = {msg.ToJson(fmt)}");
            logger.LogTrace($"ConnectionRecord (rec) being saved = {rec.ToJson(fmt)}");

            var rsp = await _messageService.SendAsync(context.Wallet, msg, rec, _invite.RecipientKeys.First(), isEndpointUriAbsent);

            logger.LogTrace($"rsp = {rsp.ToJson(fmt)}");
            if (isEndpointUriAbsent)
            {
                var response = rsp.GetMessage <ConnectionResponseMessage>();
                logger.LogTrace($"response = {response.ToJson(fmt)}");
                await _connectionService.ProcessResponseAsync(context, response, rec);
            }
        }
        public async Task AuthPrepareMessageNoRoutingAsync()
        {
            var message = new ConnectionInvitationMessage {
                RecipientKeys = new[] { "123" }
            };

            var recipient = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var sender = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var agentContext = new AgentContext()
            {
                Wallet = _wallet
            };
            var encrypted = await CryptoUtils.PrepareAsync(agentContext, message, recipient.VerKey, new string[0], sender.VerKey);

            var unpackRes = await CryptoUtils.UnpackAsync(_wallet, encrypted);

            var unpackMsg = JsonConvert.DeserializeObject <ConnectionInvitationMessage>(unpackRes.Message);

            Assert.NotNull(unpackMsg);
            Assert.True(unpackRes.SenderVerkey == sender.VerKey);
            Assert.True(unpackRes.RecipientVerkey == recipient.VerKey);
            Assert.Equal("123", unpackMsg.RecipientKeys[0]);
        }
        public async Task ScanInvite()
        {
            ConnectionInvitationMessage invitation = null;
            bool isEmulated = false;  //ONLY FOR TESTING

            if (!isEmulated)
            {
                var expectedFormat = ZXing.BarcodeFormat.QR_CODE;
                var opts           = new ZXing.Mobile.MobileBarcodeScanningOptions
                {
                    PossibleFormats = new List <ZXing.BarcodeFormat> {
                        expectedFormat
                    }
                };

                var scanner = new ZXing.Mobile.MobileBarcodeScanner();

                var result = await scanner.Scan(opts);

                if (result == null)
                {
                    return;
                }

                try
                {
                    invitation = await MessageDecoder.ParseMessageAsync(result.Text) as ConnectionInvitationMessage
                                 ?? throw new Exception("Unknown message type");
                }
                catch (Exception)
                {
                    DialogService.Alert("Invalid invitation!");
                    return;
                }
            }
            else
            {
                invitation = new ConnectionInvitationMessage()
                {
                    Id            = "453b0d8e-50d0-4a18-bf44-7d7369a0c31f",
                    Label         = "Verifier",
                    Type          = "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0/invitation",
                    ImageUrl      = "",
                    RecipientKeys = new List <string>()
                    {
                        "DPqj1fdVajDYdVgeT36NUSoVghjkapaHpVUdwbL1z6ye"
                    },
                    RoutingKeys = new List <string>()
                    {
                        "9RUPb4jPtR2S1P9yVy85ugwiywqqzDfxRrDZnKCTQCtH"
                    },
                    ServiceEndpoint = "http://mylocalhost:5002"
                };
            }
            Device.BeginInvokeOnMainThread(async() =>
            {
                await NavigationService.NavigateToAsync <AcceptInviteViewModel>(invitation, NavigationType.Modal);
            });
        }
Exemplo n.º 6
0
        public async Task PrepareMessageForMultipleRoutingHops()
        {
            var message = new ConnectionInvitationMessage {
                RecipientKeys = new[] { "123" }
            };

            var json        = message.ToJson();
            var messageBack = json.ToObject <ConnectionInvitationMessage>();

            var keys = new
            {
                Sender     = await Did.CreateAndStoreMyDidAsync(_wallet, "{}"),
                Recipient  = await Did.CreateAndStoreMyDidAsync(_wallet, "{}"),
                RoutingOne = await Did.CreateAndStoreMyDidAsync(_wallet, "{}"),
                RoutingTwo = await Did.CreateAndStoreMyDidAsync(_wallet, "{}")
            };

            // Prepare the message for transport by packing the agent message with multiple forward messages
            var transportMessage = await CryptoUtils.PrepareAsync(
                wallet : _wallet,
                message : message,
                recipientKey : keys.Recipient.VerKey,
                routingKeys : new[] { keys.RoutingOne.VerKey, keys.RoutingTwo.VerKey },
                senderKey : keys.Sender.VerKey);

            // Unpack and assert outter forward message
            var outterResult = await CryptoUtils.UnpackAsync(_wallet, transportMessage);

            var outterMessage = outterResult.Message.ToObject <ForwardMessage>();

            Assert.Equal(keys.RoutingTwo.VerKey, outterResult.RecipientVerkey);
            Assert.Null(outterResult.SenderVerkey);
            Assert.NotNull(outterMessage);
            Assert.Equal(outterMessage.To, keys.RoutingOne.VerKey);

            // Unpack and test inner forward message
            var innerResult = await CryptoUtils.UnpackAsync(_wallet, outterMessage.Message.ToJson().GetUTF8Bytes());

            var innerMessage = innerResult.Message.ToObject <ForwardMessage>();

            Assert.Equal(keys.RoutingOne.VerKey, innerResult.RecipientVerkey);
            Assert.Null(innerResult.SenderVerkey);
            Assert.NotNull(innerMessage);
            Assert.Equal(innerMessage.To, keys.Recipient.VerKey);

            // Unpack and test inner content message
            var contentResult = await CryptoUtils.UnpackAsync(_wallet, innerMessage.Message.ToJson().GetUTF8Bytes());

            var contentMessage = contentResult.Message.ToObject <ConnectionInvitationMessage>();

            Assert.Equal(keys.Recipient.VerKey, contentResult.RecipientVerkey);
            Assert.Equal(keys.Sender.VerKey, contentResult.SenderVerkey);
            Assert.NotNull(contentMessage);
            Assert.NotEmpty(contentMessage.RecipientKeys);
            Assert.Single(contentMessage.RecipientKeys);
            Assert.Equal("123", contentMessage.RecipientKeys.First());
        }
Exemplo n.º 7
0
        public void CanEncodeMessageToUrl()
        {
            var message    = new ConnectionInvitationMessage();
            var exampleUrl = "http://example.com";

            var encodedMessage = MessageUtils.EncodeMessageToUrlFormat(exampleUrl, message);

            Uri.IsWellFormedUriString(encodedMessage, UriKind.Absolute);
        }
Exemplo n.º 8
0
 public override Task InitializeAsync(object navigationData)
 {
     if (navigationData is ConnectionInvitationMessage invite)
     {
         InviteTitle    = $"{invite.Label}";
         InviterUrl     = invite.ImageUrl;
         InviteContents = AppResources.ConnectionInviteMessage;
         _invite        = invite;
     }
     return(base.InitializeAsync(navigationData));
 }
Exemplo n.º 9
0
 public override Task InitializeAsync(object navigationData)
 {
     if (navigationData is ConnectionInvitationMessage invite)
     {
         InviteTitle    = $"Trust {invite.Label}?";
         InviterUrl     = invite.ImageUrl;
         InviteContents = $"{invite.Label} would like to establish a pairwise DID connection with you. This will allow secure communication between you and {invite.Label}.";
         _invite        = invite;
     }
     return(base.InitializeAsync(navigationData));
 }
Exemplo n.º 10
0
 public CreateInvitationResponse
 (
     Guid aRequestId,
     ConnectionInvitationMessage aConnectionInvitationMessage,
     ConnectionRecord aConnectionRecord,
     string aInvitationUrl
 ) : base(aRequestId)
 {
     ConnectionInvitationMessage = aConnectionInvitationMessage;
     ConnectionRecord            = aConnectionRecord;
     InvitationUrl = aInvitationUrl;
 }
Exemplo n.º 11
0
        public void CanConvertUnsecuredMessage()
        {
            var expected = new ConnectionInvitationMessage {
                ConnectionKey = "123"
            };
            var json = JsonConvert.SerializeObject(expected);

            var actual = JsonConvert.DeserializeObject <IUnsecuredMessage>(json);

            Assert.IsType <ConnectionInvitationMessage>(actual);
            Assert.Equal("123", ((ConnectionInvitationMessage)actual).ConnectionKey);
        }
 public override Task InitializeAsync(object navigationData)
 {
     if (navigationData is ConnectionInvitationMessage invitation)
     {
         InvitationTitle    = $"Connect to {invitation.Label}?";
         InvitationImageUrl = invitation.ImageUrl;
         InvitationContents = $"{invitation.Label} has invited you to connect?";
         InvitationLabel    = invitation.Label;
         _invitation        = invitation;
     }
     return(base.InitializeAsync(navigationData));
 }
Exemplo n.º 13
0
        internal static void ValidateReceiveInvitationResponse
        (
            ReceiveInvitationRequest aReceiveInvitationRequest,
            ReceiveInvitationResponse aReceiveInvitationRespone
        )
        {
            aReceiveInvitationRespone.CorrelationId.Should().Be(aReceiveInvitationRequest.CorrelationId);

            ConnectionInvitationMessage connectionInvitationMessage = aReceiveInvitationRespone.ConnectionInvitationMessage;

            connectionInvitationMessage.Should().NotBeNull();
            // check Other properties here
        }
        public async Task PackAuth()
        {
            var message = new ConnectionInvitationMessage {
                RecipientKeys = new[] { "123" }
            }.ToByteArray();

            var my = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var anotherMy = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var packed = await CryptoUtils.PackAsync(_wallet, anotherMy.VerKey, message, my.VerKey);

            Assert.NotNull(packed);
        }
Exemplo n.º 15
0
        /// <inheritdoc />
        public (string sessionId, ConnectionInvitationMessage connectionInvitationMessage, bool awaitableConnection) ReadTransactionUrl(string invitationUrl)
        {
            string sessionId = null;
            ConnectionInvitationMessage invitationMessage = null;
            bool awaitableConnection = false;

            Uri uri = null;

            try
            {
                uri = new Uri(invitationUrl);
            }
            catch (Exception)
            {
                return(null, null, false);
            }
            try
            {
                if (uri.Query.StartsWith("?t_o="))
                {
                    var arguments = uri.Query
                                    .Substring(1) // Remove '?'
                                    .Split('&')
                                    .Select(q => q.Split('='))
                                    .ToDictionary(q => q.FirstOrDefault(), q => q.Skip(1).FirstOrDefault());

                    sessionId = arguments["t_o"];

                    invitationMessage = arguments["c_i"].FromBase64().ToObject <ConnectionInvitationMessage>();

                    try
                    {
                        awaitableConnection = bool.Parse(arguments["wait"]);
                    }
                    catch (Exception)
                    {
                        awaitableConnection = false;
                    }

                    return(sessionId, invitationMessage, awaitableConnection);
                }
            }
            catch (Exception e)
            {
                Debug.WriteLine(e);
            }

            return(sessionId, invitationMessage, awaitableConnection);
        }
Exemplo n.º 16
0
        public async Task <ReceiveInvitationResponse> Handle
        (
            ReceiveInvitationRequest aReceiveInvitationRequest,
            CancellationToken aCancellationToken
        )
        {
            ConnectionInvitationMessage connectionInvitationMessage =
                MessageUtils
                .DecodeMessageFromUrlFormat <ConnectionInvitationMessage>(aReceiveInvitationRequest.InvitationDetails);

            var response =
                new ReceiveInvitationResponse(aReceiveInvitationRequest.CorrelationId, connectionInvitationMessage);

            return(await Task.Run(() => response));
        }
Exemplo n.º 17
0
        private async Task CreateConnection(IAgentContext context, ConnectionInvitationMessage invite)
        {
            var provisioningRecord = await _provisioningService.GetProvisioningAsync(context.Wallet);

            var isEndpointUriAbsent = provisioningRecord.Endpoint.Uri == null;

            var(msg, rec) = await _connectionService.CreateRequestAsync(context, _invitation);

            var rsp = await _messageService.SendReceiveAsync <ConnectionResponseMessage>(context.Wallet, msg, rec);

            if (isEndpointUriAbsent)
            {
                await _connectionService.ProcessResponseAsync(context, rsp, rec);
            }
        }
Exemplo n.º 18
0
        public async Task PackAnon()
        {
            var message = new ConnectionInvitationMessage()
            {
                ConnectionKey = "123"
            }.ToByteArray();

            var my = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var anotherMy = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var packed = await CryptoUtils.PackAsync(_wallet, anotherMy.VerKey, null, message);

            Assert.NotNull(packed);
        }
        public void ThreadFromThrowsExceptionOnAlreadyThreadedMessage()
        {
            var message = new ConnectionRequestMessage();

            var threadId = Guid.NewGuid().ToString();

            message.AddDecorator(new ThreadDecorator()
            {
                ThreadId = threadId
            }, "thread");

            var inboundMessage = new ConnectionInvitationMessage();

            var ex = Assert.Throws <AriesFrameworkException>(() => message.ThreadFrom(inboundMessage));

            Assert.True(ex.ErrorCode == ErrorCode.InvalidMessage);
        }
        public async Task UnpackToCustomType()
        {
            var message = new ConnectionInvitationMessage {
                RecipientKeys = new [] { "123" }
            };

            var my = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var anotherMy = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var packed = await CryptoUtils.PackAsync(_wallet, anotherMy.VerKey, message, null);

            var unpack = await CryptoUtils.UnpackAsync <ConnectionInvitationMessage>(_wallet, packed);

            Assert.NotNull(unpack);
            Assert.Equal("123", unpack.RecipientKeys[0]);
        }
Exemplo n.º 21
0
        /// <inheritdoc />
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
                                        JsonSerializer serializer)
        {
            IUnsecuredMessage message;

            var item = JObject.Load(reader);

            switch (item["@type"].ToObject <string>())
            {
            case MessageTypes.ConnectionInvitation:
                message = new ConnectionInvitationMessage();
                break;

            default: throw new TypeLoadException("Unsupported serialization type.");
            }

            serializer.Populate(item.CreateReader(), message);
            return(message);
        }
        public async Task PackAndUnpackAnon()
        {
            var message = new ConnectionInvitationMessage {
                RecipientKeys = new[] { "123" }
            };

            var my = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var anotherMy = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var packed = await CryptoUtils.PackAsync(_wallet, anotherMy.VerKey, message, null);

            var unpack = await CryptoUtils.UnpackAsync(_wallet, packed);

            Assert.NotNull(unpack);
            Assert.Null(unpack.SenderVerkey);
            Assert.NotNull(unpack.RecipientVerkey);
            Assert.Equal(unpack.RecipientVerkey, anotherMy.VerKey);
        }
        public async Task <AcceptInvitationResponse> Handle
        (
            AcceptInvitationRequest aAcceptInvitationRequest,
            CancellationToken aCancellationToken
        )
        {
            IAgentContext agentContext = await AgentProvider.GetContextAsync();

            ConnectionInvitationMessage connectionInvitationMessage =
                MessageUtils
                .DecodeMessageFromUrlFormat <ConnectionInvitationMessage>(aAcceptInvitationRequest.InvitationDetails);

            (ConnectionRequestMessage connectionRequestMessage, ConnectionRecord connectionRecord)
                = await ConnectionService.CreateRequestAsync(agentContext, connectionInvitationMessage);

            await MessageService.SendAsync(agentContext, connectionRequestMessage, connectionRecord);

            var response = new AcceptInvitationResponse(aAcceptInvitationRequest.CorrelationId);

            return(response);
        }
        public async Task PackAndUnpackAuth()
        {
            var message = new ConnectionInvitationMessage {
                RecipientKeys = new[] { "123" }
            }.ToByteArray();

            var my = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var anotherMy = await Did.CreateAndStoreMyDidAsync(_wallet, "{}");

            var packed = await CryptoUtils.PackAsync(_wallet, anotherMy.VerKey, message, my.VerKey);

            var unpack = await CryptoUtils.UnpackAsync(_wallet, packed);

            var jObject = JObject.Parse(unpack.Message);

            Assert.NotNull(unpack);
            Assert.NotNull(unpack.SenderVerkey);
            Assert.NotNull(unpack.RecipientVerkey);
            Assert.Equal(unpack.RecipientVerkey, anotherMy.VerKey);
            Assert.Equal(unpack.SenderVerkey, my.VerKey);
            Assert.Equal(MessageTypes.ConnectionInvitation, jObject["@type"].ToObject <string>());
        }
Exemplo n.º 25
0
        private async Task <bool> CreateConnection(IAgentContext context, ConnectionInvitationMessage invite)
        {
            var provisioningRecord = await _provisioningService.GetProvisioningAsync(context.Wallet);

            if (provisioningRecord.Endpoint.Uri != null)
            {
                try
                {
                    var(msg, rec) = await _connectionService.CreateRequestAsync(context, _invite);

                    await _messageService.SendAsync(context.Wallet, msg, rec, _invite.RecipientKeys.First());

                    return(true);
                }
                catch (Exception) //TODO more granular error protection
                {
                    return(false);
                }
            }
            else
            {
                try
                {
                    var(msg, rec) = await _connectionService.CreateRequestAsync(context, _invite);

                    var rsp = await _messageService.SendAsync(context.Wallet, msg, rec, _invite.RecipientKeys.First(), true);

                    await _connectionService.ProcessResponseAsync(context, rsp.GetMessage <ConnectionResponseMessage>(), rec);

                    return(true);
                }
                catch (Exception) //TODO more granular error protection
                {
                    return(false);
                }
            }
        }
Exemplo n.º 26
0
        private async Task CreateConnection(IAgentContext context, ConnectionInvitationMessage invite)
        {
            var provisioningRecord = await _provisioningService.GetProvisioningAsync(context.Wallet);

            var isEndpointUriAbsent = provisioningRecord.Endpoint.Uri == null;

            var(msg, connection) = await _connectionService.CreateRequestAsync(context, invite);

            msg.Label = msg.Label == null ? "OsmaAgent" : msg.Label;

            var recipientKey = invite.RecipientKeys.First()
                               ?? connection.TheirVk
                               ?? throw new AriesFrameworkException(
                                         ErrorCode.A2AMessageTransmissionError, "Cannot find encryption key");

            var routingKeys = connection.Endpoint?.Verkey != null ? new[] { connection.Endpoint.Verkey } : new string[0];

            if (connection.Endpoint?.Uri == null)
            {
                throw new AriesFrameworkException(ErrorCode.A2AMessageTransmissionError, "Cannot send to connection that does not have endpoint information specified");
            }


            if (isEndpointUriAbsent)
            {
                var rsp = await _messageService.SendReceiveAsync(context.Wallet, msg, recipientKey, connection.Endpoint.Uri, routingKeys, connection.MyVk);

                var unpackedRsp = (UnpackedMessageContext)rsp;

                await _connectionService.ProcessResponseAsync(context, unpackedRsp.GetMessage <ConnectionResponseMessage>(), connection);
            }
            else
            {
                await _messageService.SendAsync(context.Wallet, msg, recipientKey, connection.Endpoint.Uri, routingKeys, connection.MyVk);
            }
        }
Exemplo n.º 27
0
 /// <summary>
 /// Encodes the invitation to a base64 string which can be presented to the user as QR code or a deep link Url
 /// </summary>
 /// <returns>The invitation.</returns>
 /// <param name="invitation">Invitation.</param>
 public string EncodeInvitation(ConnectionInvitationMessage invitation)
 {
     return(Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(invitation))));
 }
Exemplo n.º 28
0
 public Task <(ConnectionRequestMessage, ConnectionRecord)> CreateRequestAsync(IAgentContext agentContext, ConnectionInvitationMessage offer)
 {
     throw new System.NotImplementedException();
 }
Exemplo n.º 29
0
 public async Task <ConnectionRecord> ProcessInvitationAsync(IAgentContext agentContext, ConnectionInvitationMessage offer)
 {
     throw new System.NotImplementedException();
 }
Exemplo n.º 30
0
 public ReceiveInvitationResponse(Guid aCorrelationId, ConnectionInvitationMessage aConnectionInvitationMessage)
     : base(aCorrelationId)
 {
     ConnectionInvitationMessage = aConnectionInvitationMessage;
 }