Exemple #1
0
        /// <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(appId:$appId^,type:SEND,identityId:$identityId^,send_token_data:{recipient_identity_id:$recipient_id^, token_id: ""$token_id^"", ";
            if (item.nonFungible)
            {
                _query += @"token_index: ""$item_index^"", ";
            }

            _query += "value:$value^}){id,encodedData,state}}";

            GraphQuery.variable["appId"]      = Enjin.AppID.ToString();
            GraphQuery.variable["identityId"] = identityID.ToString();
            GraphQuery.variable["token_id"]   = item.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)));
            }

            return(null);
        }
Exemple #2
0
        /// <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(appId:$appId^,identityId:$identityID^,type:UPDATE_NAME,update_item_name_data:{token_id:""$id^"",name:""$name^""}){id,encodedData,state}}";
                GraphQuery.variable["appId"]      = Enjin.AppID.ToString();
                GraphQuery.variable["id"]         = item.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>
        /// 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.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.id, amount.ToString());
                Items.Add(tItem);
            }
        }
Exemple #4
0
        /// <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)
            {
                _query =
                    @"mutation setItemUri{request:CreateEnjinRequest(appId:$appId^,identityId:$identityID^,type:SET_ITEM_URI,set_item_uri_data:{token_id:""$itemID^"",item_uri:""$itemData^""}){id,encodedData,state}}";
            }
            else
            {
                _query =
                    @"mutation setURI{request:CreateEnjinRequest(appId:$appId^,identityId:$identityID^,type:SET_ITEM_URI,set_item_uri_data:{token_id:""$itemID^"",token_index:$tokenIndex^,item_uri:""$itemData^""}){id,encodedData,state}}";
                GraphQuery.variable["tokenIndex"] = item.index.TrimStart('0');
            }

            GraphQuery.variable["appId"]      = Enjin.AppID.ToString();
            GraphQuery.variable["identityID"] = identityID.ToString();
            GraphQuery.variable["itemID"]     = item.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);
        }
Exemple #5
0
        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.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.id, item.index, amount);
            }

            return(CreateTradeRequest(senderIdentityID, fromSender, secondPartyAddress, secondPartyIdentityID,
                                      fromSecondParty));
        }
 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 UpdateCryptoItem(string senderAddress, CryptoItem item, CryptoItemFieldType fieldType,
                                        System.Action <RequestEvent> callback)
 {
     return(_requests.UpdateCryptoItem(senderAddress, item, fieldType, callback));
 }
 public static Request SetCryptoItemURI(string senderAddress, CryptoItem item, string URI,
                                        System.Action <RequestEvent> callback)
 {
     return(_requests.SetCryptoItemURI(senderAddress, item, URI, callback));
 }