/// <summary>
/// Creates a new CryptoItem for current selected application
/// </summary>
/// <param name="newItem">CryptoItem to create</param>
/// <param name="identityID">CryptoItem creator user identity ID</param>
/// <returns>Request data</returns>
public Request CreateCryptoItem(CryptoItem newItem, int identityID)
{
string query = string.Empty;
if (newItem.icon != null)
{
query = "mutation createCryptoItem{request:CreateEnjinRequest(type:CREATE,identity_id:$identity^,create_token_data:{name:\"$name^\",totalSupply:$totalSupply^,initialReserve:$reserve^,supplyModel:$model^,meltValue:\"$meltValue^\",meltFeeRatio:$meltFee^,transferable:$transferable^,transferFeeSettings:{type:$fType^, token_id:\"$fToken^\",value:\"$fValue^\"},nonFungible:$nonFungible^,icon:\"$icon^\"}){id,encoded_data,state}}";
GraphQuery.variable["icon"] = newItem.icon;
}
else
{
query = "mutation createCryptoItem{request:CreateEnjinRequest(type:CREATE,identity_id:$identity^,create_token_data:{name:\"$name^\",totalSupply:$totalSupply^,initialReserve:$reserve^,supplyModel:$model^,meltValue:\"$meltValue^\",meltFeeRatio:$meltFee^,transferable:$transferable^,transferFeeSettings:{type:$fType^, token_id:\"$fToken^\",value:\"$fValue^\"},nonFungible:$nonFungible^}){id,encoded_data,state}}";
}
GraphQuery.variable["name"] = newItem.name;
GraphQuery.variable["identity"] = identityID.ToString();
GraphQuery.variable["totalSupply"] = newItem.totalSupply;
GraphQuery.variable["reserve"] = newItem.reserve;
GraphQuery.variable["model"] = newItem.supplyModel.ToString();
GraphQuery.variable["meltValue"] = newItem.meltValue;
GraphQuery.variable["meltFee"] = newItem.meltFeeRatio.ToString();
GraphQuery.variable["transferable"] = newItem.transferable.ToString();
GraphQuery.variable["fType"] = newItem.transferFeeSettings.type.ToString();
GraphQuery.variable["fToken"] = newItem.transferFeeSettings.token_id;
GraphQuery.variable["fValue"] = newItem.transferFeeSettings.value.ToString();
GraphQuery.variable["nonFungible"] = newItem.nonFungible.ToString().ToLower();
GraphQuery.POST(query);
return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2)));
}
public Request CreateTradeRequest(int senderIdentityID, CryptoItem[] itemsFromSender, int[] amountsFromSender, string secondPartyAddress, int?secondPartyIdentityID, CryptoItem[] itemsFromSecondParty, int[] amountsFromSecondParty)
{
if (EnjinHelpers.IsNullOrEmpty(itemsFromSender) || EnjinHelpers.IsNullOrEmpty(amountsFromSender) || itemsFromSender.Length != amountsFromSender.Length)
{
return(null);
}
if (EnjinHelpers.IsNullOrEmpty(itemsFromSecondParty) || EnjinHelpers.IsNullOrEmpty(amountsFromSecondParty) || itemsFromSecondParty.Length != amountsFromSecondParty.Length)
{
return(null);
}
TokenValueInputData[] fromSender = new TokenValueInputData[itemsFromSender.Length];
TokenValueInputData[] fromSecondParty = new TokenValueInputData[itemsFromSecondParty.Length];
for (int i = 0; i < itemsFromSender.Length; i++)
{
CryptoItem item = itemsFromSender[i];
int amount = amountsFromSender[i];
fromSender[i] = new TokenValueInputData(item.token_id, item.index, amount);
}
for (int i = 0; i < itemsFromSecondParty.Length; i++)
{
CryptoItem item = itemsFromSecondParty[i];
int amount = amountsFromSecondParty[i];
fromSecondParty[i] = new TokenValueInputData(item.token_id, item.index, amount);
}
return(CreateTradeRequest(senderIdentityID, fromSender, secondPartyAddress, secondPartyIdentityID, fromSecondParty));
}
/// <summary>
/// Creates a new CryptoItem for current selected application
/// </summary>
/// <param name="newItem">CrytpoItem to create</param>
/// <param name="identityID">CryptoItem creator user identity ID</param>
/// <param name="callback">Callback action to execute when request is completed</param>
/// <returns>Request data</returns>
public Request CreateCryptoItem(CryptoItem newItem, int identityID, System.Action <RequestEvent> callback)
{
Request request = CreateCryptoItem(newItem, identityID);
Enjin.RequestCallbacks.Add(request.id, callback);
return(request);
}
/// <summary>
/// Sends a Token on the Trusted Platform and blockchain using full CryptoItem.
/// Allows for fungible and nonfungible token requests
/// </summary>
/// <param name="identityID">Identity ID of requestor</param>
/// <param name="item">CryptoItem to be sent</param>
/// <param name="recipientID">Identity ID of reciving wallet</param>
/// <param name="value">Number of tokens to be sent</param>
/// /// <param name="value">Callback function to execute when request is fulfilled</param>
/// <returns>Create request data from API</returns>
public Request SendItem(int identityID, CryptoItem item, int recipientID, int value, System.Action <RequestEvent> callback)
{
_query = @"mutation sendItem{CreateEnjinRequest(type:SEND,identity_id:$identity_id^,send_token_data:{recipient_identity_id:$recipient_id^, token_id: ""$token_id^"", ";
if (item.nonFungible)
{
_query += @"token_index: ""$item_index^"", ";
}
_query += "value:$value^}){id,encoded_data,state}}";
GraphQuery.variable["identity_id"] = identityID.ToString();
GraphQuery.variable["token_id"] = item.token_id.ToString();
if (item.nonFungible)
{
GraphQuery.variable["item_index"] = item.index.ToString();
}
GraphQuery.variable["recipient_id"] = recipientID.ToString();
GraphQuery.variable["value"] = value.ToString();
GraphQuery.POST(_query);
if (Enjin.ServerResponse == ResponseCodes.SUCCESS)
{
return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2)));
}
return(null);
}
/// <summary>
/// Sends a Token on the Trusted Platform and blockchain using full CryptoItem.
/// Allows for fungible and nonfungible token requests
/// </summary>
/// <param name="identityID">Identity ID of requestor</param>
/// <param name="item">CryptoItem to be sent</param>
/// <param name="recipientID">Identity ID of reciving wallet</param>
/// <param name="value">Number of tokens to be sent</param>
/// /// <param name="value">Callback function to execute when request is fulfilled</param>
/// <returns>Create request data from API</returns>
public Request SendItem(int identityID, CryptoItem item, int recipientID, int value, System.Action <string> handler, bool async = false)
{
_query = @"mutation sendItem{CreateEnjinRequest(type:SEND,identity_id:$identity_id^,send_token_data:{recipient_identity_id:$recipient_id^, token_id: ""$token_id^"", ";
if (item.nonFungible)
{
_query += @"token_index: ""$item_index^"", ";
}
_query += "value:$value^}){id,encoded_data,state}}";
GraphQuery.variable["identity_id"] = identityID.ToString();
GraphQuery.variable["token_id"] = item.token_id;
if (item.nonFungible)
{
GraphQuery.variable["item_index"] = item.index;
}
GraphQuery.variable["recipient_id"] = recipientID.ToString();
GraphQuery.variable["value"] = value.ToString();
GraphQuery.POST(_query, "", async, (queryReturn) =>
{
handler?.Invoke(queryReturn);
});
if (GraphQuery.queryStatus == GraphQuery.Status.Complete)
{
return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2)));
}
else
{
return(null);
}
}
/// <summary>
/// Sets the metadata URI for a cryptoItem
/// </summary>
/// <param name="identityID">Identity ID of user setting metadata URI</param>
/// <param name="itemID">ID of cryptoItem to set metadata URI for</param>
/// <param name="itemData">metadata URI data</param>
/// <returns></returns>
public Request SetCryptoItemURI(int identityID, CryptoItem item, string itemData, System.Action <RequestEvent> callback)
{
if (item.index != null)
{
// Validate that index is not just empty, if so set it to null
if (item.index == string.Empty)
{
item.index = null;
}
}
if (item.index == null || item.balance == 0)
{
_query = @"mutation setItemUri{request:CreateEnjinRequest(identity_id:$identityID^,type:SET_ITEM_URI,set_item_uri_data:{token_id:""$itemID^"",item_uri:""$itemData^""}){id,encoded_data,state}}";
}
else
{
_query = @"mutation setURI{request:CreateEnjinRequest(identity_id:$identityID^,type:SET_ITEM_URI,set_item_uri_data:{token_id:""$itemID^"",token_index:$tokenIndex^,item_uri:""$itemData^""}){id,encoded_data,state}}";
GraphQuery.variable["tokenIndex"] = item.index.TrimStart('0');
//int subItemIndex;
//if (System.Int32.TryParse(item.index, out subItemIndex))
//{
// GraphQuery.variable["tokenIndex"] = (subItemIndex + "");
//}
}
GraphQuery.variable["identityID"] = identityID.ToString();
GraphQuery.variable["itemID"] = item.token_id;
GraphQuery.variable["itemData"] = itemData;
GraphQuery.POST(_query);
if (Enjin.ServerResponse == ResponseCodes.SUCCESS)
{
Request request = JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2));
Enjin.RequestCallbacks.Add(request.id, callback);
return(request);
}
return(null);
}
/// <summary>
/// Adds a fungible item to the transfer list
/// </summary>
/// <param name="fromAddress">Address to send item from</param>
/// <param name="toAddress">Address to send item to</param>
/// <param name="item">Item to send</param>
/// <param name="amount">Amount of item to send.</param>
public void Add(string fromAddress, string toAddress, CryptoItem item, int amount)
{
if (amount <= 0)
{
return;
}
if (item.nonFungible)
{
string tItem = @"from:""{0}"",to:""{1}"",token_id:""{2}"",token_index:""{3}"",value:""1""";
tItem = string.Format(tItem, fromAddress, toAddress, item.token_id, item.index);
Items.Add(tItem);
}
else
{
string tItem = @"from:""{0}"",to:""{1}"",token_id:""{2}"",value:""{3}""";
tItem = string.Format(tItem, fromAddress, toAddress, item.token_id, amount.ToString());
Items.Add(tItem);
}
}
/// <summary>
/// Updates CryptoItem information on blockchain
/// </summary>
/// <param name="identityID">Identity of user</param>
/// <param name="item">CryptoItem to update</param>
/// <param name="fieldType">What field to update</param>
/// <returns></returns>
public Request UpdateCryptoItem(int identityID, CryptoItem item, CryptoItemFieldType fieldType, System.Action <RequestEvent> callback)
{
switch (fieldType)
{
case CryptoItemFieldType.NAME:
_query = @"mutation updateItemName{request:CreateEnjinRequest(identity_id:$identityID^,type:UPDATE_NAME,update_item_name_data:{token_id:""$id^"",name:""$name^""}){id,encoded_data,state}}";
GraphQuery.variable["id"] = item.token_id;
GraphQuery.variable["identityID"] = identityID.ToString();
GraphQuery.variable["name"] = item.name;
break;
case CryptoItemFieldType.MELTFEE:
break;
case CryptoItemFieldType.TRANSFERABLE:
break;
case CryptoItemFieldType.TRANSFERFEE:
break;
case CryptoItemFieldType.MAXMELTFEE:
break;
case CryptoItemFieldType.MAXTRANSFERFEE:
break;
}
GraphQuery.POST(_query);
if (Enjin.ServerResponse == ResponseCodes.SUCCESS)
{
Request request = JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2));
Enjin.RequestCallbacks.Add(request.id, callback);
return(request);
}
return(null);
}
/// <summary>
/// Updates an existing CryptoItem (WIP...)
/// </summary>
/// <param name="item">CryptoItem with updated fields</param>
/// <returns>Updated CryptoItem as it was updated</returns>
public CryptoItem UpdateCryptoItem(CryptoItem item)
{
return(null);
}
public static Request UpdateCryptoItem(int identityID, CryptoItem item, CryptoItemFieldType fieldType, System.Action <RequestEvent> callback)
{
return(_requests.UpdateCryptoItem(identityID, item, fieldType, callback));
}
public static Request SetCryptoItemURI(int identityID, CryptoItem item, string URI, System.Action <RequestEvent> callback)
{
return(_requests.SetCryptoItemURI(identityID, item, URI, callback));
}
public static Request CreateCryptoItem(CryptoItem item, int identityID, System.Action <RequestEvent> callback)
{
return(_cryptoItems.CreateCryptoItem(item, identityID, callback));
}
public static Request CreateCryptoItem(CryptoItem item, int identityID)
{
return(_cryptoItems.CreateCryptoItem(item, identityID));
}
public static CryptoItem UpdateCryptoItem(CryptoItem item)
{
return(_cryptoItems.UpdateCryptoItem(item));
}
