public void SetCurrentTournament(SpaceTypeId tournament)
{
if (IsTournamentExist(tournament))
{
currentTournament = myTournaments[tournament];
}
}
public AssetData(JObject value)
{
var token = value.Root;
Amount = value.TryGetValue(AMOUNT_FIELD_KEY, out token) ? token.ToObject <long>() : 0;
AssetId = value.TryGetValue(ASSET_ID_FIELD_KEY, out token) ? token.ToObject <SpaceTypeId>() : SpaceTypeId.EMPTY;
}
public static bool IsExist(SpaceTypeId spaceTypeId)
{
lock (rootLocler)
{
return(root.ContainsKey(spaceTypeId.SpaceType) && root[spaceTypeId.SpaceType].ContainsKey(spaceTypeId));
}
}
public static IPromise <TournamentCreateOperationData> GenerateCreateTournamentOperation(CreateTournamentData data)
{
Func <AssetObject, IPromise <TournamentCreateOperationData> > GenerateOperation = assetObject => Promise <TournamentCreateOperationData> .Resolved(new TournamentCreateOperationData {
Fee = new AssetData(0L, assetObject.Id),
Creator = data.account,
Options = new TournamentOptionsData {
RegistrationDeadline = data.registrationDeadline,
NumberOfPlayers = data.numberOfPlayers,
BuyIn = new AssetData(( long )(data.buyInAmount * Math.Pow(10, assetObject.Precision)), assetObject.Id),
Whitelist = data.whitelist.OrEmpty(),
StartTime = data.startTime,
StartDelay = data.startDelay,
RoundDelay = data.roundDelay,
NumberOfWins = data.numberOfWins,
Meta = new CustomData(),
GameOptions = new RockPaperScissorsGameOptionsData {
InsuranceEnabled = data.insuranceEnabled,
TimePerCommitMove = data.timePerCommitMove,
TimePerRevealMove = data.timePerRevealMove
}
}
});
var asset = SpaceTypeId.CreateOne(SpaceType.Asset, data.buyInAssetId);
return(Repository.GetInPromise(asset, () => ApiManager.Instance.Database.GetAsset(asset.Id)).Then(GenerateOperation));
}
// Typically this is called automatically just prior to signing. Once finalized this transaction can not be changed.
private IPromise Finalize()
{
if (IsFinalized)
{
return(Promise.Rejected(new InvalidOperationException("Finalize... Already finalized")));
}
var dynamicGlobalProperties = SpaceTypeId.CreateOne(SpaceType.DynamicGlobalProperties);
return(Repository.GetInPromise(dynamicGlobalProperties, () => EchoApiManager.Instance.Database.GetObject <DynamicGlobalPropertiesObject>(dynamicGlobalProperties)).Then(FinalizeInPromise));
}
void Init()
{
ApiManager.Instance.Database.GetFullAccount(SelectUpdater(), false).Then(fullAccount => {
if (!fullAccount.IsNull())
{
account = fullAccount.FullAccount.Account.Id;
initialized = work = true;
}
});
}
public IPromise <string> QueryContract(uint contractId, string bytecode, uint feeAssetId = 0, long amount = 0)
{
if (!Authorization.IsAuthorized)
{
return(Promise <string> .Rejected(new InvalidOperationException("Isn't Authorized!")));
}
var value = new AssetData(amount, SpaceTypeId.CreateOne(SpaceType.Asset, feeAssetId));
return(Database.CallContractNoChangingState(contractId, Authorization.Current.UserNameData.Value.Account.Id.ToUintId, value, bytecode));
}
public void SetUp(TournamentObject tournament)
{
ApiManager.Instance.Database
.GetAccountBalances(AuthorizationManager.Instance.UserData.FullAccount.Account.Id.Id, Array.ConvertAll(AuthorizationManager.Instance.UserData.FullAccount.Balances,
balance => balance.AssetType.Id))
.Then(accountBalances => {
AssetData asset = null;
foreach (var balance in accountBalances)
{
if (balance.Asset.Equals(tournament.Options.BuyIn.Asset))
{
asset = balance;
}
}
var feeAsset = SpaceTypeId.CreateOne(SpaceType.GlobalProperties);
Repository.GetInPromise <GlobalPropertiesObject>(feeAsset)
.Then(result => {
TournamentJoinOperationFeeParametersData myFee = null;
foreach (var fee in result.Parameters.CurrentFees.Parameters)
{
if (fee != null && fee.Type == ChainTypes.FeeParameters.TournamentJoinOperation)
{
myFee = fee as TournamentJoinOperationFeeParametersData;
}
}
currentAccountBalanceObject = asset;
currentFee = (long)myFee.Fee;
Repository.GetInPromise <AssetObject>(asset.Asset)
.Then(assetObject => {
buyinText.text = tournament.Options.BuyIn.Amount / Math.Pow(10, assetObject.Precision) + assetObject.Symbol;
feeText.text = myFee.Fee / Math.Pow(10, assetObject.Precision) + assetObject.Symbol;
ApiManager.Instance.Database.GetAccount(tournament.Creator.Id)
.Then(creator => {
creatorNameText.text = Utils.GetFormatedString(creator.Name);
var data = new JoinToTournamentData();
data.tournament = tournament;
data.account = AuthorizationManager.Instance.UserData.FullAccount.Account.Id;
currentData = data;
gameTitleText.text = "ROCK, PAPER, SCISSORS";
numberOfPlayersText.text = data.tournament.Options.NumberOfPlayers.ToString();
winsAmountText.text = data.tournament.Options.NumberOfWins.ToString();
registrationDeadlineText.text = data.tournament.Options.RegistrationDeadline.ToString("MMMM dd, yyyy hh:mmtt (z)").ToUpper();
Show();
});
});
});
});
}
void CheckNewVersion()
{
var fromId = lastOperationHistory.Id;
ApiManager.Instance.History.GetAccountHistory(account.Id, fromId, 100, 0).Then(operations => {
if (!operations.IsNullOrEmpty())
{
Array.Sort(operations, OperationHistoryObject.Compare);
var currentVersion = new VersionInfo(CurrentVersion);
var maxVersion = currentVersion;
for (var i = 0; i < operations.Length; i++)
{
var operationData = operations[i].Operation;
if (operationData.Type.Equals(ChainTypes.Operation.Transfer))
{
var memo = (operationData as TransferOperationData).Memo;
if (!memo.IsNull() && !memo.Message.IsNullOrEmpty())
{
try {
var token = JToken.Parse(Tool.FromHex2Chars(memo.Message));
if (token.Type.Equals(JTokenType.Object))
{
var values = token.ToObject <JObject>();
if (VersionInfo.IsInstance(values))
{
var versionInfo = values.ToObject <VersionInfo>();
if (versionInfo > maxVersion)
{
maxVersion = versionInfo;
}
}
}
} catch {
continue;
}
}
}
}
if (!maxVersion.IsNull() && maxVersion > currentVersion)
{
if (!OnNewVersionAvailable.IsNull())
{
OnNewVersionAvailable.Invoke(maxVersion);
work = false;
elapsedTime = 0f;
}
}
lastOperationHistory = operations.Last().Id;
}
});
}
public CommitAndReveal(ChainTypes.RockPaperScissorsGesture gesture, SpaceTypeId player)
{
this.gesture = gesture;
this.player = player;
nonce1 = GetRandomULong();
nonce2 = GetRandomULong();
hash = SHA256.Create().HashAndDispose(Tool.ToBuffer(buffer => {
buffer.WriteUInt64(nonce1);
buffer.WriteUInt64(nonce2);
buffer.WriteEnum(( int )gesture);
}).ToArray());
IsCommited = false;
IsRevealed = false;
}
public void SetUp(TournamentObject tournament)
{
ApiManager.Instance.Database
.GetAccountBalances(AuthorizationManager.Instance.UserData.FullAccount.Account.Id.Id, Array.ConvertAll(AuthorizationManager.Instance.UserData.FullAccount.Balances, balance => balance.AssetType.Id))
.Then(accountBalances => {
var data = new LeaveFromTournamentData();
data.tournament = tournament;
data.account = AuthorizationManager.Instance.UserData.FullAccount.Account.Id;
currentData = data;
AssetData asset = null;
foreach (var balance in accountBalances)
{
if (balance.Asset.Equals(currentData.tournament.Options.BuyIn.Asset))
{
asset = balance;
}
}
TournamentTransactionService.GenerateLeaveFromTournamentOperation(currentData)
.Then(operation => {
var feeAsset = SpaceTypeId.CreateOne(SpaceType.Asset);
ApiManager.Instance.Database.GetRequiredFee(operation, feeAsset.Id)
.Then(feeResult => {
Repository.GetInPromise <AssetObject>(feeResult.Asset)
.Then(assetData => {
buyinText.text = tournament.Options.BuyIn.Amount / Math.Pow(10, assetData.Precision) + assetData.Symbol;
feeText.text = feeResult.Amount / Math.Pow(10, assetData.Precision) + assetData.Symbol;
currentFee = feeResult.Amount;
currentOperation = operation;
currentAccountBalanceObject = asset;
ApiManager.Instance.Database.GetAccount(tournament.Creator.Id)
.Then(creator => {
gameTitleText.text = "ROCK, PAPER, SCISSORS";
creatorNameText.text = Utils.GetFormatedString(creator.Name);
numberOfPlayersText.text = data.tournament.Options.NumberOfPlayers.ToString();
winsAmountText.text = data.tournament.Options.NumberOfWins.ToString();
registrationDeadlineText.text = data.tournament.Options.RegistrationDeadline.ToString("MMMM dd, yyyy hh:mmtt (z)").ToUpper();
Show();
});
})
.Catch(exception => OperationOnDone("There was a mistake during leaving of a tournament!", false));
})
.Catch(exception => OperationOnDone("There was a mistake during leaving of a tournament!", false));
})
.Catch(exception => OperationOnDone("There was a mistake during leaving of a tournament!", false));
});
}
public static IPromise <T> GetInPromise <T>(SpaceTypeId key, Func <IPromise <T> > getter = null) where T : IdObject
{
if (IsExist(key))
{
return(Promise <T> .Resolved(( T )root[key.SpaceType][key]));
}
if (getter.IsNull())
{
return(Promise <T> .Resolved(null));
}
return(getter.Invoke().Then(idObject => {
Add(idObject);
return Promise <T> .Resolved(idObject);
}));
}
public static IPromise <T> GetInPromise <T>(SpaceTypeId key, Func <IPromise <T> > getter = null) where T : IdObject
{
lock (rootLocler)
{
if (root.ContainsKey(key.SpaceType) && root[key.SpaceType].ContainsKey(key))
{
return(Promise <T> .Resolved((T)root[key.SpaceType][key]));
}
}
return(getter.IsNull() ? Promise <T> .Resolved(null) : getter.Invoke().Then(idObject =>
{
AddObjectInPromise(idObject);
return Promise <T> .Resolved(idObject);
}));
}
public IPromise DeployContract(string bytecode, uint feeAssetId = 0, Action <TransactionConfirmationData> resultCallback = null)
{
if (!Authorization.IsAuthorized)
{
return(Promise.Rejected(new InvalidOperationException("Isn't Authorized!")));
}
var operation = new ContractCallOperationData
{
Registrar = SpaceTypeId.CreateOne(SpaceType.Account, Authorization.Current.UserNameData.Value.Account.Id.ToUintId),
Value = new AssetData(0, SpaceTypeId.CreateOne(SpaceType.Asset, feeAssetId)),
Code = bytecode.OrEmpty(),
Callee = null
};
return(Authorization.ProcessTransaction(new TransactionBuilder().AddOperation(operation), operation.Value.AssetId, resultCallback));
}
public IPromise <AssetData[]> GetRequiredFees(OperationData[] operations, uint assetId)
{
if (IsInitialized)
{
return(new Promise <AssetData[]>((resolve, reject) => {
var debug = true;
var requestId = GenerateNewId();
var methodName = "get_required_fees";
var title = methodName + " " + requestId;
var parameters = new Parameters {
Id.Value, methodName, new object[] { operations, SpaceTypeId.ToString(SpaceType.Asset, assetId) }
};
DoRequest(requestId, parameters, resolve, reject, title, debug);
}));
}
return(Init().Then(api => api.GetRequiredFees(operations, assetId)));
}
public IPromise <AssetData[]> GetAccountBalances(uint accountId, uint[] assetIds)
{
if (IsInitialized)
{
return(new Promise <AssetData[]>((resolve, reject) => {
var debug = true;
var requestId = GenerateNewId();
var methodName = "get_account_balances";
var title = methodName + " " + requestId;
var parameters = new Parameters {
Id.Value, methodName, new object[] { SpaceTypeId.ToString(SpaceType.Account, accountId), SpaceTypeId.ToStrings(SpaceType.Asset, assetIds) }
};
DoRequest(requestId, parameters, resolve, reject, title, debug);
}));
}
return(Init().Then(api => api.GetAccountBalances(accountId, assetIds)));
}
public IPromise <TournamentObject[]> GetTournaments(uint fromId, uint maxCount, uint toId)
{
if (IsInitialized)
{
return(new Promise <TournamentObject[]>((resolve, reject) => {
var debug = true;
var requestId = GenerateNewId();
var methodName = "get_tournaments";
var title = methodName + " " + requestId;
var parameters = new Parameters {
Id.Value, methodName,
new object[] { SpaceTypeId.ToString(SpaceType.Tournament, fromId), maxCount, SpaceTypeId.ToString(SpaceType.Tournament, toId) }
};
DoRequest(requestId, parameters, resolve, reject, title, debug);
}));
}
return(Init().Then(api => api.GetTournaments(fromId, maxCount, toId)));
}
public IPromise <OperationHistoryObject[]> GetAccountHistory(uint accountId, uint fromId, uint maxCount, uint toId)
{
if (IsInitialized)
{
return(new Promise <OperationHistoryObject[]>((resolve, reject) => {
var debug = true;
var requestId = GenerateNewId();
var methodName = "get_account_history";
var title = methodName + " " + requestId;
var parameters = new Parameters {
Id.Value, methodName,
new object[] { SpaceTypeId.ToString(SpaceType.Account, accountId), SpaceTypeId.ToString(SpaceType.OperationHistory, fromId), maxCount, SpaceTypeId.ToString(SpaceType.OperationHistory, toId) }
};
DoRequest(requestId, parameters, resolve, reject, title, debug);
}));
}
return(Init().Then(api => api.GetAccountHistory(accountId, fromId, maxCount, toId)));
}
private IPromise <AuthorizationResult> AuthorizationBy(uint id)
#endif
{
return(EchoApiManager.Instance.Database.GetFullAccount(SpaceTypeId.ToString(SpaceType.Account, id), true).Then(result =>
{
if (result.IsNull())
{
return Promise <AuthorizationResult> .Resolved(AuthorizationResult.UserNotFound);
}
#if BY_PASS
return AuthorizationBy(result, password);
#elif BY_WIF
return AuthorizationBy(result, wif);
#else
return Promise <AuthorizationResult> .Resolved(AuthorizationResult.Failed);
#endif
}));
}
public void SetTournamentInformation(CreateTournamentData data, bool isJoin)
{
isJoinToTournament = isJoin;
currentData = data;
gameTitleText.text = "ROCK, PAPER, SCISSORS";
var username = AuthorizationManager.Instance.Authorization.UserNameData.UserName;
creatorNameText.text = Utils.GetFormatedString(username);
numberOfPlayersText.text = data.numberOfPlayers.ToString();
winsAmountText.text = data.numberOfWins.ToString();
registrationDeadlineText.text = data.registrationDeadline.ToString("MMMM dd, yyyy hh:mmtt (z)").ToUpper();
TournamentManager.Instance.GetAssetObject(data.buyInAssetId)
.Then(asset => {
buyinText.text =
Utils.GetFormatedDecimaNumber(data.buyInAmount.ToString()) + asset.Symbol;
var feeAsset = SpaceTypeId.CreateOne(SpaceType.GlobalProperties);
Repository
.GetInPromise <GlobalPropertiesObject>(feeAsset)
.Then(result => {
TournamentJoinOperationFeeParametersData joinFee = null;
TournamentCreateOperationFeeParametersData createFee = null;
foreach (var fee in result.Parameters.CurrentFees.Parameters)
{
if (fee != null && fee.Type == ChainTypes.FeeParameters.TournamentJoinOperation)
{
joinFee = fee as TournamentJoinOperationFeeParametersData;
}
if (fee != null && fee.Type == ChainTypes.FeeParameters.TournamentCreateOperation)
{
createFee = fee as TournamentCreateOperationFeeParametersData;
}
}
var amount = isJoin ? Convert.ToDouble(createFee.Fee + joinFee.Fee) : Convert.ToDouble(createFee.Fee);
amount /= Mathf.Pow(10, asset.Precision);
feeText.text = amount + asset.Symbol;
gameObject.SetActive(true);
});
});
}
void JoinTournament(SpaceTypeId tournament)
{
if (isJoinToTournament)
{
Action <TournamentObject> JoinToTournament = tournamentObject => {
var joinTournamentData = new JoinToTournamentData();
joinTournamentData.tournament = tournamentObject;
joinTournamentData.account = AuthorizationManager.Instance.Authorization.UserNameData.FullAccount.Account.Id;
TournamentTransactionService.GenerateJoinToTournamentOperation(joinTournamentData)
.Then(operation => {
TournamentTransactionService.JoinToTournament(operation)
.Then(() => JoinOperationOnDone("Your tournament was successfully created & joined!", true))
.Catch(exception => JoinOperationOnDone("Your tournament was successfully created, but not joined!", false));
})
.Catch(exception => JoinOperationOnDone("There was a mistake during joining of a tournament!", false));
};
Repository.GetInPromise(tournament, () => TournamentManager.Instance.LoadTournament(tournament.Id)).Then(JoinToTournament);
}
}
public IEnumerator GetAccount(SpaceTypeId accountId, List <AccountObject> accountResult)
{
List <AccountObject> account = null;
ApiManager.Instance.Database.GetAccount(accountId.Id)
.Then(result => {
account = new List <AccountObject>();
account.Add(result);
})
.Catch(exeption => account = new List <AccountObject>());
while (account == null)
{
yield return(null);
}
if (account.Count > 0)
{
accountResult.AddRange(account);
}
}
public TransactionBuilder AddOperation(OperationData operation)
{
if (IsFinalized)
{
throw new InvalidOperationException("AddOperation... Already finalized");
}
if (operation.Fee.IsNull())
{
operation.Fee = new AssetData(0, SpaceTypeId.CreateOne(SpaceType.Asset));
}
if (operation.Type.Equals(ChainTypes.Operation.ProposalCreate))
{
var proposalCreateOperation = (ProposalCreateOperationData)operation;
if (proposalCreateOperation.ExpirationTime.IsZero())
{
proposalCreateOperation.ExpirationTime = TimeTool.ZeroTime().AddSeconds(BaseExpirationSeconds + ChainConfig.ExpireInSecondsProposal);
}
}
operations.Add(operation);
return(this);
}
public IPromise <AssetObject> GetAsset(uint id = 0)
{
return(GetObject <AssetObject>(SpaceTypeId.CreateOne(SpaceType.Asset, id)));
}
public int CompareTo(OperationHistoryObject other)
{
return(SpaceTypeId.Compare(Id, other.Id));
}
public PayerAmountPair(SpaceTypeId payer, long amount)
{
Payer = payer;
Amount = amount;
}
public IPromise <AccountObject[]> GetAccounts(uint[] ids)
{
return(GetObjects <AccountObject>(SpaceTypeId.CreateMany(SpaceType.Account, ids)));
}
public static IPromise <TransactionBuilder> SetRequiredFees(TransactionBuilder builder, SpaceTypeId assetId = null)
{
if (builder.IsFinalized)
{
throw new InvalidOperationException("SetRequiredFees... Already finalized");
}
if (builder.operations.IsNullOrEmpty())
{
throw new InvalidOperationException("SetRequiredFees... Add operation first");
}
var ops = new OperationData[builder.operations.Count];
for (var i = 0; i < builder.operations.Count; i++)
{
ops[i] = builder.operations[i].Clone();
}
var coreAssetId = SpaceTypeId.CreateOne(SpaceType.Asset);
if (assetId.IsNull())
{
var firstFee = ops.First().Fee;
if (!firstFee.IsNull() && !firstFee.AssetId.IsNullOrEmpty())
{
assetId = firstFee.AssetId;
}
else
{
assetId = coreAssetId;
}
}
var isNotCoreAsset = !assetId.Equals(coreAssetId);
var promises = new List <IPromise <object> >();
if (ops.Contains(op => op.Type.Equals(ChainTypes.Operation.ContractCall)))
{
promises.Add(EchoApiManager.Instance.Database.GetRequiredFees <FeeForCallContractData>(ops, assetId.ToUintId).Then <object>(feesData => feesData.Cast <IFeeAsset>()));
if (isNotCoreAsset)
{
promises.Add(EchoApiManager.Instance.Database.GetRequiredFees <FeeForCallContractData>(ops, coreAssetId.ToUintId).Then <object>(coreFeesData => coreFeesData.Cast <IFeeAsset>()));
}
}
else
if (ops.Contains(op => op.Type.Equals(ChainTypes.Operation.ContractCreate)))
{
promises.Add(EchoApiManager.Instance.Database.GetRequiredFees <FeeForCreateContractData>(ops, assetId.ToUintId).Then <object>(feesData => feesData.Cast <IFeeAsset>()));
if (isNotCoreAsset)
{
promises.Add(EchoApiManager.Instance.Database.GetRequiredFees <FeeForCreateContractData>(ops, coreAssetId.ToUintId).Then <object>(coreFeesData => coreFeesData.Cast <IFeeAsset>()));
}
}
else
{
promises.Add(EchoApiManager.Instance.Database.GetRequiredFees <AssetData>(ops, assetId.ToUintId).Then <object>(feesData => feesData.Cast <IFeeAsset>()));
if (isNotCoreAsset)
{
promises.Add(EchoApiManager.Instance.Database.GetRequiredFees <AssetData>(ops, coreAssetId.ToUintId).Then <object>(coreFeesData => coreFeesData.Cast <IFeeAsset>()));
}
}
if (isNotCoreAsset)
{
promises.Add(Repository.GetInPromise(assetId, () => EchoApiManager.Instance.Database.GetAsset(assetId.ToUintId)).Then <object>(assetObject => assetObject));
}
return(Promise <object> .All(promises.ToArray()).Then(results =>
{
var list = new List <object>(results).ToArray();
var feesData = list.First() as IFeeAsset[];
var coreFeesData = (list.Length > 1) ? (list[1] as IFeeAsset[]) : null;
var assetObject = (list.Length > 2) ? (list[2] as AssetObject) : null;
var dynamicPromise = isNotCoreAsset ? EchoApiManager.Instance.Database.GetObject <AssetDynamicDataObject>(assetObject.DynamicAssetData) : Promise <AssetDynamicDataObject> .Resolved(null);
return dynamicPromise.Then(dynamicObject =>
{
if (isNotCoreAsset)
{
var totalFees = 0L;
for (var j = 0; j < coreFeesData.Length; j++)
{
totalFees += coreFeesData[j].FeeAsset.Amount;
}
var feePool = dynamicObject.IsNull() ? 0L : dynamicObject.FeePool;
if (totalFees > feePool)
{
feesData = coreFeesData;
}
}
var flatAssets = GetFee(feesData.OrEmpty(), new List <AssetData>());
var assetIndex = 0;
for (var i = 0; i < builder.operations.Count; i++)
{
SetFee(builder.operations[i], ref assetIndex, flatAssets);
}
});
}).Then(() => Promise <TransactionBuilder> .Resolved(builder)));
}
public TournamentOptionsData()
{
RegistrationDeadline = Tool.ZeroTime();
Whitelist = new SpaceTypeId[0];
}
public IPromise <AccountObject> GetAccount(uint id)
{
return(GetObject <AccountObject>(SpaceTypeId.CreateOne(SpaceType.Account, id)));
}
