public async Task <IKeyInfo> GenerateAsync(GenerateKeyRequest request)
{
Ensure.NotNull(request, nameof(request));
var aes = Aes.Create();
aes.KeySize = 256;
aes.GenerateKey();
var masterKey = await protectorProvider.GetAsync(masterKeyId.ToString(), request.Aad);
var ciphertext = await masterKey.EncryptAsync(aes.Key);
Uid id = Guid.NewGuid();
var key = new KeyInfo(
id: id,
ownerId: request.OwnerId,
name: request.Name ?? id.ToString(),
kekId: masterKeyId,
format: KeyDataFormat.AwsKmsEncryptedData,
data: ciphertext,
activated: DateTime.UtcNow.AddMinutes(-5),
type: request.Type,
aad: ToJson(request.Aad)
);
await keyStore.CreateAsync(key);
return(key);
}
public APICredential GenerateAPIKey2FA(String validationToken, String smsCode, String keyDescription)
{
Endpoint p = ConnectionStrings.Endpoints["generateKey2FA"].Clone();
p.Path = p.Path.Replace("{token}", validationToken);
GenerateKeyRequest req = new GenerateKeyRequest();
req.SMSCode = smsCode;
req.KeyDescription = keyDescription;
GenerateAPIKeyResponse response = connection.Send <GenerateAPIKeyResponse>(p, req);
if (response.Response == APIResponse.AUTHENTICATION_FAILED)
{
throw new InvalidCredentialsException(response.Message);
}
else if (response.Response == APIResponse.PIN_RESEND)
{
throw new PINRefreshException(response.Message);
}
else if (response.Response != APIResponse.SUCCESS)
{
throw new ActionFailedException(response.Response.ToString(), response.Message);
}
APICredential key = new APICredential();
key.APIKey = response.APIKey;
key.APISecret = response.APISecret;
return(key);
}
public APICredential GenerateAPIKey(String username, String password, String keyDescription)
{
Endpoint p = ConnectionStrings.Endpoints["generateKey"].Clone();
GenerateKeyRequest keyReq = new GenerateKeyRequest();
keyReq.Email = username;
keyReq.Password = password;
keyReq.KeyDescription = keyDescription;
GenerateAPIKeyResponse response = connection.Send <GenerateAPIKeyResponse>(p, keyReq);
if (response.Response == APIResponse.TWO_FA_REQUIRED)
{
throw new TwoFactorAuthException(response.Message);
}
else if (response.Response == APIResponse.AUTHENTICATION_FAILED)
{
throw new InvalidCredentialsException(response.Message);
}
else if (response.Response != APIResponse.SUCCESS)
{
throw new ActionFailedException(response.Response.ToString(), response.Message);
}
APICredential key = new APICredential();
key.APIKey = response.APIKey;
key.APISecret = response.APISecret;
return(key);
}
public async Task <IActionResult> GenerateKey(GenerateKeyRequest req)
{
_logger.LogInformation("/ExchangeRate/GetFromDates");
string APIKey = string.Empty;
GenerateKeyResponse response = await new AuthBL().GenerateKey(req, _cache, Db);
return(Ok(response));
}
public APICredential FinishPINRegistration(String email, String pincode, String password, String secretQuestion, String answer, String firstName, String lastName, String keyDescription)
{
Endpoint p = ConnectionStrings.Endpoints["finishPINRegistration"].Clone();
FinishRegistrationRequest req = new FinishRegistrationRequest();
req.Email = email;
req.PinCode = pincode;
req.Password = password;
req.Question = secretQuestion;
req.Answer = answer;
req.FirstName = firstName;
req.LastName = lastName;
StandardResponse response = connection.Send <StandardResponse>(p, req);
if (response.Response == APIResponse.PASSWORD_COMPLEXITY)
{
throw new InsufficientPasswordComplexityException(response.Message);
}
else if (response.Response == APIResponse.TOKEN_EXPIRED)
{
throw new TokenExpiredException(response.Message);
}
else if (response.Response == APIResponse.PIN_RESEND)
{
throw new PINRefreshException(response.Message);
}
else if (response.Response == APIResponse.INVALID_TOKEN)
{
throw new InvalidTokenException(response.Message);
}
else if (response.Response != APIResponse.SUCCESS)
{
throw new ActionFailedException(response.Response.ToString(), response.Message);
}
p = ConnectionStrings.Endpoints["generateKey"].Clone();
GenerateKeyRequest keyReq = new GenerateKeyRequest();
keyReq.Email = email;
keyReq.Password = password;
keyReq.KeyDescription = keyDescription;
GenerateAPIKeyResponse response2 = connection.Send <GenerateAPIKeyResponse>(p, keyReq);
if (response2.Response != APIResponse.SUCCESS)
{
throw new ActionFailedException(response2.Response.ToString(), response2.Message);
}
APICredential key = new APICredential();
key.APIKey = response2.APIKey;
key.APISecret = response2.APISecret;
return(key);
}
public async Task <GenerateKeyResponse> GenerateKey(GenerateKeyRequest req, IMemoryCache cache, MySQLDB db)
{
_cache = cache;
Db = db;
string APIKey = string.Empty;
GenerateKeyResponse response = new GenerateKeyResponse();
using (var cryptoProvider = new RNGCryptoServiceProvider())
{
byte[] secretKeyByteArray = new byte[32]; //256 bit
cryptoProvider.GetBytes(secretKeyByteArray);
APIKey = Convert.ToBase64String(secretKeyByteArray);
}
string AppID = string.Empty;
if (!req.forSession)
{
AppID = GetMachineGuid();
}
else
{
AppID = Guid.NewGuid().ToString();
}
response.AppID = AppID;
response.ApiKey = APIKey;
if (req.cache)
{
MemoryCacheEntryOptions cacheExpirationOptions = new MemoryCacheEntryOptions();
cacheExpirationOptions.AbsoluteExpiration = DateTime.Now.AddMinutes(30);
cacheExpirationOptions.Priority = CacheItemPriority.High;
_cache.Set("AppID", AppID, cacheExpirationOptions);
_cache.Set("ApiKey", APIKey, cacheExpirationOptions);
}
await Db.Connection.OpenAsync();
ApiKeys model = new ApiKeys()
{
AppID = AppID,
ApiKey = APIKey
};
model.Db = Db;
var query = new ApiKeysQuery(Db);
var queryResult = await query.FindOneByIDAsync(AppID);
if (queryResult is null)
{
await model.InsertAsync();
}
else
{
await model.UpdateAsync();
}
await Db.Connection.CloseAsync();
return(response);
}
private static List <CountKeyModel> SetKeys(OrderCountCacheRequest request)
{
#region key
var keyModels = new List <CountKeyModel>();
var keyrequest = new GenerateKeyRequest
{
DeviceId = request.DeviceId,
UserId = request.UserId.ToString(),
UserTel = request.UserTel,
ActivityId = request.ActivityId.ToString(),
Pid = request.Pid
};
var countKey = new GenerateFlashSaleKey(keyrequest);
keyModels.Add(new CountKeyModel
{
Key = countKey.PlacekeyUserId,
Sort = 1,
Type = KeyType.PlaceUserIdKey
});
keyModels.Add(new CountKeyModel
{
Key = countKey.PlacekeyDeviceId,
Sort = 2,
Type = KeyType.PlaceDeviceIdKey
});
keyModels.Add(new CountKeyModel
{
Key = countKey.PlacekeyUseTel,
Sort = 3,
Type = KeyType.PlaceUserTelKey
});
keyModels.Add(new CountKeyModel
{
Key = countKey.PersonalkeyUserId,
Sort = 4,
Type = KeyType.PersonUserIdKey
});
keyModels.Add(new CountKeyModel
{
Key = countKey.PersonalkeyDeviceId,
Sort = 5,
Type = KeyType.PersonDeviceIdKey
});
keyModels.Add(new CountKeyModel
{
Key = countKey.PersonalkeyUseTel,
Sort = 6,
Type = KeyType.PersonUserTelKey
});
return(keyModels);
#endregion
}
public static async Task DecrementAllFlashCount(FlashSaleOrderRequest requset,
List <CheckFlashSaleResponseModel> flashSale)
{
foreach (var orderItem in flashSale)
{
await DecrementHashCount(orderItem, orderItem.PID);
var request = new GenerateKeyRequest
{
DeviceId = requset.DeviceId,
UserId = requset.UserId.ToString(),
UserTel = requset.UseTel,
ActivityId = orderItem.ActivityId.ToString(),
Pid = orderItem.PID
};
var countKey = new GenerateFlashSaleKey(request);
if (orderItem.HasQuantityLimit)
{
await DecrementCountCount(orderItem, countKey.PersonalkeyUserId);
await DecrementCountCount(orderItem, countKey.PersonalkeyDeviceId);
await DecrementCountCount(orderItem, countKey.PersonalkeyUseTel);
}
if (orderItem.HasPlaceLimit)
{
await DecrementCountCount(orderItem, countKey.PlacekeyUserId);
await DecrementCountCount(orderItem, countKey.PlacekeyDeviceId);
await DecrementCountCount(orderItem, countKey.PlacekeyUseTel);
}
Logger.Info($"全局会场限购2id是{orderItem.AllPlaceLimitId}");
if (!string.IsNullOrEmpty(orderItem.AllPlaceLimitId))
{
var request1 = new GenerateKeyRequest
{
DeviceId = requset.DeviceId,
UserId = requset.UserId.ToString(),
UserTel = requset.UseTel,
ActivityId = orderItem.AllPlaceLimitId,
Pid = orderItem.PID,
IsAllPlaceLimit = true
};
var countKeyAllLimit = new GenerateFlashSaleKey(request1);
await DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyUserId);
await DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyDeviceId);
await DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyUseTel);
Logger.Info($"全局会场限购3id是{orderItem.AllPlaceLimitId}");
}
}
}
public APICredential GenerateAPIKey2FA(string validationToken, string smsCode, string keyDescription)
{
var p = ConnectionStrings.Endpoints["generateKey2FA"].Clone();
p.Path = p.Path.Replace("{token}", validationToken);
var req = new GenerateKeyRequest
{
SMSCode = smsCode,
KeyDescription = keyDescription
};
var response = _connection.Send <GenerateAPIKeyResponse>(p, req);
switch (response.Response)
{
case APIResponse.AUTHENTICATION_FAILED:
throw new InvalidCredentialsException(response.Message);
case APIResponse.PIN_RESEND:
throw new PINRefreshException(response.Message);
default:
{
if (response.Response != APIResponse.SUCCESS)
{
throw new ActionFailedException(response.Response.ToString(), response.Message);
}
break;
}
}
var key = new APICredential
{
APIKey = response.APIKey,
APISecret = response.APISecret
};
return(key);
}
public APICredential GenerateAPIKey(string username, string password, string keyDescription)
{
var p = ConnectionStrings.Endpoints["generateKey"].Clone();
var keyReq = new GenerateKeyRequest
{
Email = username,
Password = password,
KeyDescription = keyDescription
};
var response = _connection.Send <GenerateAPIKeyResponse>(p, keyReq);
switch (response.Response)
{
case APIResponse.TWO_FA_REQUIRED:
throw new TwoFactorAuthException(response.Message);
case APIResponse.AUTHENTICATION_FAILED:
throw new InvalidCredentialsException(response.Message);
default:
{
if (response.Response != APIResponse.SUCCESS)
{
throw new ActionFailedException(response.Response.ToString(), response.Message);
}
break;
}
}
var key = new APICredential
{
APIKey = response.APIKey,
APISecret = response.APISecret
};
return(key);
}
private static async Task <CheckFlashSaleResponseModel> CheckFlashSaleByPidAsync(OrderItems item, Guid userId, string deviceId, string userTel)
{
var hasMaxLimit = false;
var hasPlaceLimit = false;
string allPlaceLimitId = null;
try
{
if (!item.ActivityId.HasValue)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.NoExist,
}
}
;
var flashSale = await DalFlashSale.FetchFlashSaleProductModel(item);
if (flashSale == null)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.NoExist,
});
}
var model = await FlashSaleCounter.RedisHashRecord(item.PID, item);
if (model.Code == CheckFlashSaleStatus.CreateOrderFailed)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
}
}
;
var record = model.Record;
var remainQuantity = flashSale.TotalQuantity - record;
if (remainQuantity < 0)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.NoEnough,
}
}
;
var request = new GenerateKeyRequest
{
DeviceId = deviceId,
UserId = userId.ToString(),
UserTel = userTel,
ActivityId = item.ActivityId.ToString(),
Pid = item.PID
};
var countKey = new GenerateFlashSaleKey(request);
if (flashSale.MaxQuantity.HasValue)
{
var personLimit1 = await FlashSaleCounter.RedisCounterRecord(countKey.PersonalkeyUserId,
LimitType.PersonalLimit, CounterKeyType.UserIdKey, item, userId, deviceId, userTel, null, -1);
if (personLimit1.Code < 0)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
}
}
;
var personLimit2 = await FlashSaleCounter.RedisCounterRecord(countKey.PersonalkeyDeviceId,
LimitType.PersonalLimit, CounterKeyType.DeviceIdKey, item, userId, deviceId, userTel, null,
personLimit1.DeviceCount);
if (personLimit2.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PersonalkeyUserId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var personLimit3 = await FlashSaleCounter.RedisCounterRecord(countKey.PersonalkeyUseTel,
LimitType.PersonalLimit, CounterKeyType.UserTelKey, item, userId, deviceId, userTel, null,
personLimit1.TelCount);
if (personLimit3.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PersonalkeyUserId);
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PersonalkeyDeviceId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
if (personLimit1.Code < 0 || personLimit2.Code < 0 || personLimit3.Code < 0)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var maxLimit = Math.Max(Math.Max(personLimit1.Record, personLimit2.Record), personLimit3.Record);
hasMaxLimit = true;
if (maxLimit > flashSale.MaxQuantity)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.MaxQuantityLimit,
HasQuantityLimit = true
});
}
}
if (flashSale.PlaceQuantity.HasValue && flashSale.PlaceQuantity.Value > 0)
{
var saleProducts = (await DalFlashSale.SelectFlashSaleProductsAsync(item.ActivityId.Value)).ToList();
var salePids = saleProducts.Where(r => r.IsJoinPlace).Select(r => r.PID).ToList();
if (salePids.Contains(item.PID))
{
var placeLimit1 = await FlashSaleCounter.RedisCounterRecord(countKey.PlacekeyUserId,
LimitType.PlaceLimit, CounterKeyType.UserIdKey, item, userId, deviceId, userTel, salePids,
-1);
if (placeLimit1.Code < 0)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
}
}
;
var placeLimit2 = await FlashSaleCounter.RedisCounterRecord(countKey.PlacekeyDeviceId,
LimitType.PlaceLimit, CounterKeyType.DeviceIdKey, item, userId, deviceId, userTel, salePids,
placeLimit1.DeviceCount);
if (placeLimit2.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PlacekeyUserId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var placeLimit3 = await FlashSaleCounter.RedisCounterRecord(countKey.PlacekeyUseTel,
LimitType.PlaceLimit, CounterKeyType.UserTelKey, item, userId, deviceId, userTel, salePids,
placeLimit1.TelCount);
if (placeLimit3.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PlacekeyUserId);
await FlashSaleCounter.DecrementCountCount(orderItem, countKey.PlacekeyDeviceId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
if (placeLimit1.Code < 0 || placeLimit2.Code < 0 || placeLimit3.Code < 0)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
hasPlaceLimit = true;
var placeLimit = Math.Max(Math.Max(placeLimit1.Record, placeLimit2.Record), placeLimit3.Record);
if (placeLimit > flashSale.PlaceQuantity.Value)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.PlaceQuantityLimit,
HasQuantityLimit = hasMaxLimit,
HasPlaceLimit = true
});
}
}
}
#region 针对618增加一个全局会场限购
if (flashSale.ActiveType == 3 && FlashSaleManager.CheckAllPlaceLimitStatrtDate())
{
var allPLimitId = GlobalConstant.AllPlaceLimitId;
item.AllPlaceLimitId = allPLimitId;
var request1 = new GenerateKeyRequest
{
DeviceId = deviceId,
UserId = userId.ToString(),
UserTel = userTel,
ActivityId = item.AllPlaceLimitId,
Pid = item.PID,
IsAllPlaceLimit = true
};
var countKeyAllLimit = new GenerateFlashSaleKey(request1);
var config = await FlashSaleManager.SelectFlashSaleDataByActivityIDAsync(new Guid(allPLimitId));
if (config.PlaceQuantity.HasValue)
{
var saleProducts = config.Products.ToList();
var salePids = saleProducts.Where(r => r.IsJoinPlace).Select(r => r.PID).ToList();
if (salePids.Contains(item.PID))
{
var placeLimit1 = await FlashSaleCounter.RedisCounterRecord(
countKeyAllLimit.PlacekeyUserId, LimitType.AllPlaceLimit, CounterKeyType.UserIdKey, item,
userId, deviceId, userTel, salePids, -1);
if (placeLimit1.Code < 0)
{
return new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
}
}
;
var placeLimit2 = await FlashSaleCounter.RedisCounterRecord(countKeyAllLimit.PlacekeyDeviceId,
LimitType.AllPlaceLimit, CounterKeyType.DeviceIdKey, item, userId, deviceId, userTel,
salePids, placeLimit1.DeviceCount);
if (placeLimit2.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyUserId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var placeLimit3 = await FlashSaleCounter.RedisCounterRecord(countKeyAllLimit.PlacekeyUseTel,
LimitType.AllPlaceLimit, CounterKeyType.UserTelKey, item, userId, deviceId, userTel,
salePids, placeLimit1.TelCount);
if (placeLimit3.Code < 0)
{
var orderItem = new CheckFlashSaleResponseModel
{
Num = item.Num
};
await FlashSaleCounter.DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyUserId);
await FlashSaleCounter.DecrementCountCount(orderItem, countKeyAllLimit.PlacekeyDeviceId);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
if (placeLimit1.Code < 0 || placeLimit2.Code < 0 || placeLimit3.Code < 0)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
});
}
var allplaceLimit = Math.Max(Math.Max(placeLimit1.Record, placeLimit2.Record),
placeLimit3.Record);
allPlaceLimitId = allPLimitId;
if (allplaceLimit > config.PlaceQuantity.Value)
{
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.PlaceQuantityLimit,
AllPlaceLimitId = allPlaceLimitId
});
}
}
#region 错误代码
//var hashRecord618 = await FlashSaleCounter.RedisAllPlaceLimitHashRecord(item.PID, item);
//if (hashRecord618 != null)
//{
// if (hashRecord618.Code == CheckFlashSaleStatus.CreateOrderFailed)
// return new CheckFlashSaleResponseModel()
// {
// Code = CheckFlashSaleStatus.CreateOrderFailed,
// };
// var saledAll = model.Record;
// var config =
// await FlashSaleManager.SelectFlashSaleDataByActivityIDAsync(
// new Guid(allPLimitId));
// var configQty = config.Products.Where(r => r.PID == item.PID).Select(r => r.TotalQuantity).FirstOrDefault();
// allPlaceLimitId = allPLimitId;
// if (configQty - saledAll < 0)
// return new CheckFlashSaleResponseModel()
// {
// Code = CheckFlashSaleStatus.NoEnough,
// AllPlaceLimitId = allPlaceLimitId
// };
//}
#endregion
}
}
#endregion
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.Succeed,
HasPlaceLimit = hasPlaceLimit,
HasQuantityLimit = hasMaxLimit,
AllPlaceLimitId = allPlaceLimitId
});
#endregion
}
catch (Exception ex)
{
Logger.Info(ex);
return(new CheckFlashSaleResponseModel()
{
Code = CheckFlashSaleStatus.CreateOrderFailed,
HasPlaceLimit = hasPlaceLimit,
HasQuantityLimit = hasMaxLimit
});
}
}
public APICredential FinishPINRegistration(string email, string pincode, string password, string secretQuestion, string answer, string firstName, string lastName, string keyDescription)
{
var p = ConnectionStrings.Endpoints["finishPINRegistration"].Clone();
var req = new FinishRegistrationRequest
{
Email = email,
PinCode = pincode,
Password = password,
Question = secretQuestion,
Answer = answer,
FirstName = firstName,
LastName = lastName
};
var response = _connection.Send <StandardResponse>(p, req);
switch (response.Response)
{
case APIResponse.PASSWORD_COMPLEXITY:
throw new InsufficientPasswordComplexityException(response.Message);
case APIResponse.TOKEN_EXPIRED:
throw new TokenExpiredException(response.Message);
case APIResponse.PIN_RESEND:
throw new PINRefreshException(response.Message);
case APIResponse.INVALID_TOKEN:
throw new InvalidTokenException(response.Message);
default:
{
if (response.Response != APIResponse.SUCCESS)
{
throw new ActionFailedException(response.Response.ToString(), response.Message);
}
break;
}
}
p = ConnectionStrings.Endpoints["generateKey"].Clone();
var keyReq = new GenerateKeyRequest
{
Email = email,
Password = password,
KeyDescription = keyDescription
};
var response2 = _connection.Send <GenerateAPIKeyResponse>(p, keyReq);
if (response2.Response != APIResponse.SUCCESS)
{
throw new ActionFailedException(response2.Response.ToString(), response2.Message);
}
var key = new APICredential
{
APIKey = response2.APIKey,
APISecret = response2.APISecret
};
return(key);
}
/// <summary> /// Generate new key /// </summary> /// <param name="request"></param> /// <returns></returns> public static GenerateKeyResponse Generate(GenerateKeyRequest request) => Native.Call <GenerateKeyRequest, GenerateKeyResponse>(request, Native.didkey_generate);
