Change CFT ID to 192 bits

src/ripple/app/tx/impl/CFTokenIssuanceCreate.cpp

@@ -22,6 +22,7 @@
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/TxFlags.h>
 #include <ripple/protocol/st.h>
+#include <ripple/protocol/cft.h>
 
 namespace ripple {
 
@@ -68,24 +69,25 @@ CFTokenIssuanceCreate::doApply()
     if (mPriorBalance < view().fees().accountReserve((*acct)[sfOwnerCount] + 1))
         return tecINSUFFICIENT_RESERVE;
 
-    auto const cftIssuanceID =
-        keylet::cftIssuance(account_, ctx_.tx.getSeqProxy().value());
+    auto const cftIssuanceID = cft::createCFTokenIssuanceID(ctx_.tx.getSeqProxy().value(), account_);
+    auto const cftIssuanceKeylet = keylet::cftIssuance(cftIssuanceID);
 
     // create the CFTokenIssuance
     {
         auto const ownerNode = view().dirInsert(
             keylet::ownerDir(account_),
-            cftIssuanceID,
+            cftIssuanceKeylet,
             describeOwnerDir(account_));
 
         if (!ownerNode)
             return tecDIR_FULL;
 
-        auto cftIssuance = std::make_shared<SLE>(cftIssuanceID);
+        auto cftIssuance = std::make_shared<SLE>(cftIssuanceKeylet);
         (*cftIssuance)[sfFlags] = ctx_.tx.getFlags() & ~tfUniversal;
         (*cftIssuance)[sfIssuer] = account_;
         (*cftIssuance)[sfOutstandingAmount] = 0;
         (*cftIssuance)[sfOwnerNode] = *ownerNode;
+        (*cftIssuance)[sfSequence] = ctx_.tx.getSeqProxy().value();
 
         if (auto const max = ctx_.tx[~sfMaximumAmount])
             (*cftIssuance)[sfMaximumAmount] = *max;

src/ripple/basics/base_uint.h

@@ -547,6 +547,7 @@ class base_uint
 
 using uint128 = base_uint<128>;
 using uint160 = base_uint<160>;
+using uint192 = base_uint<192>;
 using uint256 = base_uint<256>;
 
 template <std::size_t Bits, class Tag>

src/ripple/protocol/Indexes.h

@@ -284,19 +284,13 @@ Keylet
 did(AccountID const& account) noexcept;
 
 Keylet
-cftIssuance(AccountID const& issuer, std::uint32_t seq) noexcept;
-
-inline Keylet
-cftIssuance(uint256 const& issuance)
-{
-    return {ltCFTOKEN_ISSUANCE, issuance};
-}
+cftIssuance(uint192 const& issuanceID) noexcept;
 
 Keylet
-cftoken(uint256 const& issuanceID, AccountID const& holder) noexcept;
+cftoken(uint192 const& issuanceID, AccountID const& holder) noexcept;
 
 Keylet
-cft_dir(uint256 const& id) noexcept;
+cft_dir(uint192 const& issuanceID) noexcept;
 }  // namespace keylet
 
 // Everything below is deprecated and should be removed in favor of keylets:

src/ripple/protocol/SField.h

@@ -475,6 +475,9 @@ extern SF_UINT160 const sfTakerPaysIssuer;
 extern SF_UINT160 const sfTakerGetsCurrency;
 extern SF_UINT160 const sfTakerGetsIssuer;
 
+// 192-bit (common)
+extern SF_UINT192 const sfCFTokenIssuanceID;
+
 // 256-bit (common)
 extern SF_UINT256 const sfLedgerHash;
 extern SF_UINT256 const sfParentHash;
@@ -490,7 +493,6 @@ extern SF_UINT256 const sfEmitParentTxnID;
 extern SF_UINT256 const sfEmitNonce;
 extern SF_UINT256 const sfEmitHookHash;
 extern SF_UINT256 const sfAMMID;
-extern SF_UINT256 const sfCFTokenIssuanceID;
 
 // 256-bit (uncommon)
 extern SF_UINT256 const sfBookDirectory;

src/ripple/protocol/STBitString.h

@@ -83,6 +83,7 @@ class STBitString final : public STBase
 
 using STUInt128 = STBitString<128>;
 using STUInt160 = STBitString<160>;
+using STUInt192 = STBitString<192>;
 using STUInt256 = STBitString<256>;
 
 template <int Bits>
@@ -135,6 +136,13 @@ STUInt160::getSType() const
     return STI_UINT160;
 }
 
+template <>
+inline SerializedTypeID
+STUInt192::getSType() const
+{
+    return STI_UINT192;
+}
+
 template <>
 inline SerializedTypeID
 STUInt256::getSType() const

src/ripple/protocol/STObject.h

@@ -222,6 +222,8 @@ class STObject : public STBase, public CountedObject<STObject>
 
     uint160
     getFieldH160(SField const& field) const;
+    uint192
+    getFieldH192(SField const& field) const;
     uint256
     getFieldH256(SField const& field) const;
     AccountID
@@ -352,6 +354,8 @@ class STObject : public STBase, public CountedObject<STObject>
     void
     setFieldH128(SField const& field, uint128 const&);
     void
+    setFieldH192(SField const& field, uint192 const&);
+    void
     setFieldH256(SField const& field, uint256 const&);
     void
     setFieldVL(SField const& field, Blob const&);

src/ripple/protocol/cft.h

@@ -0,0 +1,68 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2023 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_PROTOCOL_CFT_H_INCLUDED
+#define RIPPLE_PROTOCOL_CFT_H_INCLUDED
+
+#include <ripple/basics/base_uint.h>
+#include <string_view>
+
+namespace ripple {
+namespace cft {
+
+inline std::uint32_t
+getSequence(uint192 const& issuanceID)
+{
+    std::uint32_t seq;
+    memcpy(&seq, issuanceID.begin(), 4);
+    return boost::endian::big_to_native(seq);
+}
+
+inline AccountID
+getIssuer(uint192 const& issuanceID)
+{
+    return AccountID::fromVoid(issuanceID.data() + 4);
+}
+
+
+inline uint192
+createCFTokenIssuanceID(
+    std::uint32_t sequence,
+    AccountID const& issuer)
+{
+    sequence = boost::endian::native_to_big(sequence);
+
+    std::array<std::uint8_t, 24> buf{};
+
+    auto ptr = buf.data();
+
+    std::memcpy(ptr, &sequence, sizeof(sequence));
+    ptr += sizeof(sequence);
+
+    std::memcpy(ptr, issuer.data(), issuer.size());
+    ptr += issuer.size();
+    assert(std::distance(buf.data(), ptr) == buf.size());
+
+    return uint192::fromVoid(buf.data());
+}
+
+}  // namespace cft
+}  // namespace ripple
+
+#endif

src/ripple/protocol/impl/Indexes.cpp

@@ -24,6 +24,7 @@
 #include <ripple/protocol/SeqProxy.h>
 #include <ripple/protocol/digest.h>
 #include <ripple/protocol/nftPageMask.h>
+#include <ripple/protocol/cft.h>
 
 #include <algorithm>
 #include <cassert>
@@ -448,23 +449,25 @@ did(AccountID const& account) noexcept
 }
 
 Keylet
-cftIssuance(AccountID const& issuer, std::uint32_t seq) noexcept
+cftIssuance(uint192 const& issuanceID) noexcept
 {
+    uint32_t const sequence = cft::getSequence(issuanceID);
+    AccountID const issuer = cft::getIssuer(issuanceID);
     return {
         ltCFTOKEN_ISSUANCE,
-        indexHash(LedgerNameSpace::CFTOKEN_ISSUANCE, issuer, seq)};
+        indexHash(LedgerNameSpace::CFTOKEN_ISSUANCE, sequence, issuer)};
 }
 
 Keylet
-cftoken(uint256 const& issuanceID, AccountID const& holder) noexcept
+cftoken(uint192 const& issuanceID, AccountID const& holder) noexcept
 {
     return {ltCFTOKEN, indexHash(LedgerNameSpace::CFTOKEN, issuanceID, holder)};
 }
 
 Keylet
-cft_dir(uint256 const& id) noexcept
+cft_dir(uint192 const& issuanceID) noexcept
 {
-    return {ltDIR_NODE, indexHash(LedgerNameSpace::CFT_DIR, id)};
+    return {ltDIR_NODE, indexHash(LedgerNameSpace::CFT_DIR, issuanceID)};
 }
 }  // namespace keylet
 

src/ripple/protocol/impl/LedgerFormats.cpp

@@ -345,6 +345,7 @@ LedgerFormats::LedgerFormats()
         ltCFTOKEN_ISSUANCE,
         {
             {sfIssuer,               soeREQUIRED},
+            {sfSequence,             soeREQUIRED},
             {sfTransferFee,          soeDEFAULT},
             {sfOwnerNode,            soeREQUIRED},
             {sfAssetScale,           soeDEFAULT},

src/ripple/protocol/impl/SField.cpp

@@ -204,6 +204,9 @@ CONSTRUCT_TYPED_SFIELD(sfTakerPaysIssuer,       "TakerPaysIssuer",      UINT160,
 CONSTRUCT_TYPED_SFIELD(sfTakerGetsCurrency,     "TakerGetsCurrency",    UINT160,    3);
 CONSTRUCT_TYPED_SFIELD(sfTakerGetsIssuer,       "TakerGetsIssuer",      UINT160,    4);
 
+// 192-bit (common)
+CONSTRUCT_TYPED_SFIELD(sfCFTokenIssuanceID,     "CFTokenIssuanceID",    UINT192,    1);
+
 // 256-bit (common)
 CONSTRUCT_TYPED_SFIELD(sfLedgerHash,            "LedgerHash",           UINT256,    1);
 CONSTRUCT_TYPED_SFIELD(sfParentHash,            "ParentHash",           UINT256,    2);
@@ -219,7 +222,6 @@ CONSTRUCT_TYPED_SFIELD(sfEmitParentTxnID,       "EmitParentTxnID",      UINT256,
 CONSTRUCT_TYPED_SFIELD(sfEmitNonce,             "EmitNonce",            UINT256,   12);
 CONSTRUCT_TYPED_SFIELD(sfEmitHookHash,          "EmitHookHash",         UINT256,   13);
 CONSTRUCT_TYPED_SFIELD(sfAMMID,                 "AMMID",                UINT256,   14);
-CONSTRUCT_TYPED_SFIELD(sfCFTokenIssuanceID,     "CFTokenIssuanceID",    UINT256,   15);
 
 // 256-bit (uncommon)
 CONSTRUCT_TYPED_SFIELD(sfBookDirectory,         "BookDirectory",        UINT256,   16);

src/ripple/protocol/impl/STObject.cpp

@@ -579,6 +579,12 @@ STObject::getFieldH160(SField const& field) const
     return getFieldByValue<STUInt160>(field);
 }
 
+uint192
+STObject::getFieldH192(SField const& field) const
+{
+    return getFieldByValue<STUInt192>(field);
+}
+
 uint256
 STObject::getFieldH256(SField const& field) const
 {
@@ -673,6 +679,12 @@ STObject::setFieldH128(SField const& field, uint128 const& v)
     setFieldUsingSetValue<STUInt128>(field, v);
 }
 
+void
+STObject::setFieldH192(SField const& field, uint192 const& v)
+{
+    setFieldUsingSetValue<STUInt192>(field, v);
+}
+
 void
 STObject::setFieldH256(SField const& field, uint256 const& v)
 {

src/ripple/protocol/impl/STParsedJSON.cpp

@@ -478,6 +478,30 @@ parseLeaf(
             break;
         }
 
+        case STI_UINT192: {
+            if (!value.isString())
+            {
+                error = bad_type(json_name, fieldName);
+                return ret;
+            }
+
+            uint192 num;
+
+            if (auto const s = value.asString(); !num.parseHex(s))
+            {
+                if (!s.empty())
+                {
+                    error = invalid_data(json_name, fieldName);
+                    return ret;
+                }
+
+                num.zero();
+            }
+
+            ret = detail::make_stvar<STUInt192>(field, num);
+            break;
+        }
+
         case STI_UINT256: {
             if (!value.isString())
             {

src/ripple/protocol/impl/STVar.cpp

@@ -140,6 +140,9 @@ STVar::STVar(SerialIter& sit, SField const& name, int depth)
         case STI_UINT160:
             construct<STUInt160>(sit, name);
             return;
+        case STI_UINT192:
+            construct<STUInt192>(sit, name);
+            return;
         case STI_UINT256:
             construct<STUInt256>(sit, name);
             return;
@@ -201,6 +204,9 @@ STVar::STVar(SerializedTypeID id, SField const& name)
         case STI_UINT160:
             construct<STUInt160>(name);
             return;
+        case STI_UINT192:
+            construct<STUInt192>(name);
+            return;
         case STI_UINT256:
             construct<STUInt256>(name);
             return;