diff --git a/src/blind.cpp b/src/blind.cpp
index 0afc87bd88..866e02aef3 100644
--- a/src/blind.cpp
+++ b/src/blind.cpp
@@ -53,7 +53,7 @@ bool UnblindOutput(const CKey &key, const CTxOut& txout, CAmount& amount_out, ui
         return false;
 
     secp256k1_generator gen;
-    if (secp256k1_generator_parse(secp256k1_blind_context, &gen, &txout.nAsset.vchAssetTag[0]) != 1)
+    if (secp256k1_generator_parse(secp256k1_blind_context, &gen, &txout.nAsset.vchCommitment[0]) != 1)
         return false;
     if (secp256k1_pedersen_commitment_parse(secp256k1_blind_context, &commit, &txout.nValue.vchCommitment[0]) != 1)
         return false;
@@ -137,7 +137,7 @@ int BlindOutputs(std::vector<uint256 >& input_blinding_factors, const std::vecto
             //Assert-check surjective proofs
             secp256k1_generator gen;
             secp256k1_surjectionproof proof;
-            assert(secp256k1_generator_parse(secp256k1_blind_context, &gen, &out.nAsset.vchAssetTag[0]) == 1);
+            assert(secp256k1_generator_parse(secp256k1_blind_context, &gen, &out.nAsset.vchCommitment[0]) == 1);
             assert(secp256k1_surjectionproof_parse(secp256k1_blind_context, &proof, &out.nAsset.vchSurjectionproof[0], out.nAsset.vchSurjectionproof.size()) == 1);
             assert(secp256k1_surjectionproof_verify(secp256k1_blind_context, &proof, &inputAssetGenerators[0], inputAssetGenerators.size(), &gen) == 1);
          } else {
@@ -203,7 +203,7 @@ int BlindOutputs(std::vector<uint256 >& input_blinding_factors, const std::vecto
             //Blind the asset ID
             ret = secp256k1_generator_generate_blinded(secp256k1_blind_context, &gen, assetID.begin(), assetblindptrs[assetblindptrs.size()-1]);
             assert(ret == 1);
-            ret = secp256k1_generator_serialize(secp256k1_blind_context, &asset.vchAssetTag[0], &gen);
+            ret = secp256k1_generator_serialize(secp256k1_blind_context, &asset.vchCommitment[0], &gen);
             assert(ret != 0);
 
             // Create value commitment
diff --git a/src/primitives/transaction.cpp b/src/primitives/transaction.cpp
index 2e3de70ba5..77bad4050d 100644
--- a/src/primitives/transaction.cpp
+++ b/src/primitives/transaction.cpp
@@ -11,15 +11,15 @@
 
 void CTxOutAsset::SetNull()
 {
-    vchAssetTag.clear();
+    vchCommitment.clear();
     vchSurjectionproof.clear();
 }
 
 void CTxOutAsset::SetToAsset(const CAsset& asset)
 {
-    vchAssetTag.reserve(nAssetTagSize);
-    vchAssetTag.push_back(1);
-    vchAssetTag.insert(vchAssetTag.end(), asset.begin(), asset.end());
+    vchCommitment.reserve(nCommittedSize);
+    vchCommitment.push_back(1);
+    vchCommitment.insert(vchCommitment.end(), asset.begin(), asset.end());
     vchSurjectionproof.clear();
 }
 
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 7f273f9b25..8f2ddca877 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -20,14 +20,14 @@ static const CFeeRate withdrawLockTxFee = CFeeRate(5460);
 class CTxOutAsset
 {
 public:
-    static const size_t nAssetTagSize = 33;
+    static const size_t nCommittedSize = 33;
 
-    std::vector<unsigned char> vchAssetTag;
+    std::vector<unsigned char> vchCommitment;
     std::vector<unsigned char> vchSurjectionproof;
 
     CTxOutAsset()
     {
-        vchAssetTag.reserve(nAssetTagSize);
+        vchCommitment.reserve(nCommittedSize);
         SetNull();
     }
 
@@ -40,13 +40,13 @@ public:
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        unsigned char version = vchAssetTag.empty()? 0: vchAssetTag[0];
+        unsigned char version = vchCommitment.empty()? 0: vchCommitment[0];
         READWRITE(version);
         if (ser_action.ForRead()) {
             switch (version) {
                 /* Null */
                 case 0:
-                    vchAssetTag.clear();
+                    vchCommitment.clear();
                     return;
                 /* Explicit asset */
                 case 1:
@@ -55,43 +55,43 @@ public:
                 /* Confidential asset */
                 case 10:
                 case 11:
-                    vchAssetTag.resize(nAssetTagSize);
+                    vchCommitment.resize(nCommittedSize);
                     break;
                 default:
                     throw std::ios_base::failure("Unrecognized serialization prefix");
             }
-            vchAssetTag[0] = version;
+            vchCommitment[0] = version;
         }
-        if (vchAssetTag.size() > 1)
-            READWRITE(REF(CFlatData(&vchAssetTag[1], &vchAssetTag[vchAssetTag.size()])));
+        if (vchCommitment.size() > 1)
+            READWRITE(REF(CFlatData(&vchCommitment[1], &vchCommitment[vchCommitment.size()])));
         // The surjection proof is serialized as part of the witness data
     }
 
     bool IsNull() const
     {
-        return vchAssetTag.empty();
+        return vchCommitment.empty();
     }
 
     void SetNull();
 
     bool IsExplicit() const
     {
-        return vchAssetTag.size()==nAssetTagSize && vchAssetTag[0]==1;
+        return vchCommitment.size()==nCommittedSize && vchCommitment[0]==1;
     }
     const CAsset& GetAsset() const
     {
         assert(IsExplicit());
-        return *reinterpret_cast<const CAsset*>(&vchAssetTag[1]);
+        return *reinterpret_cast<const CAsset*>(&vchCommitment[1]);
     }
 
     bool IsCommitment() const
     {
-        return vchAssetTag.size()==nAssetTagSize && (vchAssetTag[0]==10 || vchAssetTag[0]==11);
+        return vchCommitment.size()==nCommittedSize && (vchCommitment[0]==10 || vchCommitment[0]==11);
     }
 
     friend bool operator==(const CTxOutAsset& a, const CTxOutAsset& b)
     {
-        return (a.vchAssetTag        == b.vchAssetTag &&
+        return (a.vchCommitment      == b.vchCommitment &&
                 a.vchSurjectionproof == b.vchSurjectionproof);
     }
 
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 991012cf0b..bd32f058dc 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -148,7 +148,7 @@ void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
             out.push_back(Pair("asset", asset.GetAsset().GetHex()));
         }
         else if (asset.IsCommitment()) {
-            out.push_back(Pair("assettag", HexStr(asset.vchAssetTag)));
+            out.push_back(Pair("assettag", HexStr(asset.vchCommitment)));
         }
 
         {
diff --git a/src/script/sigcache.cpp b/src/script/sigcache.cpp
index d6c6ec2149..07f03378ce 100644
--- a/src/script/sigcache.cpp
+++ b/src/script/sigcache.cpp
@@ -143,9 +143,9 @@ bool CachingTransactionSignatureChecker::VerifySignature(const std::vector<unsig
     return true;
 }
 
-bool CachingRangeProofChecker::VerifyRangeProof(const std::vector<unsigned char>& vchRangeProof, const std::vector<unsigned char>& vchCommitment, const std::vector<unsigned char>& vchAssetTag, const CScript& scriptPubKey, const secp256k1_context* secp256k1_ctx_verify_amounts) const
+bool CachingRangeProofChecker::VerifyRangeProof(const std::vector<unsigned char>& vchRangeProof, const std::vector<unsigned char>& vchValueCommitment, const std::vector<unsigned char>& vchAssetCommitment, const CScript& scriptPubKey, const secp256k1_context* secp256k1_ctx_verify_amounts) const
 {
-    CPubKey pubkey(vchCommitment);
+    CPubKey pubkey(vchValueCommitment);
     uint256 entry;
     rangeProofCache.ComputeEntry(entry, uint256(), vchRangeProof, pubkey);
 
@@ -155,11 +155,11 @@ bool CachingRangeProofChecker::VerifyRangeProof(const std::vector<unsigned char>
 
     uint64_t min_value, max_value;
     secp256k1_pedersen_commitment commit;
-    if (secp256k1_pedersen_commitment_parse(secp256k1_ctx_verify_amounts, &commit, &vchCommitment[0]) != 1)
+    if (secp256k1_pedersen_commitment_parse(secp256k1_ctx_verify_amounts, &commit, &vchValueCommitment[0]) != 1)
             return false;
 
     secp256k1_generator tag;
-    if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &tag, &vchAssetTag[0]) != 1)
+    if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &tag, &vchAssetCommitment[0]) != 1)
         return false;
 
     if (!secp256k1_rangeproof_verify(secp256k1_ctx_verify_amounts, &min_value, &max_value, &commit, vchRangeProof.data(), vchRangeProof.size(), scriptPubKey.size() ? &scriptPubKey.front() : NULL, scriptPubKey.size(), &tag)) {
diff --git a/src/script/sigcache.h b/src/script/sigcache.h
index a7c700f748..5a35880f7c 100644
--- a/src/script/sigcache.h
+++ b/src/script/sigcache.h
@@ -42,7 +42,7 @@ public:
         store = storeIn;
     };
 
-    bool VerifyRangeProof(const std::vector<unsigned char>& vchRangeProof, const std::vector<unsigned char>& vchCommitment, const std::vector<unsigned char>& vchAssetTag, const CScript& scriptPubKey, const secp256k1_context* ctx) const;
+    bool VerifyRangeProof(const std::vector<unsigned char>& vchRangeProof, const std::vector<unsigned char>& vchValueCommitment, const std::vector<unsigned char>& vchAssetCommitment, const CScript& scriptPubKey, const secp256k1_context* ctx) const;
 
 };
 
diff --git a/src/validation.cpp b/src/validation.cpp
index f2112ffaa1..85639db06e 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -633,7 +633,7 @@ bool CRangeCheck::operator()()
         return true;
     }
 
-    return CachingRangeProofChecker(store).VerifyRangeProof(val->vchRangeproof, val->vchCommitment, asset->vchAssetTag, *scriptPubKey, secp256k1_ctx_verify_amounts);
+    return CachingRangeProofChecker(store).VerifyRangeProof(val->vchRangeproof, val->vchCommitment, asset->vchCommitment, *scriptPubKey, secp256k1_ctx_verify_amounts);
 };
 
 bool CBalanceCheck::operator()()
@@ -688,7 +688,7 @@ bool VerifyAmounts(const CCoinsViewCache& cache, const CTransaction& tx, std::ve
                 assert(ret != 0);
             }
             else if (asset.IsCommitment()) {
-                if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchAssetTag[0]) != 1)
+                if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchCommitment[0]) != 1)
                     return false;
             }
             else {
@@ -731,7 +731,7 @@ bool VerifyAmounts(const CCoinsViewCache& cache, const CTransaction& tx, std::ve
             assert(ret != 0);
         }
         else if (asset.IsCommitment()) {
-            if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchAssetTag[0]) != 1)
+            if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchCommitment[0]) != 1)
                 return false;
         }
         else {
@@ -788,7 +788,7 @@ bool VerifyAmounts(const CCoinsViewCache& cache, const CTransaction& tx, std::ve
             assert(ret != 0);
         }
         else {
-            if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &ephemeral_input_tags[i], &asset.vchAssetTag[0]) != 1)
+            if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &ephemeral_input_tags[i], &asset.vchCommitment[0]) != 1)
                 return false;
         }
     }
@@ -803,7 +803,7 @@ bool VerifyAmounts(const CCoinsViewCache& cache, const CTransaction& tx, std::ve
             assert(asset.vchSurjectionproof.size() == 0);
             continue;
         }
-        if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchAssetTag[0]) != 1)
+        if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchCommitment[0]) != 1)
                 return false;
 
         secp256k1_surjectionproof proof;