ETH NFT support

src/core_write.cpp

@@ -883,6 +883,14 @@ UniValue CReserveDeposit::ToUniValue() const
     return ret;
 }
 
+UniValue CETHNFTAddress::ToUniValue() const
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("contract", "0x" + HexBytes(contractID.begin(), contractID.size()));
+    ret.pushKV("tokenid", "0x" + HexBytes(tokenID.begin(), tokenID.size()));
+    return ret;
+}
+
 UniValue CTransferDestination::ToUniValue() const
 {
     UniValue destVal = UniValue(UniValue::VOBJ);
@@ -918,6 +926,15 @@ UniValue CTransferDestination::ToUniValue() const
             destVal.push_back(Pair("address", EncodeEthDestination(uint160(destination))));
             break;
 
+        case CTransferDestination::DEST_ETHNFT:
+        {
+            CETHNFTAddress oneAddr;
+            bool success = false;
+            ::FromVector(destination, oneAddr, &success);
+            destVal.push_back(Pair("address", success ? oneAddr.ToUniValue() : UniValue(UniValue::VOBJ)));
+            break;
+        }
+
         case CTransferDestination::DEST_FULLID:
             destVal.push_back(Pair("identity", CIdentity(destination).ToUniValue()));
             destVal.push_back(Pair("serializeddata", HexBytes(&(destination[0]), destination.size())));

src/key_io.cpp

@@ -740,6 +740,20 @@ CIdentity::CIdentity(const UniValue &uni) : CPrincipal(uni)
     }
 }
 
+CETHNFTAddress::CETHNFTAddress(const UniValue &uni)
+{
+    std::string contractAddrStr = uni_get_str(find_value(uni, "contract"));
+    std::string TokenIDStr = uni_get_str(find_value(uni, "tokenid"));
+
+    if (!(contractID = DecodeEthDestination(contractAddrStr)).IsNull() &&
+        TokenIDStr.length() == 66 &&
+        TokenIDStr.substr(0,2) == "0x" &&
+        IsHex(TokenIDStr.substr(2,64)))
+    {
+        tokenID = uint256(ParseHex(TokenIDStr.substr(2,64)));
+    }
+}
+
 CTransferDestination::CTransferDestination(const UniValue &obj) : fees(0)
 {
     type = uni_get_int(find_value(obj, "type"));
@@ -777,6 +791,13 @@ CTransferDestination::CTransferDestination(const UniValue &obj) : fees(0)
             break;
         }
 
+        case CTransferDestination::DEST_ETHNFT:
+        {
+            CETHNFTAddress ethNFTAddress(find_value(obj, "address"));
+            destination = ::AsVector(ethNFTAddress);
+            break;
+        }
+
         case CTransferDestination::DEST_FULLID:
         {
             std::string serializedHex(uni_get_str(find_value(obj, "serializeddata")));

src/pbaas/crosschainrpc.h

@@ -321,22 +321,8 @@ public:
         uint256 retTokenID;
         UniValue nftJSON(UniValue::VOBJ);
         nftJSON.read(destStr);
- 
+        CETHNFTAddress retAddr(nftJSON);
-        std::string contractAddrStr = uni_get_str(find_value(nftJSON, "contract"));
+        return std::make_pair(retAddr.contractID, retAddr.tokenID);
-        std::string TokenIDStr = uni_get_str(find_value(nftJSON, "tokenid"));
-
-        if (!(retContract = DecodeEthDestination(contractAddrStr)).IsNull() &&
-            TokenIDStr.length() == 66 &&
-            destStr.substr(0,2) == "0x" &&
-            IsHex(TokenIDStr.substr(2,64)))
-        {
-            retTokenID = uint256S(TokenIDStr.substr(2,64));
-            return std::make_pair(retContract, uint256S(TokenIDStr));
-        }
-        else
-        {
-            return std::make_pair(uint160(), uint256());
-        }
     }
 
     static std::string EncodeEthNFTDestination(const uint160 &ethContractID, const uint256 &tokenID)
@@ -364,35 +350,22 @@ public:
     UniValue ToUniValue() const;
 };
 
-class CNFTAddress
+class CETHNFTAddress
 {
 public:
-    uint32_t version;
+    uint160 contractID;
-    CTransferDestination rootContractOrID;
+    uint256 tokenID;
-    std::vector<uint160> shortHashes;
-    std::vector<uint256> longHashes;
-
-    enum EVersions {
-        VERSION_INVALID = 0,
-        VERSION_VERUSID = 1,
-        VERSION_FIRST = 1,
-        VERSION_DEFAULT = 1,
-        VERSION_LAST = 1
-    };
 
-    CNFTAddress(const UniValue &uni);
+    CETHNFTAddress() {}
-    CNFTAddress(uint32_t ver=VERSION_DEFAULT) : version(ver) {}
+    CETHNFTAddress(const UniValue &uni);
-    CNFTAddress(const CTransferDestination &rootDest, const std::vector<uint160> &shorts, const std::vector<uint256> &longs, uint32_t ver=VERSION_DEFAULT) : 
+    CETHNFTAddress(const uint160 &contract, const uint256 &token) : contractID(contract), tokenID(token) {}
-        version(ver), rootContractOrID(rootDest), shortHashes(shorts), longHashes(longs) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(VARINT(version));
+        READWRITE(contractID);
-        READWRITE(rootContractOrID);
+        READWRITE(tokenID);
-        READWRITE(shortHashes);
-        READWRITE(longHashes);
     }
 
     UniValue ToUniValue() const;