public AccountWrapper CreateAccount(int id, RawPubKey pubkey, RequestRateLimits rateLimits)
{
if (pubkey == null)
{
throw new ArgumentNullException(nameof(pubkey));
}
if (accountIds.ContainsKey(pubkey))
{
throw new InvalidOperationException($"Account with public key {pubkey} already exists");
}
var acc = new AccountWrapper(new Account
{
Id = id,
Pubkey = pubkey,
Balances = new List <Balance>()
},
rateLimits
);
accountIds.Add(pubkey, id);
accounts.Add(id, acc);
return(acc);
}
/// <summary>
/// Updates specified request rate limit object values.
/// </summary>
/// <param name="requestRateLimits">Target rate limit request object.</param>
/// <param name="newRequestRateLimits">New rate limit request object.</param>
public static void Update(this RequestRateLimits requestRateLimits, RequestRateLimits newRequestRateLimits)
{
if (newRequestRateLimits == null)
{
throw new ArgumentNullException(nameof(newRequestRateLimits));
}
Update(requestRateLimits, newRequestRateLimits.HourLimit, newRequestRateLimits.MinuteLimit);
}
/// <summary>
/// Updates specified request rate limit object values.
/// </summary>
/// <param name="requestRateLimits">Target rate limit request object.</param>
/// <param name="hourLimit">New hour limit.</param>
/// <param name="minuteLimit">New minute limit.</param>
public static void Update(this RequestRateLimits requestRateLimits, uint hourLimit, uint minuteLimit)
{
if (requestRateLimits == null)
{
throw new ArgumentNullException(nameof(requestRateLimits));
}
requestRateLimits.HourLimit = hourLimit;
requestRateLimits.MinuteLimit = minuteLimit;
}
private void Update(RequestRateLimits newValue)
{
if (newValue == null)
{
Account.RequestRateLimits = null;
Account.RequestRateLimits.Update(globalRateLimits);
return;
}
if (Account.RequestRateLimits == null)
{
Account.RequestRateLimits = new RequestRateLimits();
Effect.AccountWrapper.RequestCounter.SetLimits(Account.RequestRateLimits); //update reference
}
//update values
Account.RequestRateLimits.Update(newValue);
}
public async Task <IActionResult> Init([FromBody] ConstellationInitModel constellationInit)
{
try
{
if (constellationInit == null)
{
return(StatusCode(415));
}
if (constellationInit.RequestRateLimits == null)
{
throw new ArgumentNullException(nameof(constellationInit.RequestRateLimits), "RequestRateLimits parameter is required.");
}
var requestRateLimits = new RequestRateLimits
{
HourLimit = constellationInit.RequestRateLimits.HourLimit,
MinuteLimit = constellationInit.RequestRateLimits.MinuteLimit
};
var constellationInitializer = new ConstellationInitializer(
new ConstellationInitInfo
{
Auditors = constellationInit.Auditors.Select(a => KeyPair.FromAccountId(a)).ToArray(),
MinAccountBalance = constellationInit.MinAccountBalance,
MinAllowedLotSize = constellationInit.MinAllowedLotSize,
Assets = constellationInit.Assets.Select(a => AssetSettings.FromCode(a)).ToArray(),
RequestRateLimits = requestRateLimits
},
Context
);
await constellationInitializer.Init();
return(new JsonResult(new InitResult {
IsSuccess = true
}));
}
catch (Exception exc)
{
return(new JsonResult(new InitResult {
IsSuccess = false, Error = exc.Message
}));
}
}
public void Setup()
{
EnvironmentHelper.SetTestEnvironmentVariable();
var settings = new AlphaSettings
{
HorizonUrl = "https://horizon-testnet.stellar.org",
NetworkPassphrase = "Test SDF Network ; September 2015",
CWD = "AppData"
};
var stellarProvider = new MockStellarDataProvider(settings.NetworkPassphrase, settings.HorizonUrl);
context = new AlphaContext(settings, new MockStorage(), stellarProvider);
context.Init().Wait();
var requestsLimit = new RequestRateLimits();
account1 = new AccountWrapper(new Models.Account
{
Id = 1,
Pubkey = new RawPubKey()
{
Data = KeyPair.Random().PublicKey
},
Balances = new List <Balance>()
}, requestsLimit);
account1.Account.CreateBalance(0);
account1.Account.GetBalance(0).UpdateBalance(10000000000);
account1.Account.CreateBalance(1);
account1.Account.GetBalance(1).UpdateBalance(10000000000);
account2 = new AccountWrapper(new Models.Account
{
Id = 2,
Pubkey = new RawPubKey()
{
Data = KeyPair.Random().PublicKey
},
Balances = new List <Balance>()
}, requestsLimit);
account2.Account.CreateBalance(0);
account2.Account.GetBalance(0).UpdateBalance(10000000000);
account2.Account.CreateBalance(1);
account2.Account.GetBalance(1).UpdateBalance(10000000000);
context.Setup(new Snapshot
{
Accounts = new List <AccountWrapper> {
account1, account2
},
Apex = 0,
TxCursor = 1,
Orders = new List <Order>(),
Settings = new ConstellationSettings
{
Vault = KeyPair.Random().PublicKey,
Assets = new List <AssetSettings> {
new AssetSettings {
Id = 1, Code = "X", Issuer = new RawPubKey()
}
},
RequestRateLimits = new RequestRateLimits {
HourLimit = 1000, MinuteLimit = 100
}
},
}).Wait();
}
public AccountCreateEffectProcessor(AccountCreateEffect effect, AccountStorage accountStorage, RequestRateLimits requestRateLimits)
: base(effect)
{
this.accountStorage = accountStorage ?? throw new ArgumentNullException(nameof(accountStorage));
this.requestRateLimits = requestRateLimits ?? throw new ArgumentNullException(nameof(requestRateLimits));
}
public AccountStorage(IEnumerable <Account> accounts, RequestRateLimits defaultRequestRateLimits)
: this(accounts.Select(a => new AccountWrapper(a, a.RequestRateLimits ?? defaultRequestRateLimits)))
{
}
public RequestRateLimitUpdateEffectProcessor(RequestRateLimitUpdateEffect effect, RequestRateLimits globalRateLimits)
: base(effect)
{
this.globalRateLimits = globalRateLimits ?? throw new ArgumentNullException(nameof(globalRateLimits));
}
