diff --git a/src/blockchain_db/blockchain_db.cpp b/src/blockchain_db/blockchain_db.cpp
index e35b2a62c..a4297e0e7 100644
--- a/src/blockchain_db/blockchain_db.cpp
+++ b/src/blockchain_db/blockchain_db.cpp
@@ -294,7 +294,22 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
   time1 = epee::misc_utils::get_tick_count();
 
   uint64_t num_rct_outs = 0;
-  oracle::asset_type_counts num_rct_outs_by_asset_type;
+  oracle::asset_type_counts_v2 num_rct_outs_by_asset_type;
+  
+  // add newly created tokens
+  for (const std::pair<transaction, blobdata>& tx : txs)
+  {
+    if (tx.first.type == cryptonote::transaction_type::CREATE_TOKEN)
+    {
+      uint32_t asset_type_id = cryptonote::asset_id_from_type("sal" + tx.first.token_metadata.asset_type);
+      if (!num_rct_outs_by_asset_type.add_asset_type(asset_type_id))
+        throw std::runtime_error("Failed to add asset_type 'sal" + tx.first.token_metadata.asset_type + "'");
+    }
+
+    if (!is_tx_paid_for(tx.first))
+      throw std::runtime_error("TX is not paid for");
+  }
+  
   blobdata miner_bd = tx_to_blob(blk.miner_tx);
   add_transaction(blk_hash, std::make_pair(blk.miner_tx, blobdata_ref(miner_bd)));
   blobdata protocol_bd = tx_to_blob(blk.protocol_tx);
@@ -309,12 +324,14 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
       std::string asset_type;
       if (!get_output_asset_type(vout, asset_type))
         throw std::runtime_error("Failed to get output asset type");
-      num_rct_outs_by_asset_type.add(asset_type, 1);
+      uint32_t asset_type_id = cryptonote::asset_id_from_type(asset_type);
+      num_rct_outs_by_asset_type.add_asset_type(asset_type_id);
+      num_rct_outs_by_asset_type.add(asset_type_id, 1);
     }
   }
 
   std::map<std::string, int64_t> slippage_counts;
-  uint64_t audit_total = 0, yield_total = 0;
+  uint64_t audit_total = 0, token_total = 0, yield_total = 0;
   if (blk.protocol_tx.version >= 2)
   {
     num_rct_outs += blk.protocol_tx.vout.size();
@@ -326,10 +343,12 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
       std::string asset_type;
       if (!get_output_asset_type(vout, asset_type))
         throw std::runtime_error("Failed to get output asset type");
+      uint32_t asset_type_id = cryptonote::asset_id_from_type(asset_type);
+      
+      // Update the RCT outs for the asset_type
+      num_rct_outs_by_asset_type.add_asset_type(asset_type_id);
+      num_rct_outs_by_asset_type.add(asset_type_id, 1);
       
-      // Update the RCT outs
-      num_rct_outs_by_asset_type.add(asset_type, 1);
-
       // Update the amount tallies by DEDUCTING the minted amount
       if (slippage_counts.count(asset_type) == 0)
         slippage_counts[asset_type] = 0;
@@ -350,7 +369,9 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
         throw std::runtime_error("Failed to get output asset type");
       if (vout.amount == 0) {
         ++num_rct_outs;
-        num_rct_outs_by_asset_type.add(asset_type, 1);
+        uint32_t asset_type_id = cryptonote::asset_id_from_type(asset_type);
+        num_rct_outs_by_asset_type.add_asset_type(asset_type_id);
+        num_rct_outs_by_asset_type.add(asset_type_id, 1);
       }
 
       // Is this a CONVERT TX?
@@ -367,6 +388,16 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
       audit_total += tx.first.amount_burnt;
     }
     
+    // Is this an create_token TX?
+    if (tx.first.type == cryptonote::transaction_type::CREATE_TOKEN) {
+      token_total += tx.first.amount_burnt;
+      /*
+      uint32_t asset_type_id = cryptonote::asset_id_from_type(tx.first.token_metadata.asset_type);
+      if (!num_rct_outs_by_asset_type.add_asset_type(asset_type_id))
+        throw std::runtime_error("Failed to add asset_type '" + tx.first.token_metadata.asset_type + "' to RCT outputs");
+      */
+    }
+    
     // Is this a STAKE TX?
     if (tx.first.type == cryptonote::transaction_type::STAKE) {
       yield_total += tx.first.amount_burnt;
@@ -420,7 +451,7 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
 
   // call out to subclass implementation to add the block & metadata
   time1 = epee::misc_utils::get_tick_count();
-  add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, num_rct_outs, num_rct_outs_by_asset_type, blk_hash, slippage_total, yield_total, audit_total, nettype, ybi, abi);
+  add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, num_rct_outs, num_rct_outs_by_asset_type, blk_hash, slippage_total, yield_total, audit_total, token_total, nettype, ybi, abi);
   TIME_MEASURE_FINISH(time1);
   time_add_block1 += time1;
 
diff --git a/src/blockchain_db/blockchain_db.h b/src/blockchain_db/blockchain_db.h
index 2da1559f4..28916fe03 100644
--- a/src/blockchain_db/blockchain_db.h
+++ b/src/blockchain_db/blockchain_db.h
@@ -218,6 +218,18 @@ typedef struct yield_tx_info_carrot {
   carrot::encrypted_janus_anchor_t return_anchor_enc;
 } yield_tx_info_carrot;
 
+typedef struct token_tx_info_carrot {
+  uint64_t block_height;
+  uint8_t version;
+  crypto::hash tx_hash;
+  uint64_t locked_coins;
+  crypto::public_key return_address;
+  crypto::public_key return_pubkey;
+  carrot::view_tag_t return_view_tag;
+  carrot::encrypted_janus_anchor_t return_anchor_enc;
+  uint32_t asset_type_id;
+} token_tx_info_carrot;
+
 #define DBF_SAFE       1
 #define DBF_FAST       2
 #define DBF_FASTEST    4
@@ -437,11 +449,12 @@ private:
                           const difficulty_type& cumulative_difficulty,
                           const uint64_t& coins_generated,
                           uint64_t num_rct_outs,
-                          oracle::asset_type_counts& cum_rct_by_asset_type,
+                          oracle::asset_type_counts_v2& cum_rct_by_asset_type,
                           const crypto::hash& blk_hash,
                           uint64_t slippage_total,
                           uint64_t yield_total,
                           uint64_t audit_total,
+                          uint64_t token_total,
                           const cryptonote::network_type nettype,
                           cryptonote::yield_block_info& ybi,
                           cryptonote::audit_block_info& abi
@@ -1212,6 +1225,20 @@ public:
   virtual std::map<std::string, uint64_t> get_circulating_supply() const = 0;
   
 
+  /**
+   * @brief fetch the tokens from the blockchain
+   *
+   * @return the current token values
+   */
+  virtual std::map<std::string, cryptonote::token_metadata_t> get_tokens() const = 0;
+
+  /**
+   * @brief determine if a TX has been paid for
+   *
+   * @return the current token values
+   */
+  virtual bool is_tx_paid_for(const cryptonote::transaction& tx) const = 0;
+
   /**
    * <!--
    * TODO: Rewrite (if necessary) such that all calls to remove_* are
@@ -1937,6 +1964,8 @@ public:
 
   virtual int get_carrot_yield_tx_info(const uint64_t height, std::vector<yield_tx_info_carrot>& yti_container) const = 0;
 
+  virtual int get_token_tx_info(const uint64_t height, std::vector<token_tx_info_carrot>& tti_container) const = 0;
+
   
   /**
    * @brief set whether or not to automatically remove logs
diff --git a/src/blockchain_db/lmdb/db_lmdb.cpp b/src/blockchain_db/lmdb/db_lmdb.cpp
index 17f29c512..5f84ef2d4 100644
--- a/src/blockchain_db/lmdb/db_lmdb.cpp
+++ b/src/blockchain_db/lmdb/db_lmdb.cpp
@@ -64,7 +64,7 @@ using epee::string_tools::pod_to_hex;
 using namespace crypto;
 
 // Increase when the DB structure changes
-#define VERSION 2
+#define VERSION 3
 
 namespace
 {
@@ -222,6 +222,12 @@ namespace
  * audit_block_data block height {locked_coins, lc_total}
  * audit_tx_data    block height {txn hash, locked_coins, return_address}
  *
+ * token_tx_data    block height {txn hash, asset_type, supply, return_address}
+ *
+ * rct_count_info   block height {serialised RCT asset counts}
+ *
+ * rollup_tx_info   rollup_tag   {serialised rollup_tx_data_t struct}
+ *
  * Note: where the data items are of uniform size, DUPFIXED tables have
  * been used to save space. In most of these cases, a dummy "zerokval"
  * key is used when accessing the table; the Key listed above will be
@@ -300,6 +306,14 @@ const char* const LMDB_AUDIT_TXS = "audit_txs";
 const char* const LMDB_AUDIT_BLOCKS = "audit_blocks";
 const char* const LMDB_CARROT_YIELD_TXS = "carrot_yield_txs";
 
+const char* const LMDB_TOKEN_TXS = "token_txs";
+
+const char* const LMDB_TOKENS = "tokens";
+
+const char* const LMDB_RCT_COUNT_INFO = "rct_count_info";
+
+const char* const LMDB_ROLLUP_TX_INFO = "rollup_tx_info";
+
 const char zerokey[8] = {0};
 const MDB_val zerokval = { sizeof(zerokey), (void *)zerokey };
 
@@ -357,7 +371,21 @@ typedef struct mdb_block_info_1
   oracle::asset_type_counts bi_cum_rct_by_asset_type;
 } mdb_block_info_1;
 
-typedef mdb_block_info_1 mdb_block_info;
+typedef struct mdb_block_info_2
+{
+  uint64_t bi_height;
+  uint64_t bi_timestamp;
+  uint64_t bi_coins;
+  uint64_t bi_weight; // a size_t really but we need 32-bit compat
+  uint64_t bi_diff_lo;
+  uint64_t bi_diff_hi;
+  crypto::hash bi_hash;
+  uint64_t bi_cum_rct;
+  uint64_t bi_long_term_block_weight;
+  oracle::pricing_record bi_pricing_record;
+} mdb_block_info_2;
+
+typedef mdb_block_info_2 mdb_block_info;
 
 typedef struct blk_height {
     crypto::hash bh_hash;
@@ -879,6 +907,44 @@ int BlockchainLMDB::get_audit_tx_info(const uint64_t height, std::vector<yield_t
   return 0;
 }
 
+int BlockchainLMDB::get_token_tx_info(const uint64_t height, std::vector<token_tx_info_carrot>& tti_container) const
+{
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+  check_open();
+
+  // Clear the container
+  tti_container.clear();
+
+  // Query for the (presumably matured) TOKEN_TX_INFO information
+  TXN_PREFIX_RDONLY();
+  RCURSOR(token_txs);
+  
+  MDB_val v;
+  MDB_val_set(k, height);
+  MDB_cursor_op op = MDB_SET;
+  while (1)
+  {
+    int ret = mdb_cursor_get(m_cur_token_txs, &k, &v, op);
+    op = MDB_NEXT_DUP;
+    if (ret == MDB_NOTFOUND)
+      break;
+    if (ret)
+      throw0(DB_ERROR(lmdb_error("Failed to enumerate audit TX info: ", ret).c_str()));
+
+    // Get the data
+    token_tx_info_carrot *p = (token_tx_info_carrot*)v.mv_data;
+    // Push result back into the container
+    tti_container.emplace_back(*p);
+    // Update the height retrospectively (because the DB stores the count of elements there to handle duplicates, because it's rubbish)
+    tti_container.back().block_height = height;
+  }
+
+  TXN_POSTFIX_RDONLY();
+
+  // Return success to caller
+  return 0;
+}
+
 int BlockchainLMDB::get_yield_block_info(const uint64_t height, yield_block_info& ybi) const
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@@ -985,7 +1051,21 @@ int BlockchainLMDB::get_carrot_yield_tx_info(const uint64_t height, std::vector<
   return 0;
 }
 
-void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t long_term_block_weight, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated, uint64_t num_rct_outs, oracle::asset_type_counts& cum_rct_by_asset_type, const crypto::hash& blk_hash, uint64_t slippage_total, uint64_t yield_total, uint64_t audit_total, const cryptonote::network_type nettype, cryptonote::yield_block_info& ybi, cryptonote::audit_block_info& abi)
+void BlockchainLMDB::add_block(const block& blk,
+                               size_t block_weight,
+                               uint64_t long_term_block_weight,
+                               const difficulty_type& cumulative_difficulty,
+                               const uint64_t& coins_generated,
+                               uint64_t num_rct_outs,
+                               oracle::asset_type_counts_v2& cum_rct_by_asset_type,
+                               const crypto::hash& blk_hash,
+                               uint64_t slippage_total,
+                               uint64_t yield_total,
+                               uint64_t audit_total,
+                               uint64_t token_total,
+                               const cryptonote::network_type nettype,
+                               cryptonote::yield_block_info& ybi,
+                               cryptonote::audit_block_info& abi)
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
   check_open();
@@ -1020,7 +1100,7 @@ void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t l
   abi.block_height = m_height;
   abi.locked_coins_this_block = audit_total;
 
-  // Put the YBI into the table
+  // Put the ABI into the table
   MDB_val_set(key, m_height);
   MDB_val_set(abi_val, abi);
   result = mdb_cursor_put(m_cur_audit_blocks, &key, &abi_val, MDB_APPEND);
@@ -1070,6 +1150,7 @@ void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t l
 
   CURSOR(blocks)
   CURSOR(block_info)
+  CURSOR(rct_count_info)
 
   // this call to mdb_cursor_put will change height()
   cryptonote::blobdata block_blob(block_to_blob(blk));
@@ -1088,6 +1169,7 @@ void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t l
   bi.bi_hash = blk_hash;
   bi.bi_cum_rct = num_rct_outs;
   bi.bi_pricing_record = blk.pricing_record;
+  
   if (m_height > 0)
   {
     uint64_t last_height = m_height-1;
@@ -1096,21 +1178,40 @@ void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t l
         throw1(BLOCK_DNE(lmdb_error("Failed to get block info: ", result).c_str()));
     const mdb_block_info *bi_prev = (const mdb_block_info*)h.mv_data;
     bi.bi_cum_rct += bi_prev->bi_cum_rct;
-    for (auto const& asset_type : oracle::ASSET_TYPES)
-      cum_rct_by_asset_type.add(asset_type, bi_prev->bi_cum_rct_by_asset_type[asset_type]);
+    
+    oracle::asset_type_counts_v2 cum_rct_counts_prev;
+    MDB_val_copy<uint64_t> key_prev_height(last_height);
+    MDB_val val_prev_counts;
+    if ((result = mdb_cursor_get(m_cur_rct_count_info, &key_prev_height, &val_prev_counts, MDB_SET)))
+      throw1(BLOCK_DNE(lmdb_error("Failed to get previous rct count info: ", result).c_str()));
+    cum_rct_counts_prev.deserialize((uint8_t*)val_prev_counts.mv_data, val_prev_counts.mv_size);
+    for (auto const& asset_type_id : cum_rct_counts_prev.get_asset_types()) {
+      if (!cum_rct_by_asset_type.has_asset_type(asset_type_id)) {
+        cum_rct_by_asset_type.add_asset_type(asset_type_id);
+      }
+      cum_rct_by_asset_type.add(asset_type_id, cum_rct_counts_prev[asset_type_id]);
+    }
   }
   bi.bi_long_term_block_weight = long_term_block_weight;
-  bi.bi_cum_rct_by_asset_type = cum_rct_by_asset_type;
 
   MDB_val_set(val, bi);
   result = mdb_cursor_put(m_cur_block_info, (MDB_val *)&zerokval, &val, MDB_APPENDDUP);
   if (result)
     throw0(DB_ERROR(lmdb_error("Failed to add block info to db transaction: ", result).c_str()));
-
+  
   result = mdb_cursor_put(m_cur_block_heights, (MDB_val *)&zerokval, &val_h, 0);
   if (result)
     throw0(DB_ERROR(lmdb_error("Failed to add block height by hash to db transaction: ", result).c_str()));
 
+  // Update the rct_count_info table
+  std::vector<uint8_t> serialized_counts = cum_rct_by_asset_type.serialize();
+  MDB_val_copy<uint64_t> key_height(m_height);
+  MDB_val_sized(val_counts, serialized_counts);
+  CURSOR(rct_count_info)
+  result = mdb_cursor_put(m_cur_rct_count_info, &key_height, &val_counts, 0);
+  if (result)
+    throw0(DB_ERROR(lmdb_error("Failed to add asset_type_counts to db transaction: ", result).c_str()));
+
   // we use weight as a proxy for size, since we don't have size but weight is >= size
   // and often actually equal
   m_cum_size += block_weight;
@@ -1135,6 +1236,8 @@ void BlockchainLMDB::remove_block()
   CURSOR(circ_supply_tally)
   CURSOR(yield_blocks)
   CURSOR(audit_blocks)
+  CURSOR(rct_count_info)
+
   MDB_val_copy<uint64_t> k(m_height - 1);
   MDB_val h = k;
   if ((result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &h, MDB_GET_BOTH)))
@@ -1157,7 +1260,6 @@ void BlockchainLMDB::remove_block()
       throw1(DB_ERROR(lmdb_error("Failed to add removal of block info to db transaction: ", result).c_str()));
 
   MDB_val_copy<uint64_t> k2(m_height - 1);
-  MDB_val v = k2;
   if ((result = mdb_cursor_get(m_cur_yield_blocks, &k2,  NULL, MDB_SET)))
       throw1(BLOCK_DNE(lmdb_error("Attempting to remove yield block info that's not in the db: ", result).c_str()));
   if ((result = mdb_cursor_del(m_cur_yield_blocks, 0)))
@@ -1167,6 +1269,11 @@ void BlockchainLMDB::remove_block()
   if ((result = mdb_cursor_get(m_cur_audit_blocks, &k2,  NULL, MDB_SET)) == 0)
     if ((result = mdb_cursor_del(m_cur_audit_blocks, 0)))
       throw1(DB_ERROR(lmdb_error("Failed to add removal of audit block info to db transaction: ", result).c_str()));
+
+  if ((result = mdb_cursor_get(m_cur_rct_count_info, &k2,  NULL, MDB_SET)))
+      throw1(BLOCK_DNE(lmdb_error("Attempting to remove rct count info that's not in the db: ", result).c_str()));
+  if ((result = mdb_cursor_del(m_cur_rct_count_info, 0)))
+      throw1(DB_ERROR(lmdb_error("Failed to add removal of rct count info to db transaction: ", result).c_str()));
 }
 
 boost::multiprecision::int128_t
@@ -1234,6 +1341,32 @@ void write_circulating_supply_data(MDB_cursor *cur_circ_supply_tally, MDB_val id
     throw0(DB_ERROR(lmdb_error("Failed to update tally for source circulating supply: ", result).c_str()));
 }
 
+inline std::string write_token_metadata(const cryptonote::token_metadata_t& token_metadata)
+{
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+  
+  std::stringstream token_blob_str;
+  binary_archive<true> ba(token_blob_str);
+  bool r = ::serialization::serialize(ba, const_cast<cryptonote::token_metadata_t&>(token_metadata));
+  if (!r)
+    throw0(DB_ERROR("Failed to serialize token_metadata"));
+  
+  return token_blob_str.str();
+}
+
+inline void read_token_metadata(const std::string& token_blob, cryptonote::token_metadata_t& token_metadata)
+{
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+  
+  if (token_blob.empty())
+    throw0(DB_ERROR("Empty token_blob provided to read_token_metadata"));
+  
+  binary_archive<false> ba{epee::strspan<std::uint8_t>(token_blob)};
+  bool r = ::serialization::serialize(ba, token_metadata);
+  if (!r)
+    throw0(DB_ERROR("Failed to deserialize token_metadata"));
+}
+
 uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, const std::pair<transaction, blobdata_ref>& txp, const crypto::hash& tx_hash, const crypto::hash& tx_prunable_hash, const bool miner_tx)
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@@ -1254,6 +1387,9 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
   CURSOR(yield_txs)
   CURSOR(audit_txs)
   CURSOR(carrot_yield_txs)
+  CURSOR(token_txs)
+  CURSOR(tokens)
+  CURSOR(rollup_tx_info)
 
   MDB_val_set(val_tx_id, tx_id);
   MDB_val_set(val_h, tx_hash);
@@ -1364,7 +1500,8 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
       tx.type == cryptonote::transaction_type::CONVERT ||
       tx.type == cryptonote::transaction_type::STAKE ||
       tx.type == cryptonote::transaction_type::AUDIT ||
-      tx.type == cryptonote::transaction_type::TRANSFER) 
+      tx.type == cryptonote::transaction_type::TRANSFER ||
+      tx.type == cryptonote::transaction_type::CREATE_TOKEN) 
   {
 
     // Get the current tally value for the source currency type
@@ -1395,7 +1532,7 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
   if (tx.type == cryptonote::transaction_type::PROTOCOL) {
 
     // Iterate over all of the outputs for a PROTOCOL_TX since they're all MINTED
-    std::map<uint32_t, uint64_t> minted_amounts;
+    std::map<uint32_t, uint64_t> minted_amounts; 
     for (const auto& out: tx.vout) {
 
       // Fetch the amount and output_asset_type for this output
@@ -1413,14 +1550,22 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
       MDB_val_copy<uint64_t> source_idx(asset.first);
       boost::multiprecision::int128_t source_tally = 0;
       result = read_circulating_supply_data(m_cur_circ_supply_tally, source_idx, source_tally);
-      if (result == MDB_NOTFOUND)
-        throw0(DB_ERROR("minted asset not found"));
+      if (result == MDB_NOTFOUND){
+        std::string asset_symbol = cryptonote::asset_type_from_id(asset.first);
+        if (asset.first == 0x53414C31 /*SAL1*/ || asset.first == 0x53414C00 /*SAL*/) {
+          throw0(DB_ERROR(("Asset " + asset_symbol + " not found when updating circulating supply for PROTOCOL_TX").c_str()));
+        }
+        else{
+          LOG_PRINT_L1("First time minting asset, ID: " << asset.first << " symbol: " << asset_symbol << " in tx_id: " << tx_id);
+        }
+      }
       else if (result)
         throw0(DB_ERROR(lmdb_error("Failed to get circulating supply tally when adding db transaction: ", result).c_str()));
       if (source_tally > source_tally + asset.second)
         throw0(DB_ERROR("add_transaction_data() - mint overflow"));
       boost::multiprecision::int128_t final_source_tally = source_tally + asset.second;
       write_circulating_supply_data(m_cur_circ_supply_tally, source_idx, final_source_tally);
+      // Log can be changed - not burning here
       LOG_PRINT_L1("tx ID " << tx_id << "\n\tAsset Type = " << cryptonote::asset_type_from_id(asset.first) << "\n\tTally before burn =" << source_tally.str() << "\n\tTally after burn =" << final_source_tally.str());
 
       MDB_val_copy<uint64_t> burn_idx(cryptonote::asset_id_from_type("BURN"));
@@ -1428,13 +1573,80 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
       result = read_circulating_supply_data(m_cur_circ_supply_tally, burn_idx, burn_tally);
       if (result && result != MDB_NOTFOUND)
         throw0(DB_ERROR(lmdb_error("Failed to get circulating supply tally when adding db transaction: ", result).c_str()));
-      if (burn_tally < asset.second)
+      uint64_t burn_amount = 0;
+      if (asset.first == 0x53414C00 || asset.first == 0x53414C31 || asset.first == 0x4255524E) { //BURN SAL and SAL1 // check
+        burn_amount = asset.second;
+      } else {
+        burn_amount = asset.second / 200;
+      }
+      if (burn_tally < burn_amount)
         throw0(DB_ERROR("add_transaction_data() - burn underflow"));
-      boost::multiprecision::int128_t final_burn_tally = burn_tally - asset.second;
+      boost::multiprecision::int128_t final_burn_tally = burn_tally - burn_amount;
       write_circulating_supply_data(m_cur_circ_supply_tally, burn_idx, final_burn_tally);
     }
   }
 
+  // Is there a rollup_tx to add?
+  if (tx.version >= TRANSACTION_VERSION_ENABLE_TOKENS &&
+      tx.type == cryptonote::transaction_type::ROLLUP &&
+      tx.layer2_rollup_data.txs.size())
+  {
+    // We already have the necessary values in the `layer2_rollup_data` member of the TX
+    for (const auto &rollup_tx: tx.layer2_rollup_data.txs) {
+      MDB_val_set(rtx_key, tx.rollup_binding_tag);
+      MDB_val_set(rtx_val, rollup_tx);
+      result = mdb_cursor_put(m_cur_rollup_tx_info, &rtx_key, &rtx_val, MDB_APPENDDUP);
+    }
+  }
+  
+  // Is there token_tx data to add?
+  if (tx.version >= TRANSACTION_VERSION_ENABLE_TOKENS && tx.type == cryptonote::transaction_type::CREATE_TOKEN)
+  {
+    // Create the object we are going to write to the database
+    token_tx_info_carrot token_data;
+    token_data.block_height = m_height;
+    token_data.tx_hash = tx_hash;
+    token_data.return_pubkey = tx.protocol_tx_data.return_pubkey;
+    token_data.return_address = tx.protocol_tx_data.return_address;
+    token_data.return_view_tag = tx.protocol_tx_data.return_view_tag;
+    token_data.return_anchor_enc = tx.protocol_tx_data.return_anchor_enc;
+    token_data.locked_coins = tx.amount_burnt;
+    token_data.asset_type_id = cryptonote::asset_id_from_type("sal" + tx.token_metadata.asset_type);
+
+    // Because LMDB is shockingly bad at handling duplicates, we have resorted to using a counter of elements
+    // in the first element of the struct.
+    MDB_val data;
+    MDB_val_set(val_height, m_height);
+    result = mdb_cursor_get(m_cur_token_txs, &val_height, &data, MDB_SET);
+    if (!result)
+    {
+      mdb_size_t num_elems = 0;
+      result = mdb_cursor_count(m_cur_token_txs, &num_elems);
+      if (result)
+        throw0(DB_ERROR(std::string("Failed to get number of token TXs for height: ").append(mdb_strerror(result)).c_str()));
+      token_data.block_height = num_elems;
+    }
+    else if (result != MDB_NOTFOUND)
+      throw0(DB_ERROR(lmdb_error("Failed to get output amount in db transaction: ", result).c_str()));
+    else
+     token_data.block_height = 0;
+
+    // Now we know how many there are, write out the data to the DB
+    MDB_val_set(val_token_tx_data, token_data);
+    result = mdb_cursor_put(m_cur_token_txs, &val_height, &val_token_tx_data, MDB_APPENDDUP);
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to add tx carrot token data to db transaction: ", result).c_str()));
+
+    // Now add an entry to the `tokens` table
+    MDB_val_copy<uint64_t> asset_type_id(token_data.asset_type_id);
+    std::stringstream token_blob_str;
+    std::string token_blob = write_token_metadata(tx.token_metadata);
+    MDB_val_sized(token, token_blob);
+    int result = mdb_cursor_put(m_cur_tokens, &asset_type_id, &token, 0);
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to update token table: ", result).c_str()));
+  }
+
   // Is there yield_tx data to add?
   if (tx.version >= TRANSACTION_VERSION_CARROT && tx.type == cryptonote::transaction_type::STAKE)
   {
@@ -1601,6 +1813,9 @@ void BlockchainLMDB::remove_transaction_data(const crypto::hash& tx_hash, const
   CURSOR(yield_txs)
   CURSOR(audit_txs)
   CURSOR(carrot_yield_txs)
+  CURSOR(token_txs)
+  CURSOR(tokens)
+  CURSOR(rollup_tx_info)
 
   MDB_val_set(val_h, tx_hash);
 
@@ -1842,6 +2057,64 @@ void BlockchainLMDB::remove_transaction_data(const crypto::hash& tx_hash, const
       }
     }
   }
+
+
+  // Is there token_tx data to remove?
+  if (tx.version >= TRANSACTION_VERSION_ENABLE_TOKENS && tx.type == cryptonote::transaction_type::CREATE_TOKEN)
+  {
+    // Remove all CREATE_TOKEN entries for this transaction
+    MDB_val_set(val_height, m_height);
+    MDB_val v;
+    MDB_cursor_op op = MDB_SET;
+    while (1) {
+      result = mdb_cursor_get(m_cur_token_txs, &val_height, &v, op);
+      if (result == MDB_NOTFOUND) {
+        throw1(DB_ERROR("Failed to locate token tx for removal from db transaction"));
+      } else if (result) {
+        throw1(DB_ERROR(lmdb_error("Failed to locate token_tx data for removal: ", result).c_str()));
+      }
+      op = MDB_NEXT_DUP;
+      const token_tx_info_carrot tti = *(const token_tx_info_carrot*)v.mv_data;
+      if (tti.tx_hash == tx_hash) {
+        result = mdb_cursor_del(m_cur_token_txs, 0);
+        if (result)
+          throw1(DB_ERROR(lmdb_error("Failed to add removal of token_tx data to db transaction: ", result).c_str()));
+        break;
+      }
+    }
+
+    // Now remove an entry from the `tokens` table
+    MDB_val_copy<uint64_t> asset_type_id(cryptonote::asset_id_from_type("sal" + tx.token_metadata.asset_type));
+    op = MDB_SET;
+    result = mdb_cursor_get(m_cur_tokens, &asset_type_id, &v, op);
+    if (result == MDB_NOTFOUND) {
+      throw1(DB_ERROR("Failed to locate token for removal from db transaction"));
+    } else if (result) {
+      throw1(DB_ERROR(lmdb_error("Failed to locate token data for removal: ", result).c_str()));
+    }
+    result = mdb_cursor_del(m_cur_tokens, 0);
+    if (result)
+      throw1(DB_ERROR(lmdb_error("Failed to remove token data to db transaction: ", result).c_str()));
+  }
+
+  // Is there a rollup_tx to add?
+  if (tx.version >= TRANSACTION_VERSION_ENABLE_TOKENS &&
+      tx.type == cryptonote::transaction_type::ROLLUP &&
+      tx.layer2_rollup_data.txs.size())
+  {
+    for (const auto &rollup_tx: tx.layer2_rollup_data.txs) {
+      MDB_val_set(rtx_key, tx.rollup_binding_tag);
+      MDB_val_set(rtx_val, rollup_tx);
+      result = mdb_cursor_get(m_cur_rollup_tx_info, &rtx_key, &rtx_val, MDB_GET_BOTH);
+      if (result == MDB_NOTFOUND)
+        continue;
+      if (result)
+        throw1(DB_ERROR(lmdb_error("Failed to locate rollup_tx data for removal: ", result).c_str()));
+      result = mdb_cursor_del(m_cur_rollup_tx_info, 0);
+      if (result)
+        throw1(DB_ERROR(lmdb_error("Error adding removal of tx id to db transaction", result).c_str()));
+    }
+  }
   
   // Don't delete the tx_indices entry until the end, after we're done with val_tx_id
   if (mdb_cursor_del(m_cur_tx_indices, 0))
@@ -2390,6 +2663,13 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
 
   lmdb_db_open(txn, LMDB_CARROT_YIELD_TXS, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_carrot_yield_txs, "Failed to open db handle for m_carrot_yield_txs");
 
+  lmdb_db_open(txn, LMDB_TOKEN_TXS, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_token_txs, "Failed to open db handle for m_token_txs");
+  lmdb_db_open(txn, LMDB_TOKENS, MDB_CREATE, m_tokens, "Failed to open db handle for m_tokens");
+
+  lmdb_db_open(txn, LMDB_RCT_COUNT_INFO, MDB_INTEGERKEY | MDB_CREATE, m_rct_count_info, "Failed to open db handle for m_rct_count_info");
+
+  lmdb_db_open(txn, LMDB_ROLLUP_TX_INFO, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_rollup_tx_info, "Failed to open db handle for m_rollup_tx_info");
+
   mdb_set_dupsort(txn, m_spent_keys, compare_hash32);
   mdb_set_dupsort(txn, m_block_heights, compare_hash32);
   mdb_set_dupsort(txn, m_tx_indices, compare_hash32);
@@ -2415,6 +2695,11 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
   mdb_set_dupsort(txn, m_yield_txs, compare_uint64);
   mdb_set_dupsort(txn, m_audit_txs, compare_uint64);
   mdb_set_dupsort(txn, m_carrot_yield_txs, compare_uint64);
+  mdb_set_dupsort(txn, m_token_txs, compare_uint64);
+
+  mdb_set_compare(txn, m_tokens, compare_uint64);
+
+  mdb_set_dupsort(txn, m_rollup_tx_info, compare_uint64);
   
   if (!(mdb_flags & MDB_RDONLY))
   {
@@ -2602,6 +2887,12 @@ void BlockchainLMDB::reset()
     throw0(DB_ERROR(lmdb_error("Failed to drop m_audit_blocks: ", result).c_str()));
   if (auto result = mdb_drop(txn, m_carrot_yield_txs, 0))
     throw0(DB_ERROR(lmdb_error("Failed to drop m_carrot_yield_txs: ", result).c_str()));
+  if (auto result = mdb_drop(txn, m_token_txs, 0))
+    throw0(DB_ERROR(lmdb_error("Failed to drop m_token_txs: ", result).c_str()));
+  if (auto result = mdb_drop(txn, m_rct_count_info, 0))
+    throw0(DB_ERROR(lmdb_error("Failed to drop m_rct_count_info: ", result).c_str()));
+  if (auto result = mdb_drop(txn, m_rollup_tx_info, 0))
+    throw0(DB_ERROR(lmdb_error("Failed to drop m_rollup_tx_info: ", result).c_str()));
 
   // init with current version
   MDB_val_str(k, "version");
@@ -3454,8 +3745,13 @@ uint64_t BlockchainLMDB::get_block_timestamp(const uint64_t& height) const
   return ret;
 }
 
-std::pair<std::vector<uint64_t>, uint64_t> BlockchainLMDB::get_block_cumulative_rct_outputs(const std::vector<uint64_t> &heights, const std::string asset_type) const
+std::pair<std::vector<uint64_t>, uint64_t> BlockchainLMDB::get_block_cumulative_rct_outputs_old(const std::vector<uint64_t> &heights, const std::string asset_type) const
 {
+  // Handle tokens separately
+  if (cryptonote::is_asset_type_token(asset_type)) {
+    return get_block_cumulative_rct_outputs(heights, asset_type);
+  }
+  
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
   check_open();
   std::vector<uint64_t> res;
@@ -3484,11 +3780,11 @@ std::pair<std::vector<uint64_t>, uint64_t> BlockchainLMDB::get_block_cumulative_
   {
     if (height >= range_begin && height < range_end)
     {
-      // nohting to do
+      // nothing to do
     }
     else
     {
-      if (height == prev_height + 1)
+      if (false/*height == prev_height + 1*/)
       {
         MDB_val k2;
         result = mdb_cursor_get(m_cur_block_info, &k2, &v, MDB_NEXT_MULTIPLE);
@@ -3508,14 +3804,18 @@ std::pair<std::vector<uint64_t>, uint64_t> BlockchainLMDB::get_block_cumulative_
       if (result)
         throw0(DB_ERROR(lmdb_error("Error attempting to retrieve rct distribution from the db: ", result).c_str()));
     }
-    const mdb_block_info *bi = ((const mdb_block_info *)v.mv_data) + (height - range_begin);
+
+    assert(false);
+    //const mdb_block_info *bi = ((const mdb_block_info *)v.mv_data) + (height - range_begin);
 
     // if no asset type is provided in the request, an old client is requesting the cumulative outputs,
     // and is expecting the global output distribution that isn't bucketed by asset type in response
-    res.push_back(asset_type.empty() ? bi->bi_cum_rct : bi->bi_cum_rct_by_asset_type[asset_type]);
 
-    if (height == heights[heights.size() - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE])
-      num_spendable_global_outs = bi->bi_cum_rct;
+    //res.push_back(asset_type.empty() ? bi->bi_cum_rct : bi->bi_cum_rct_by_asset_type[asset_type]);
+
+    //if (height == heights[heights.size() - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE])
+    //  num_spendable_global_outs = asset_type.empty() ? bi->bi_cum_rct : bi->bi_cum_rct_by_asset_type[asset_type];
+    assert(true);
 
     prev_height = height;
   }
@@ -3524,6 +3824,64 @@ std::pair<std::vector<uint64_t>, uint64_t> BlockchainLMDB::get_block_cumulative_
   return std::make_pair(res, num_spendable_global_outs);
 }
 
+std::pair<std::vector<uint64_t>, uint64_t> BlockchainLMDB::get_block_cumulative_rct_outputs(const std::vector<uint64_t> &heights, const std::string asset_type) const
+{  
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+  check_open();
+  std::vector<uint64_t> res;
+  uint64_t num_spendable_global_outs = 0;
+  int result;
+
+  // Verify the asset_type matches a token
+  //if (!cryptonote::is_asset_type_token(asset_type)) {
+  //  throw0(BLOCK_DNE(std::string("Attempt to get token rct distribution failed - '" + asset_type + "' is not a valid token").c_str()));
+  //}
+  
+  // Get the token asset_type_id
+  uint32_t asset_type_id = cryptonote::asset_id_from_type(asset_type);
+  
+  if (heights.empty())
+    return {};
+  res.reserve(heights.size());
+
+  TXN_PREFIX_RDONLY();
+  RCURSOR(rct_count_info);
+
+  MDB_stat db_stats;
+  if ((result = mdb_stat(m_txn, m_blocks, &db_stats)))
+    throw0(DB_ERROR(lmdb_error("Failed to query m_blocks: ", result).c_str()));
+  for (size_t i = 0; i < heights.size(); ++i)
+    if (heights[i] >= db_stats.ms_entries)
+      throw0(BLOCK_DNE(std::string("Attempt to get rct distribution from height " + std::to_string(heights[i]) + " failed -- block size not in db").c_str()));
+
+  uint64_t prev_height = heights[0];
+  for (uint64_t height: heights)
+  {
+    MDB_val v;
+    MDB_val_set(k, height);
+    result = mdb_cursor_get(m_cur_rct_count_info, &k, &v, MDB_SET);
+    if (result == MDB_NOTFOUND) {
+      throw0(DB_ERROR(lmdb_error("Error attempting to retrieve rct distribution from the db: ", result).c_str()));
+    }
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to enumerate rct distribution info: ", result).c_str()));
+
+    oracle::asset_type_counts_v2 rct_count_info;
+    rct_count_info.deserialize(reinterpret_cast<const uint8_t*>(v.mv_data), v.mv_size);
+    //if (!rct_count_info.has_asset_type(asset_type_id))
+    //  throw0(BLOCK_DNE(std::string("Attempt to get rct distribution failed - '" + asset_type + "' not found").c_str()));
+    res.push_back(rct_count_info[asset_type_id]);
+
+    if (height == heights[heights.size() - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE])
+      num_spendable_global_outs = rct_count_info[asset_type_id];
+
+    prev_height = height;
+  }
+  
+  TXN_POSTFIX_RDONLY();
+  return std::make_pair(res, num_spendable_global_outs);
+}
+
 uint64_t BlockchainLMDB::get_top_block_timestamp() const
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@@ -3970,6 +4328,102 @@ std::map<std::string,uint64_t> BlockchainLMDB::get_circulating_supply() const
   return circulating_supply;
 }
 
+std::map<std::string, cryptonote::token_metadata_t> BlockchainLMDB::get_tokens() const
+{
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+  check_open();
+  TXN_PREFIX_RDONLY();
+  int result;
+
+  // Open the tokens table read-only
+  RCURSOR(tokens)
+
+  // Create the map<asset_type, token_data> we are going to return
+  std::map<std::string, cryptonote::token_metadata_t> token_map;
+
+  MDB_val k;
+  MDB_val v;
+  MDB_cursor_op op = MDB_FIRST;
+  while (1)
+  {
+    int result = mdb_cursor_get(m_cur_tokens, &k, &v, op);
+    op = MDB_NEXT;
+    if (result == MDB_NOTFOUND)
+      break;
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to get tokens: ", result).c_str()));
+
+    // Push the data into the tokens return struct
+    const uint64_t asset_type_id = *(const uint64_t*)k.mv_data;
+    const std::string asset_type = cryptonote::asset_type_from_id(asset_type_id);
+    if (!v.mv_size)
+      throw0(DB_ERROR("zero-length token_blob provided"));
+    std::string token_blob(reinterpret_cast<const char *>(v.mv_data), v.mv_size);
+    cryptonote::token_metadata_t token_metadata;
+    read_token_metadata(token_blob, token_metadata);
+    if (token_metadata.token.type() == typeid(cryptonote::erc_token_t)) {
+
+      // ERC20 token found
+      erc_token_t token = boost::get<cryptonote::erc_token_t>(token_metadata.token);
+      LOG_PRINT_L3("erc_token_t version " << token.version);
+      
+    } else if (token_metadata.token.type() == typeid(cryptonote::sal_token_t)) {
+
+      // SAL token found
+      sal_token_t token = boost::get<cryptonote::sal_token_t>(token_metadata.token);
+      LOG_PRINT_L3("sal_token_t version " << token.version);
+      
+    } else {
+      throw0(DB_ERROR("invalid token_blob provided"));
+    }
+    token_map[asset_type] = token_metadata;
+  }
+  
+  TXN_POSTFIX_RDONLY();
+
+  return token_map;
+}
+
+bool BlockchainLMDB::is_tx_paid_for(const cryptonote::transaction& tx) const
+{
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+  check_open();
+  TXN_PREFIX_RDONLY();
+  int result;
+
+  // Is it a TRANSFER?
+  if (tx.type != cryptonote::transaction_type::TRANSFER)
+    return true;
+  // Is is a TOKEN?
+  if (!cryptonote::is_asset_type_token(tx.source_asset_type))
+    return true;
+  
+  RCURSOR(rollup_tx_info)
+
+  // Calculate the TX prefix hash
+  crypto::hash tx_prefix_hash;
+  cryptonote::get_transaction_hash(tx, tx_prefix_hash);
+    
+  // get the key image from the first input
+  if (tx.vin.size() == 0)
+    return false;
+  const txin_to_key &in_to_key = boost::get < txin_to_key > (tx.vin[0]);
+
+  cryptonote::layer2_rollup_tx_t rollup_tx{tx_prefix_hash, in_to_key.k_image, tx.rct_signatures.txnFee};
+  MDB_val_set(key, tx.rollup_binding_tag);
+  MDB_val_set(val, rollup_tx);
+  result = mdb_cursor_get(m_cur_rollup_tx_info, &key, &val, MDB_GET_BOTH);
+  if (result == MDB_NOTFOUND) {
+    LOG_PRINT_L2("Transaction ID " << tx_prefix_hash << " has not been paid for");
+    return false;
+  }
+  if (result)
+    throw1(DB_ERROR(lmdb_error("Failed to locate rollup TX data: ", result).c_str()));
+
+  // Can only find a matching record if the ROLLUP is already mined
+  return true;
+}
+
 uint64_t BlockchainLMDB::num_outputs() const
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@@ -5683,8 +6137,169 @@ void BlockchainLMDB::migrate_2_3()
 
   MGINFO_YELLOW("Migrating blockchain from DB version 2 to 3 - this may take a while:");
 
-  // Create the missing (and empty) "audit_block_info" records for all blocks
+  std::map<uint64_t, oracle::asset_type_counts> map_counts;
+  
+  // Create the updated asset_type_counts_v2 entries
   do {
+    LOG_PRINT_L1("migrating block info:");
+
+    result = mdb_txn_begin(m_env, NULL, 0, txn);
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", result).c_str()));
+
+    MDB_stat db_stats;
+    if ((result = mdb_stat(txn, m_blocks, &db_stats)))
+      throw0(DB_ERROR(lmdb_error("Failed to query m_blocks: ", result).c_str()));
+    const uint64_t blockchain_height = db_stats.ms_entries;
+
+    /* the block_info table name is the same but the old version and new version
+     * have incompatible data. Create a new table. We want the name to be similar
+     * to the old name so that it will occupy the same location in the DB.
+     */
+    MDB_dbi o_block_info = m_block_info;
+    lmdb_db_open(txn, "block_infn", MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_block_info, "Failed to open db handle for block_infn");
+    mdb_set_dupsort(txn, m_block_info, compare_uint64);
+
+
+    MDB_cursor *c_blocks;
+    result = mdb_cursor_open(txn, m_blocks, &c_blocks);
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to open a cursor for blocks: ", result).c_str()));
+
+    MDB_cursor *c_old, *c_cur;
+    i = 0;
+    while(1) {
+      if (!(i % 1000)) {
+        if (i) {
+          LOGIF(el::Level::Info) {
+            std::cout << i << " / " << blockchain_height << "  \r" << std::flush;
+          }
+          txn.commit();
+          result = mdb_txn_begin(m_env, NULL, 0, txn);
+          if (result)
+            throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", result).c_str()));
+        }
+        result = mdb_cursor_open(txn, m_block_info, &c_cur);
+        if (result)
+          throw0(DB_ERROR(lmdb_error("Failed to open a cursor for block_infn: ", result).c_str()));
+        result = mdb_cursor_open(txn, o_block_info, &c_old);
+        if (result)
+          throw0(DB_ERROR(lmdb_error("Failed to open a cursor for block_info: ", result).c_str()));
+        if (!i) {
+          MDB_stat db_stat;
+          result = mdb_stat(txn, m_block_info, &db_stats);
+          if (result)
+            throw0(DB_ERROR(lmdb_error("Failed to query m_block_info: ", result).c_str()));
+          i = db_stats.ms_entries;
+        }
+      }
+      result = mdb_cursor_get(c_old, &k, &v, MDB_NEXT);
+      if (result == MDB_NOTFOUND) {
+        txn.commit();
+        break;
+      }
+      else if (result)
+        throw0(DB_ERROR(lmdb_error("Failed to get a record from block_info: ", result).c_str()));
+      const mdb_block_info_1 *bi_old = (const mdb_block_info_1*)v.mv_data;
+      mdb_block_info_2 bi;
+      bi.bi_height = bi_old->bi_height;
+      bi.bi_timestamp = bi_old->bi_timestamp;
+      bi.bi_coins = bi_old->bi_coins;
+      bi.bi_weight = bi_old->bi_weight;
+      bi.bi_diff_lo = bi_old->bi_diff_lo;
+      bi.bi_diff_hi = bi_old->bi_diff_hi;
+      bi.bi_hash = bi_old->bi_hash;
+      bi.bi_cum_rct = bi_old->bi_cum_rct;
+      bi.bi_long_term_block_weight = bi_old->bi_long_term_block_weight;
+      bi.bi_pricing_record = bi_old->bi_pricing_record;
+      map_counts[bi.bi_height] = bi_old->bi_cum_rct_by_asset_type;
+
+      MDB_val_set(nv, bi);
+      result = mdb_cursor_put(c_cur, (MDB_val *)&zerokval, &nv, MDB_APPENDDUP);
+      if (result)
+        throw0(DB_ERROR(lmdb_error("Failed to put a record into block_infn: ", result).c_str()));
+      /* we delete the old records immediately, so the overall DB and mapsize should not grow.
+       * This is a little slower than just letting mdb_drop() delete it all at the end, but
+       * it saves a significant amount of disk space.
+       */
+      result = mdb_cursor_del(c_old, 0);
+      if (result)
+        throw0(DB_ERROR(lmdb_error("Failed to delete a record from block_info: ", result).c_str()));
+      i++;
+    }
+
+    result = mdb_txn_begin(m_env, NULL, 0, txn);
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", result).c_str()));
+    /* Delete the old table */
+    result = mdb_drop(txn, o_block_info, 1);
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to delete old block_info table: ", result).c_str()));
+
+    RENAME_DB("block_infn");
+    mdb_dbi_close(m_env, m_block_info);
+
+    lmdb_db_open(txn, "block_info", MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_block_info, "Failed to open db handle for block_infn");
+    mdb_set_dupsort(txn, m_block_info, compare_uint64);
+
+    txn.commit();
+    
+    // Now create the new table with our asset_type_counts
+    LOG_PRINT_L1("migrating RCT asset_type count info:");
+
+    result = mdb_txn_begin(m_env, NULL, 0, txn);
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", result).c_str()));
+
+    oracle::asset_type_counts_v2 rct_counts;
+    uint32_t asset_type_id_sal = cryptonote::asset_id_from_type("SAL");
+    rct_counts.add_asset_type(asset_type_id_sal);
+    uint32_t asset_type_id_one = cryptonote::asset_id_from_type("SAL1");
+    rct_counts.add_asset_type(asset_type_id_one);
+    uint32_t asset_type_id_burn = cryptonote::asset_id_from_type("BURN");
+    rct_counts.add_asset_type(asset_type_id_burn);
+    MDB_cursor *c_cur_rct;
+    i = 0;
+    uint64_t i_max = map_counts.size();
+    do {
+      if (!(i % 1000)) {
+        if (i) {
+          LOGIF(el::Level::Info) {
+            std::cout << i << " / " << blockchain_height << "  \r" << std::flush;
+          }
+          txn.commit();
+          result = mdb_txn_begin(m_env, NULL, 0, txn);
+          if (result)
+            throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", result).c_str()));
+        }
+        result = mdb_cursor_open(txn, m_rct_count_info, &c_cur_rct);
+        if (result)
+          throw0(DB_ERROR(lmdb_error("Failed to open a cursor for rct_count_info: ", result).c_str()));
+        if (!i) {
+          result = mdb_stat(txn, m_rct_count_info, &db_stats);
+          if (result)
+            throw0(DB_ERROR(lmdb_error("Failed to query m_rct_count_info: ", result).c_str()));
+          i = db_stats.ms_entries;
+        }
+      }
+
+      // populate the RCT counts
+      oracle::asset_type_counts old_counts = map_counts.at(i);
+      rct_counts.asset_counts[asset_type_id_sal] = old_counts["SAL"];
+      rct_counts.asset_counts[asset_type_id_one] = old_counts["SAL1"];
+      rct_counts.asset_counts[asset_type_id_burn] = old_counts["BURN"];
+
+      std::vector<uint8_t> rct_counts_serialized = rct_counts.serialize();      
+      MDB_val_set(key, i);
+      MDB_val_sized(value, rct_counts_serialized);
+      result = mdb_cursor_put(c_cur_rct, &key, &value, MDB_APPEND);
+      if (result)
+        throw0(DB_ERROR(lmdb_error("Failed to put a record into : ", result).c_str()));
+      i++;
+    } while (i<i_max);
+
+    txn.commit();
+    
   } while(0);
   
   uint32_t version = VERSION;
@@ -5693,7 +6308,7 @@ void BlockchainLMDB::migrate_2_3()
   MDB_val_str(vk, "version");
   result = mdb_txn_begin(m_env, NULL, 0, txn);
   if (result)
-    throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", result).c_str()));
+    throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", result).c_str()));  
   result = mdb_put(txn, m_properties, &vk, &v, 0);
   if (result)
     throw0(DB_ERROR(lmdb_error("Failed to update version for the db: ", result).c_str()));
@@ -5702,8 +6317,8 @@ void BlockchainLMDB::migrate_2_3()
 
 void BlockchainLMDB::migrate(const uint32_t oldversion)
 {
-  //if (oldversion < 3)
-  //  migrate_2_3();
+  if (oldversion < 3)
+    migrate_2_3();
 }
 
 }  // namespace cryptonote
diff --git a/src/blockchain_db/lmdb/db_lmdb.h b/src/blockchain_db/lmdb/db_lmdb.h
index df6910668..9e978bc04 100644
--- a/src/blockchain_db/lmdb/db_lmdb.h
+++ b/src/blockchain_db/lmdb/db_lmdb.h
@@ -82,6 +82,14 @@ typedef struct mdb_txn_cursors
   MDB_cursor *m_txc_audit_blocks;
   MDB_cursor *m_txc_carrot_yield_txs;
 
+  MDB_cursor *m_txc_token_txs;
+  MDB_cursor *m_txc_tokens;
+  MDB_cursor *m_txc_asset_type_counts;
+  
+  MDB_cursor *m_txc_rct_count_info;
+  
+  MDB_cursor *m_txc_rollup_tx_info;
+  
 } mdb_txn_cursors;
 
 #define m_cur_blocks	m_cursors->m_txc_blocks
@@ -111,6 +119,14 @@ typedef struct mdb_txn_cursors
 #define m_cur_audit_blocks	m_cursors->m_txc_audit_blocks
 #define m_cur_carrot_yield_txs		m_cursors->m_txc_carrot_yield_txs
 
+#define m_cur_token_txs		m_cursors->m_txc_token_txs
+#define m_cur_tokens		m_cursors->m_txc_tokens
+#define m_cur_asset_type_counts	m_cursors->m_txc_asset_type_counts
+
+#define m_cur_rct_count_info m_cursors->m_txc_rct_count_info
+
+#define m_cur_rollup_tx_info m_cursors->m_txc_rollup_tx_info
+
 typedef struct mdb_rflags
 {
   bool m_rf_txn;
@@ -140,6 +156,15 @@ typedef struct mdb_rflags
   bool m_rf_audit_txs;
   bool m_rf_audit_blocks;
   bool m_rf_carrot_yield_txs;
+
+  bool m_rf_token_txs;
+  bool m_rf_tokens;
+  bool m_rf_asset_type_counts;
+
+  bool m_rf_rct_count_info;
+
+  bool m_rf_rollup_tx_info;
+  
 } mdb_rflags;
 
 typedef struct mdb_threadinfo
@@ -242,6 +267,8 @@ public:
 
   virtual cryptonote::blobdata get_block_blob_from_height(const uint64_t& height) const;
 
+  virtual std::pair<std::vector<uint64_t>, uint64_t> get_block_cumulative_rct_outputs_old(const std::vector<uint64_t> &heights, const std::string asset_type) const;
+
   virtual std::pair<std::vector<uint64_t>, uint64_t> get_block_cumulative_rct_outputs(const std::vector<uint64_t> &heights, const std::string asset_type) const;
 
   virtual uint64_t get_block_timestamp(const uint64_t& height) const;
@@ -277,6 +304,10 @@ public:
   virtual uint64_t height() const;
 
   virtual std::map<std::string, uint64_t> get_circulating_supply() const;
+
+  virtual std::map<std::string, cryptonote::token_metadata_t> get_tokens() const;
+  
+  virtual bool is_tx_paid_for(const cryptonote::transaction& tx) const;
   
   virtual bool tx_exists(const crypto::hash& h) const;
   virtual bool tx_exists(const crypto::hash& h, uint64_t& tx_index) const;
@@ -406,11 +437,12 @@ private:
                           const difficulty_type& cumulative_difficulty,
                           const uint64_t& coins_generated,
                           uint64_t num_rct_outs,
-                          oracle::asset_type_counts& cum_rct_by_asset_type,
+                          oracle::asset_type_counts_v2& cum_rct_by_asset_type,
                           const crypto::hash& blk_hash,
                           uint64_t slippage_total,
                           uint64_t yield_total,
                           uint64_t audit_total,
+                          uint64_t token_total,
                           const cryptonote::network_type nettype,
                           cryptonote::yield_block_info& ybi,
                           cryptonote::audit_block_info& abi
@@ -479,6 +511,8 @@ private:
   virtual int get_yield_tx_info(const uint64_t height, std::vector<yield_tx_info>& yti_container) const;
   virtual int get_carrot_yield_tx_info(const uint64_t height, std::vector<yield_tx_info_carrot>& yti_container) const;
 
+  virtual int get_token_tx_info(const uint64_t height, std::vector<token_tx_info_carrot>& tti_container) const;
+
 private:
   MDB_env* m_env;
 
@@ -521,6 +555,14 @@ private:
 
   MDB_dbi m_carrot_yield_txs;
 
+  MDB_dbi m_token_txs;
+  MDB_dbi m_tokens;
+  MDB_dbi m_asset_type_counts;
+
+  MDB_dbi m_rct_count_info;
+
+  MDB_dbi m_rollup_tx_info;
+
   mutable uint64_t m_cum_size;	// used in batch size estimation
   mutable unsigned int m_cum_count;
   std::string m_folder;
diff --git a/src/blockchain_db/testdb.h b/src/blockchain_db/testdb.h
index d19d7ab78..c8a263539 100644
--- a/src/blockchain_db/testdb.h
+++ b/src/blockchain_db/testdb.h
@@ -156,15 +156,20 @@ public:
                           const difficulty_type& cumulative_difficulty,
                           const uint64_t& coins_generated,
                           uint64_t num_rct_outs,
-                          oracle::asset_type_counts& cum_rct_by_asset_type,
+                          oracle::asset_type_counts_v2& cum_rct_by_asset_type,
                           const crypto::hash& blk_hash,
                           uint64_t slippage_total,
                           uint64_t yield_total,
                           uint64_t audit_total,
+                          uint64_t token_total,
                           const cryptonote::network_type nettype,
                           cryptonote::yield_block_info& ybi,
                           cryptonote::audit_block_info& abi
                           ) override { }
+  
+  virtual std::map<std::string, cryptonote::token_metadata_t> get_tokens() const override { return {}; }
+  virtual bool is_tx_paid_for(const cryptonote::transaction& tx) const override { return true; }
+  virtual int get_token_tx_info(const uint64_t height, std::vector<token_tx_info_carrot>& tti_container) const override { return 0; }
   virtual cryptonote::block get_block_from_height(const uint64_t& height) const override { return cryptonote::block(); }
   virtual void set_hard_fork_version(uint64_t height, uint8_t version) override {}
   virtual uint8_t get_hard_fork_version(uint64_t height) const override { return 0; }
diff --git a/src/blocks/checkpoints.dat b/src/blocks/checkpoints.dat
index 0a5167066..bdd06709a 100644
Binary files a/src/blocks/checkpoints.dat and b/src/blocks/checkpoints.dat differ
diff --git a/src/carrot_core/config.h b/src/carrot_core/config.h
index 84aa2afa3..a5163a0c1 100644
--- a/src/carrot_core/config.h
+++ b/src/carrot_core/config.h
@@ -75,5 +75,6 @@ static constexpr const unsigned int CARROT_MAX_TX_INPUTS = 64;
 // SPARC addressing protocol domain separators
 static constexpr const unsigned char SPARC_DOMAIN_SEP_RETURN_PUBKEY_ENCRYPTION_MASK[] = "SPARC return pubkey encryption mask";
 static constexpr const unsigned char SPARC_DOMAIN_SEP_RETURN_ADDRESS_SCALAR[] = "SPARC return address scalar";
+static constexpr const unsigned char SPARC_DOMAIN_SEP_RETURN_INDEX_SCALAR[] = "SPARC return index scalar";
  
 } //namespace carrot
diff --git a/src/carrot_core/core_types.cpp b/src/carrot_core/core_types.cpp
index f4600416a..b0b47c8b1 100644
--- a/src/carrot_core/core_types.cpp
+++ b/src/carrot_core/core_types.cpp
@@ -122,6 +122,11 @@ bool operator==(const view_tag_t &a, const view_tag_t &b)
     return memcmp(&a, &b, sizeof(view_tag_t)) == 0;
 }
 //-------------------------------------------------------------------------------------------------------------------
+bool operator==(const rollup_binding_tag_t &a, const rollup_binding_tag_t &b)
+{
+    return memcmp(&a, &b, sizeof(rollup_binding_tag_t)) == 0;
+}
+//-------------------------------------------------------------------------------------------------------------------
 janus_anchor_t gen_janus_anchor()
 {
     return crypto::rand<janus_anchor_t>();
diff --git a/src/carrot_core/core_types.h b/src/carrot_core/core_types.h
index 8431de51b..f7250c611 100644
--- a/src/carrot_core/core_types.h
+++ b/src/carrot_core/core_types.h
@@ -106,6 +106,13 @@ struct encrypted_return_pubkey_t final
     unsigned char bytes[ENCRYPTED_RETURN_PUBKEY_BYTES];
 };
 
+/// Salvium rollup binding tag
+constexpr std::size_t ROLLUP_BINDING_TAG_BYTES{8};
+struct rollup_binding_tag_t final
+{
+    unsigned char bytes[ROLLUP_BINDING_TAG_BYTES];
+};
+
 /// overloaded operators: address tag
 bool operator==(const janus_anchor_t &a, const janus_anchor_t &b);
 static inline bool operator!=(const janus_anchor_t &a, const janus_anchor_t &b) { return !(a == b); }
@@ -139,6 +146,10 @@ bool operator==(const encrypted_return_pubkey_t &a, const encrypted_return_pubke
 static inline bool operator!=(const encrypted_return_pubkey_t &a, const encrypted_return_pubkey_t &b) { return !(a == b); }
 encrypted_return_pubkey_t operator^(const encrypted_return_pubkey_t &a, const encrypted_return_pubkey_t &b);
 
+/// overloaded operators: rollup binding tag
+bool operator==(const rollup_binding_tag_t &a, const rollup_binding_tag_t &b);
+static inline bool operator!=(const rollup_binding_tag_t &a, const rollup_binding_tag_t &b) { return !(a == b); }
+
 /// generate a random janus anchor
 janus_anchor_t gen_janus_anchor();
 /// generate a random (non-null) payment ID
diff --git a/src/carrot_core/enote_utils.cpp b/src/carrot_core/enote_utils.cpp
index adcfbc451..a107f1106 100644
--- a/src/carrot_core/enote_utils.cpp
+++ b/src/carrot_core/enote_utils.cpp
@@ -39,6 +39,7 @@ extern "C"
 #include "crypto/wallet/crypto.h"
 #include "hash_functions.h"
 #include "int-util.h"
+#include "string_tools.h"
 #include "misc_language.h"
 #include "ringct/rctOps.h"
 #include "transcript_fixed.h"
@@ -211,6 +212,17 @@ void make_sparc_return_privkey(const unsigned char s_sender_receiver_unctx[32],
     derive_scalar(transcript.data(), transcript.size(), s_sender_receiver_unctx, &return_privkey_out);
 }
 //-------------------------------------------------------------------------------------------------------------------
+void make_sparc_return_index(const unsigned char s_sender_receiver_unctx[32],
+                             const input_context_t &input_context,
+                             const crypto::public_key &onetime_address,
+                             const uint64_t idx,
+                             crypto::secret_key &return_index_out)
+{
+    // k_idx = H_32(s_sr || input_context || Ko || idx)
+    const auto transcript = sp::make_fixed_transcript<SPARC_DOMAIN_SEP_RETURN_INDEX_SCALAR>(input_context, onetime_address, idx);
+    derive_scalar(transcript.data(), transcript.size(), s_sender_receiver_unctx, &return_index_out);
+}
+//-------------------------------------------------------------------------------------------------------------------
 void make_sparc_return_pubkey_encryption_mask(const unsigned char s_sender_receiver_unctx[32],
     const input_context_t &input_context,
     const crypto::public_key &onetime_address,
@@ -222,22 +234,50 @@ void make_sparc_return_pubkey_encryption_mask(const unsigned char s_sender_recei
 }
 //-------------------------------------------------------------------------------------------------------------------
 void make_sparc_return_pubkey(const unsigned char s_sender_receiver_unctx[32],
-    const input_context_t &input_context,
-    const view_balance_secret_device *s_view_balance_dev,
-    const crypto::public_key &onetime_address,
-    encrypted_return_pubkey_t &return_pubkey_out)
+                              const input_context_t &input_context,
+                              const view_balance_secret_device *s_view_balance_dev,
+                              const crypto::public_key &onetime_address,
+                              const uint64_t idx,
+                              encrypted_return_pubkey_t &return_pubkey_out)
 {
-    // K_return = k_return G ^ m_return
+    // compute k_return
     crypto::secret_key k_return;
-    crypto::public_key return_pub;
-    encrypted_return_pubkey_t K_return;
-    encrypted_return_pubkey_t m_return;
     s_view_balance_dev->make_internal_return_privkey(input_context, onetime_address, k_return);
-    crypto::secret_key_to_public_key(k_return, return_pub);
-    static_assert(sizeof(K_return.bytes) == sizeof(return_pub.data), "Size mismatch");
-    memcpy(K_return.bytes, return_pub.data, sizeof(encrypted_return_pubkey_t));
-    make_sparc_return_pubkey_encryption_mask(s_sender_receiver_unctx, input_context, onetime_address, m_return);
-    return_pubkey_out = K_return ^ m_return;
+
+    // compute k_idx
+    crypto::secret_key k_idx;
+    make_sparc_return_index(s_sender_receiver_unctx, input_context, onetime_address, idx, k_idx);
+    
+    // compute m_return
+    encrypted_return_pubkey_t m_return;
+    make_sparc_return_pubkey_encryption_mask(s_sender_receiver_unctx,
+                                             input_context,
+                                             onetime_address,
+                                             m_return);
+
+#if 1
+    // compute SPARC K_return = k_return * G
+    crypto::public_key K_return;
+    crypto::secret_key_to_public_key(k_return, K_return);
+
+    // compute return_enc
+    encrypted_return_pubkey_t return_pub;
+    static_assert(sizeof(K_return.data) == sizeof(return_pub.bytes), "Size mismatch");
+    memcpy(return_pub.bytes, K_return.data, sizeof(encrypted_return_pubkey_t));
+#else
+    // compute SPARC K_return = k_return * G + k_idx * T
+    rct::key K_return;
+    rct::addKeys2(K_return,
+                  rct::sk2rct(k_return),
+                  rct::sk2rct(k_idx),
+                  rct::pk2rct(crypto::get_T()));
+
+    // compute return_enc
+    encrypted_return_pubkey_t return_pub;
+    static_assert(sizeof(K_return.bytes) == sizeof(return_pub.bytes), "Size mismatch");
+    memcpy(return_pub.bytes, K_return.bytes, sizeof(encrypted_return_pubkey_t));
+#endif
+    return_pubkey_out = return_pub ^ m_return;
 }
 //-------------------------------------------------------------------------------------------------------------------
 //-------------------------------------------------------------------------------------------------------------------
@@ -470,7 +510,6 @@ bool test_carrot_view_tag(const unsigned char s_sender_receiver_unctx[32],
     // vt' = H_3(s_sr || input_context || Ko)
     view_tag_t nominal_view_tag;
     make_carrot_view_tag(s_sender_receiver_unctx, input_context, onetime_address, nominal_view_tag);
-
     // vt' ?= vt
     return nominal_view_tag == view_tag;
 }
diff --git a/src/carrot_core/enote_utils.h b/src/carrot_core/enote_utils.h
index 03e6844eb..239404902 100644
--- a/src/carrot_core/enote_utils.h
+++ b/src/carrot_core/enote_utils.h
@@ -138,6 +138,20 @@ void make_sparc_return_privkey(const unsigned char s_sender_receiver_unctx[32],
     const crypto::public_key &onetime_address,
     crypto::secret_key &return_privkey_out);
 /**
+* brief: make_sparc_return_index - return index, given non-secret data
+*    m_return = H_32(s_sr || input_context || Ko || idx)
+* param: s_sender_receiver_unctx - s_sr
+* param: input_context - input_context
+* param: onetime_address - Ko
+* param: idx - idx
+* outparam: return_index_out - m_return
+*/
+void make_sparc_return_index(const unsigned char s_sender_receiver_unctx[32],
+                             const input_context_t &input_context,
+                             const crypto::public_key &onetime_address,
+                             const uint64_t idx,
+                             crypto::secret_key &return_index_out);
+/**
 * brief: make_sparc_return_pubkey_encryption_mask - used for hiding return pubkey
 *    m_return = H_32(s_sr || input_context || Ko)
 * param: s_sender_receiver_unctx - s_sr
@@ -159,10 +173,11 @@ void make_sparc_return_pubkey_encryption_mask(const unsigned char s_sender_recei
 * outparam: return_pubkey_mask_out - K_return
 */
 void make_sparc_return_pubkey(const unsigned char s_sender_receiver_unctx[32],
-    const input_context_t &input_context,
-    const view_balance_secret_device *s_view_balance_dev,
-    const crypto::public_key &onetime_address,
-    encrypted_return_pubkey_t &return_pubkey_out);
+                              const input_context_t &input_context,
+                              const view_balance_secret_device *s_view_balance_dev,
+                              const crypto::public_key &onetime_address,
+                              const uint64_t idx,
+                              encrypted_return_pubkey_t &return_pubkey_out);
 /**
 * brief: make_carrot_input_context_coinbase - input context for a sender-receiver secret (coinbase txs)
 *    input_context = "C" || IntToBytes256(block_index)
diff --git a/src/carrot_core/output_set_finalization.cpp b/src/carrot_core/output_set_finalization.cpp
index d11ccb919..554ae14a5 100644
--- a/src/carrot_core/output_set_finalization.cpp
+++ b/src/carrot_core/output_set_finalization.cpp
@@ -174,7 +174,10 @@ void get_output_enote_proposals(const std::vector<CarrotPaymentProposalV1> &norm
     // assert payment proposals numbers
     const size_t num_selfsend_proposals = selfsend_payment_proposals.size();
     const size_t num_proposals = normal_payment_proposals.size() + num_selfsend_proposals;
-    if (tx_type == cryptonote::transaction_type::STAKE || tx_type == cryptonote::transaction_type::BURN) {
+    if (tx_type == cryptonote::transaction_type::STAKE ||
+        tx_type == cryptonote::transaction_type::BURN ||
+        tx_type == cryptonote::transaction_type::CREATE_TOKEN ||
+        tx_type == cryptonote::transaction_type::ROLLUP) {
         CARROT_CHECK_AND_THROW(num_proposals == 1, too_few_outputs, "tx doesn't have correct number of proposals");
     } else {
         CARROT_CHECK_AND_THROW(num_proposals >= CARROT_MIN_TX_OUTPUTS, too_few_outputs, "too few payment proposals");
@@ -221,11 +224,12 @@ void get_output_enote_proposals(const std::vector<CarrotPaymentProposalV1> &norm
 
         encrypted_payment_id_t encrypted_payment_id;
         if (tx_type == cryptonote::transaction_type::RETURN) {
+            const uint64_t idx = 0;
             get_output_proposal_return_v1(normal_payment_proposals[i],
-                tx_first_key_image,
-                s_view_balance_dev,
-                output_entry.first,
-                encrypted_payment_id);
+                                          tx_first_key_image,
+                                          s_view_balance_dev,
+                                          output_entry.first,
+                                          encrypted_payment_id);
         } else {
             get_output_proposal_normal_v1(normal_payment_proposals[i],
                 tx_first_key_image,
diff --git a/src/carrot_core/payment_proposal.cpp b/src/carrot_core/payment_proposal.cpp
index e20b50504..9f5ad0ef0 100644
--- a/src/carrot_core/payment_proposal.cpp
+++ b/src/carrot_core/payment_proposal.cpp
@@ -36,6 +36,7 @@
 #include "misc_language.h"
 #include "misc_log_ex.h"
 #include "ringct/rctOps.h"
+#include "crypto/generators.h"
 
 //third party headers
 
@@ -208,10 +209,11 @@ static void get_external_output_proposal_parts(const mx25519_pubkey &s_sender_re
     // 4. construct the return pubkey
     if (s_view_balance_dev != nullptr)
         make_sparc_return_pubkey(s_sender_receiver_unctx.data,
-            input_context,
-            s_view_balance_dev,
-            onetime_address_out,
-            return_pubkey_out);
+                                 input_context,
+                                 s_view_balance_dev,
+                                 onetime_address_out,
+                                 0,
+                                 return_pubkey_out);
 }
 //-------------------------------------------------------------------------------------------------------------------    
 //-------------------------------------------------------------------------------------------------------------------
@@ -423,11 +425,95 @@ void get_output_proposal_special_v1(const CarrotPaymentProposalSelfSendV1 &propo
     // 8. save the enote ephemeral pubkey, first tx key image, and amount
     output_enote_out.enote.enote_ephemeral_pubkey = enote_ephemeral_pubkey;
     output_enote_out.enote.tx_first_key_image     = tx_first_key_image;
-    output_enote_out.enote.asset_type             = "SAL1";
+    output_enote_out.enote.asset_type             = proposal.asset_type;
     output_enote_out.enote.return_enc             = crypto::rand<carrot::encrypted_return_pubkey_t>();
     output_enote_out.amount                       = proposal.amount;
 }
 //-------------------------------------------------------------------------------------------------------------------
+void get_output_proposal_paymentchannel_v1(const CarrotPaymentProposalV1 &proposal,
+                                           const crypto::key_image &tx_first_key_image,
+                                           const view_balance_secret_device *s_view_balance_dev,
+                                           const crypto::public_key &K_o,
+                                           const uint64_t idx,
+                                           RCTOutputEnoteProposal &output_enote_out,
+                                           encrypted_payment_id_t &encrypted_payment_id_out)
+{
+    // 1. sanity checks
+    CARROT_CHECK_AND_THROW(proposal.randomness != null_anchor,
+        missing_randomness, "invalid randomness for janus anchor (zero).");
+
+    // 2. input context: input_context = "R" || KI_1
+    const input_context_t input_context = make_carrot_input_context(tx_first_key_image);
+    /*
+    //    K_v = K_return - k_idx * T 
+    CarrotPaymentProposalV1 proposal_with_kv = proposal;
+    const bool is_sparc = (k_idx != crypto::null_skey) && sc_isnonzero(to_bytes(k_idx)); // check here! for zero its not needed
+    if (is_sparc)
+    {
+        // Calculate K_v = K_return - k_idx * T
+        const rct::key K_return_rct = rct::pk2rct(proposal.destination.address_view_pubkey);
+        const rct::key k_idx_T = rct::scalarmultKey(rct::pk2rct(crypto::get_T()), rct::sk2rct(k_idx));
+        rct::key K_v_rct;
+        rct::subKeys(K_v_rct, K_return_rct, k_idx_T);
+        proposal_with_kv.destination.address_view_pubkey = rct::rct2pk(K_v_rct);
+    }
+    */
+    mx25519_pubkey s_sender_receiver_unctx; auto dhe_wiper = auto_wiper(s_sender_receiver_unctx);
+    get_normal_proposal_ecdh_parts(proposal,
+        input_context,
+        output_enote_out.enote.enote_ephemeral_pubkey,
+        s_sender_receiver_unctx);
+
+    // 4. build the output enote address pieces
+    crypto::hash s_sender_receiver; auto q_wiper = auto_wiper(s_sender_receiver);
+    encrypted_return_pubkey_t return_pubkey;
+    get_external_output_proposal_parts(
+        s_sender_receiver_unctx,
+        proposal.destination.address_spend_pubkey,
+        proposal.destination.payment_id,
+        proposal.amount,
+        CarrotEnoteType::PAYMENT,
+        output_enote_out.enote.enote_ephemeral_pubkey,
+        input_context,
+        s_view_balance_dev,
+        false, // coinbase_amount_commitment
+        s_sender_receiver,
+        output_enote_out.amount_blinding_factor,
+        output_enote_out.enote.amount_commitment,
+        output_enote_out.enote.onetime_address,
+        output_enote_out.enote.amount_enc,
+        encrypted_payment_id_out,
+        output_enote_out.enote.view_tag,
+        return_pubkey
+    );
+
+    // Override the onetime address
+    crypto::secret_key k_idx;
+    make_sparc_return_index(s_sender_receiver_unctx.data, input_context, K_o, idx, k_idx);    
+    rct::key K_r = rct::addKeys(rct::pk2rct(proposal.destination.address_spend_pubkey),rct::pk2rct(proposal.destination.address_view_pubkey));
+    rct::key K_idx = rct::scalarmultKey(rct::pk2rct(crypto::get_T()), rct::sk2rct(k_idx));
+    output_enote_out.enote.onetime_address = rct::rct2pk(rct::addKeys(K_r, K_idx));
+
+    // Recalculate the view tag : vt = H_3(s_sr || input_context || Ksra)
+    make_carrot_view_tag(s_sender_receiver_unctx.data, input_context, output_enote_out.enote.onetime_address, output_enote_out.enote.view_tag);
+    
+    // Recalculate a_enc = BytesToInt64(a) XOR m_a
+    output_enote_out.enote.amount_enc = encrypt_carrot_amount(proposal.amount, s_sender_receiver, output_enote_out.enote.onetime_address);
+    
+    // Recalculate anchor_enc = anchor XOR m_anchor
+    output_enote_out.enote.anchor_enc = encrypt_carrot_anchor(proposal.randomness, s_sender_receiver, output_enote_out.enote.onetime_address);
+    
+    // Recalculate the pid_enc = pid XOR m_pid
+    encrypted_payment_id_out = encrypt_legacy_payment_id(proposal.destination.payment_id, s_sender_receiver, output_enote_out.enote.onetime_address);
+
+    // 6. save the amount & first key image & asset type
+    output_enote_out.amount                   = proposal.amount;
+    output_enote_out.enote.asset_type         = proposal.asset_type;
+    output_enote_out.enote.tx_first_key_image = tx_first_key_image;
+    // disable returning an already returned tx.
+    output_enote_out.enote.return_enc         = crypto::rand<carrot::encrypted_return_pubkey_t>();
+}
+//-------------------------------------------------------------------------------------------------------------------
 void get_output_proposal_return_v1(const CarrotPaymentProposalV1 &proposal,
     const crypto::key_image &tx_first_key_image,
     const view_balance_secret_device *s_view_balance_dev,
@@ -561,12 +647,12 @@ void get_output_proposal_internal_v1(const CarrotPaymentProposalSelfSendV1 &prop
     // 9. save the enote ephemeral pubkey, first tx key image, and amount
     output_enote_out.enote.enote_ephemeral_pubkey = enote_ephemeral_pubkey;
     output_enote_out.enote.tx_first_key_image     = tx_first_key_image;
-    output_enote_out.enote.asset_type             = "SAL1";
+    output_enote_out.enote.asset_type             = proposal.asset_type;
     output_enote_out.enote.return_enc             = crypto::rand<carrot::encrypted_return_pubkey_t>();
     output_enote_out.amount                       = proposal.amount;
 
     // 10. construct the stake return enote
-    if (tx_type == cryptonote::transaction_type::STAKE) {
+    if (tx_type == cryptonote::transaction_type::STAKE || tx_type == cryptonote::transaction_type::CREATE_TOKEN) {
         // make k_return
         crypto::secret_key k_return;
         s_view_balance_dev.make_internal_return_privkey(input_context, output_enote_out.enote.onetime_address, k_return);
diff --git a/src/carrot_core/payment_proposal.h b/src/carrot_core/payment_proposal.h
index fc5deadbe..c5f318e5b 100644
--- a/src/carrot_core/payment_proposal.h
+++ b/src/carrot_core/payment_proposal.h
@@ -139,6 +139,21 @@ void get_output_proposal_normal_v1(const CarrotPaymentProposalV1 &proposal,
     RCTOutputEnoteProposal &output_enote_out,
     encrypted_payment_id_t &encrypted_payment_id_out);
 /**
+* brief: get_output_proposal_paymentchannel_v1 - convert the carrot proposal to an output proposal
+* param: proposal -
+* param: tx_first_key_image -
+* param: k_view_dev -
+* outparam: output_enote_out -
+* outparam: encrypted_payment_id_out - pid_enc
+*/
+void get_output_proposal_paymentchannel_v1(const CarrotPaymentProposalV1 &proposal,
+                                           const crypto::key_image &tx_first_key_image,
+                                           const view_balance_secret_device *s_view_balance_dev,
+                                           const crypto::public_key &K_o,
+                                           const uint64_t idx,
+                                           RCTOutputEnoteProposal &output_enote_out,
+                                           encrypted_payment_id_t &encrypted_payment_id_out);
+/**
 * brief: get_output_proposal_return_v1 - convert the carrot proposal to an output proposal
 * param: proposal -
 * param: tx_first_key_image -
@@ -147,10 +162,10 @@ void get_output_proposal_normal_v1(const CarrotPaymentProposalV1 &proposal,
 * outparam: encrypted_payment_id_out - pid_enc
 */
 void get_output_proposal_return_v1(const CarrotPaymentProposalV1 &proposal,
-    const crypto::key_image &tx_first_key_image,
-    const view_balance_secret_device *s_view_balance_dev,
-    RCTOutputEnoteProposal &output_enote_out,
-    encrypted_payment_id_t &encrypted_payment_id_out);
+                                   const crypto::key_image &tx_first_key_image,
+                                   const view_balance_secret_device *s_view_balance_dev,
+                                   RCTOutputEnoteProposal &output_enote_out,
+                                   encrypted_payment_id_t &encrypted_payment_id_out);
 /**
 * brief: get_output_proposal_special_v1 - convert the carrot proposal to an output proposal (external selfsend)
 * param: proposal -
diff --git a/src/carrot_impl/carrot_boost_serialization.h b/src/carrot_impl/carrot_boost_serialization.h
index db95215af..3fd001ad2 100644
--- a/src/carrot_impl/carrot_boost_serialization.h
+++ b/src/carrot_impl/carrot_boost_serialization.h
@@ -86,6 +86,12 @@ inline void serialize(Archive &a, carrot::encrypted_return_pubkey_t &x, const bo
 }
 //---------------------------------------------------
 template <class Archive>
+inline void serialize(Archive &a, carrot::rollup_binding_tag_t &x, const boost::serialization::version_type ver)
+{
+    a & x.bytes;
+}
+//---------------------------------------------------
+template <class Archive>
 inline void serialize(Archive &a, carrot::CarrotDestinationV1 &x, const boost::serialization::version_type ver)
 {
     a & x.address_spend_pubkey;
diff --git a/src/carrot_impl/carrot_chain_serialization.h b/src/carrot_impl/carrot_chain_serialization.h
index f911f0660..cc3d40c5a 100644
--- a/src/carrot_impl/carrot_chain_serialization.h
+++ b/src/carrot_impl/carrot_chain_serialization.h
@@ -42,3 +42,4 @@ BLOB_SERIALIZER(carrot::view_tag_t);
 BLOB_SERIALIZER(carrot::encrypted_janus_anchor_t);
 BLOB_SERIALIZER(carrot::encrypted_payment_id_t);
 BLOB_SERIALIZER(carrot::encrypted_return_pubkey_t);
+BLOB_SERIALIZER(carrot::rollup_binding_tag_t);
diff --git a/src/carrot_impl/format_utils.cpp b/src/carrot_impl/format_utils.cpp
index 3ca3b185e..5941858d0 100644
--- a/src/carrot_impl/format_utils.cpp
+++ b/src/carrot_impl/format_utils.cpp
@@ -193,31 +193,51 @@ bool try_load_carrot_extra_v1(
 }
 //-------------------------------------------------------------------------------------------------------------------
 cryptonote::transaction store_carrot_to_transaction_v1(const std::vector<CarrotEnoteV1> &enotes,
-    const std::vector<crypto::key_image> &key_images,
-    const std::vector<cryptonote::tx_source_entry> &sources,
-    const rct::xmr_amount fee,
-    const cryptonote::transaction_type tx_type,
-    const rct::xmr_amount tx_amount_burnt,
-    const std::vector<uint8_t> &change_masks,
-    const carrot::RCTOutputEnoteProposal &return_enote,
-    const encrypted_payment_id_t encrypted_payment_id)
+                                                       const std::vector<crypto::key_image> &key_images,
+                                                       const std::vector<cryptonote::tx_source_entry> &sources,
+                                                       const rct::xmr_amount fee,
+                                                       const cryptonote::transaction_type tx_type,
+                                                       const rct::xmr_amount tx_amount_burnt,
+                                                       const std::vector<uint8_t> &change_masks,
+                                                       const cryptonote::token_metadata_t &token,
+                                                       const carrot::RCTOutputEnoteProposal &return_enote,
+                                                       const encrypted_payment_id_t encrypted_payment_id,
+                                                       const uint8_t hf_version)
 {
     const size_t nins = key_images.size();
     const size_t nouts = enotes.size();
     CHECK_AND_ASSERT_THROW_MES(nins == sources.size(), "invalid inputs/sources size");
     CHECK_AND_ASSERT_THROW_MES(change_masks.size() == nouts, "invalid change masks size. Expected: "  << nouts - 1 << " got: " << change_masks.size());
 
+    // Sanity check asset types - all enotes and sources must be the same
+    std::string asset_type = "";
+    for (const auto &enote: enotes) {
+      if (asset_type == "")
+        asset_type = enote.asset_type;
+      else
+        CHECK_AND_ASSERT_THROW_MES(enote.asset_type == asset_type, "invalid asset_type in enote. Expected: " << asset_type << " got: " << enote.asset_type);
+    }
+    for (const auto &source: sources) {
+      if (asset_type == "")
+        asset_type = source.asset_type;
+      else
+        CHECK_AND_ASSERT_THROW_MES(source.asset_type == asset_type, "invalid asset_type in source. Expected: " << asset_type << " got: " << source.asset_type);
+    }      
+    
     cryptonote::transaction tx;
     tx.pruned = true;
     tx.unlock_time = 0;
-    tx.source_asset_type = "SAL1";
-    tx.destination_asset_type = "SAL1";
-    tx.version = TRANSACTION_VERSION_CARROT;
+    tx.source_asset_type = asset_type;
+    tx.destination_asset_type = asset_type;
+    tx.version = (hf_version >= HF_VERSION_ENABLE_TOKENS) ? TRANSACTION_VERSION_ENABLE_TOKENS : TRANSACTION_VERSION_CARROT;
     tx.type = 
         tx_type == cryptonote::transaction_type::RETURN ? cryptonote::transaction_type::TRANSFER : tx_type;
     tx.amount_burnt = (
-        tx.type == cryptonote::transaction_type::STAKE || tx.type == cryptonote::transaction_type::BURN
-    ) ? tx_amount_burnt : 0;
+                       tx.type == cryptonote::transaction_type::STAKE ||
+                       tx.type == cryptonote::transaction_type::BURN ||
+                       tx.type == cryptonote::transaction_type::CREATE_TOKEN ||
+                       tx.type == cryptonote::transaction_type::ROLLUP
+                       ) ? tx_amount_burnt : 0;
     tx.return_address_change_mask.assign(change_masks.begin(), change_masks.end());
     tx.vin.reserve(nins);
     tx.vout.reserve(nouts);
@@ -239,7 +259,7 @@ cryptonote::transaction store_carrot_to_transaction_v1(const std::vector<CarrotE
         //L
         tx.vin.emplace_back(cryptonote::txin_to_key{ //@TODO: can save 2 bytes by using slim input type
             .amount = 0,
-            .asset_type = "SAL1",
+            .asset_type = asset_type,
             .key_offsets = cryptonote::absolute_output_offsets_to_relative(key_offsets),
             .k_image = key_images.at(i)
         });
@@ -264,7 +284,7 @@ cryptonote::transaction store_carrot_to_transaction_v1(const std::vector<CarrotE
         tx.rct_signatures.outPk.push_back(rct::ctkey{rct::key{}, enote.amount_commitment});
 
         //K_return
-        if (tx_type != cryptonote::transaction_type::STAKE) {
+        if (tx_type != cryptonote::transaction_type::STAKE && tx_type != cryptonote::transaction_type::CREATE_TOKEN) {
             crypto::public_key K_return;
             memcpy(K_return.data, enote.return_enc.bytes, sizeof(crypto::public_key));
             tx.return_address_list.push_back(K_return);
@@ -272,7 +292,7 @@ cryptonote::transaction store_carrot_to_transaction_v1(const std::vector<CarrotE
     }
 
     // store the return pubkey for stake txs
-    if (tx_type == cryptonote::transaction_type::STAKE)
+    if (tx_type == cryptonote::transaction_type::STAKE || tx_type == cryptonote::transaction_type::CREATE_TOKEN)
     {
         tx.protocol_tx_data.version = 1;
         memcpy(tx.protocol_tx_data.return_address.data, return_enote.enote.onetime_address.data, sizeof(crypto::public_key));
@@ -280,7 +300,12 @@ cryptonote::transaction store_carrot_to_transaction_v1(const std::vector<CarrotE
         tx.protocol_tx_data.return_view_tag = return_enote.enote.view_tag;
         tx.protocol_tx_data.return_anchor_enc = return_enote.enote.anchor_enc;
     }
-
+    if (tx_type == cryptonote::transaction_type::CREATE_TOKEN) {
+      tx.token_metadata = token;
+    } else {
+      tx.token_metadata = cryptonote::token_metadata_t{};
+    }
+    
     //ephemeral pubkeys: D_e
     store_carrot_ephemeral_pubkeys_to_extra(enotes, tx.extra);
 
diff --git a/src/carrot_impl/format_utils.h b/src/carrot_impl/format_utils.h
index 20bc6bf71..a325b76e3 100644
--- a/src/carrot_impl/format_utils.h
+++ b/src/carrot_impl/format_utils.h
@@ -102,14 +102,16 @@ bool try_load_carrot_extra_v1(
  * return: a fully populated, pruned, non-coinbase transaction containing given Carrot information
  */
 cryptonote::transaction store_carrot_to_transaction_v1(const std::vector<CarrotEnoteV1> &enotes,
-    const std::vector<crypto::key_image> &key_images,
-    const std::vector<cryptonote::tx_source_entry> &sources,
-    const rct::xmr_amount fee,
-    const cryptonote::transaction_type tx_type,
-    const rct::xmr_amount tx_amount_burnt,
-    const std::vector<uint8_t> &change_masks,
-    const RCTOutputEnoteProposal &return_enote,
-    const encrypted_payment_id_t encrypted_payment_id);
+                                                       const std::vector<crypto::key_image> &key_images,
+                                                       const std::vector<cryptonote::tx_source_entry> &sources,
+                                                       const rct::xmr_amount fee,
+                                                       const cryptonote::transaction_type tx_type,
+                                                       const rct::xmr_amount tx_amount_burnt,
+                                                       const std::vector<uint8_t> &change_masks,
+                                                       const cryptonote::token_metadata_t &token,
+                                                       const RCTOutputEnoteProposal &return_enote,
+                                                       const encrypted_payment_id_t encrypted_payment_id,
+                                                       const uint8_t hf_version);
 /**
  * brief: try_load_carrot_enote_from_transaction_v1 - load one non-coinbase Carrot enote from a cryptonote::transaction
  * param: tx -
diff --git a/src/carrot_impl/input_selection.cpp b/src/carrot_impl/input_selection.cpp
index 3f29917ed..6912da408 100644
--- a/src/carrot_impl/input_selection.cpp
+++ b/src/carrot_impl/input_selection.cpp
@@ -88,7 +88,8 @@ static std::pair<std::size_t, boost::multiprecision::uint128_t> input_count_for_
     const epee::span<const InputCandidate> input_candidates,
     const std::set<std::size_t> &selectable_inputs,
     std::size_t max_num_input_count,
-    const std::map<std::size_t, rct::xmr_amount> &fee_by_input_count)
+    const std::map<std::size_t, rct::xmr_amount> &fee_by_input_count,
+    const bool is_token_transfer)
 {
     // Returns (N, X) where the X is the sum of the amounts of the greatest N <= max_num_input_count
     // inputs from selectable_inputs, maximizing X - F(N). F(N) is the fee for this transaction,
@@ -96,6 +97,7 @@ static std::pair<std::size_t, boost::multiprecision::uint128_t> input_count_for_
     // the fee, but greater than or equal to the difference of the fee compared to excluding that
     // input. If this function returns N == 0, then there aren't enough usable funds, i.e. no N
     // exists such that X - F(N) > 0.
+    // For token transfers, fee is paid separately in SAL1 so we just accumulate all inputs.
 
     if (fee_by_input_count.empty() || selectable_inputs.empty())
         return {0, 0};
@@ -125,6 +127,15 @@ static std::pair<std::size_t, boost::multiprecision::uint128_t> input_count_for_
     {
         const rct::xmr_amount amount = *amount_it;
         const rct::xmr_amount current_fee = fee_by_input_count.at(num_ins + 1);
+        
+        // For token transfers, fee is paid separately in SAL1 - just accumulate inputs
+        if (is_token_transfer)
+        {
+            ++num_ins;
+            cumulative_input_sum += amount;
+            continue;
+        }
+        
         CARROT_CHECK_AND_THROW(current_fee > last_fee,
             carrot_logic_error, "provided fee by input count is not monotonically increasing");
         const rct::xmr_amount marginal_fee_diff = current_fee - last_fee;
@@ -372,11 +383,12 @@ select_inputs_func_t make_single_transfer_input_selector(
 
         // 3. Calculate minimum required input money sum for a given input count
         const bool subtract_fee = flags & IS_KNOWN_FEE_SUBTRACTABLE;
+        const bool is_token_transfer = flags & IS_TOKEN_TRANSFER;
         std::map<std::size_t, boost::multiprecision::uint128_t> required_money_by_input_count;
         for (const auto &fee_and_input_count : fee_by_input_count)
         {
             required_money_by_input_count[fee_and_input_count.first] = 
-                nominal_output_sum + (subtract_fee ? 0 : fee_and_input_count.second);
+                nominal_output_sum + ((subtract_fee || is_token_transfer) ? 0 : fee_and_input_count.second);
         }
         const boost::multiprecision::uint128_t absolute_minimum_required_money
             = required_money_by_input_count.cbegin()->second;
@@ -390,9 +402,10 @@ select_inputs_func_t make_single_transfer_input_selector(
             "Not enough money in all inputs (" << cryptonote::print_money(total_candidate_money)
             << ") to fund minimum output sum (" << cryptonote::print_money(absolute_minimum_required_money) << ')');
 
+        // const bool is_token_transfer = flags & IS_TOKEN_TRANSFER;
         std::set<std::size_t> all_idxs; for (std::size_t i = 0; i < input_candidates.size(); ++i) all_idxs.insert(i);
         const std::pair<std::size_t, boost::multiprecision::uint128_t> max_usable_money =
-            input_count_for_max_usable_money(input_candidates, all_idxs, CARROT_MAX_TX_INPUTS, fee_by_input_count);
+            input_count_for_max_usable_money(input_candidates, all_idxs, CARROT_MAX_TX_INPUTS, fee_by_input_count, is_token_transfer);
         CARROT_CHECK_AND_THROW(max_usable_money.second >= absolute_minimum_required_money,
             not_enough_usable_money,
             "Not enough usable money in top " << max_usable_money.first << " inputs ("
@@ -417,7 +430,7 @@ select_inputs_func_t make_single_transfer_input_selector(
 
             // Skip if not enough money in this selectable set for max number of tx inputs...
             const auto max_usable_money = input_count_for_max_usable_money(input_candidates,
-                input_candidate_subset, CARROT_MAX_TX_INPUTS, fee_by_input_count);
+                input_candidate_subset, CARROT_MAX_TX_INPUTS, fee_by_input_count, is_token_transfer);
             if (!max_usable_money.first)
                 continue;
             else if (max_usable_money.second < required_money_by_input_count.at(max_usable_money.first))
@@ -441,7 +454,7 @@ select_inputs_func_t make_single_transfer_input_selector(
 
                 // Skip if not enough money in this selectable set for exact number of inputs...
                 const auto max_usable_money = input_count_for_max_usable_money(input_candidates,
-                    input_candidate_subset, n_inputs, fee_by_input_count);
+                    input_candidate_subset, n_inputs, fee_by_input_count, is_token_transfer);
                 if (max_usable_money.first != n_inputs)
                     continue;
                 else if (max_usable_money.second < required_money)
diff --git a/src/carrot_impl/input_selection.h b/src/carrot_impl/input_selection.h
index d53f6e943..34b92cb5c 100644
--- a/src/carrot_impl/input_selection.h
+++ b/src/carrot_impl/input_selection.h
@@ -52,14 +52,17 @@ struct InputCandidate
 namespace InputSelectionFlags
 {
     // Quantum forward secrecy (ON = unsafe)
-    static constexpr std::uint32_t ALLOW_EXTERNAL_INPUTS_IN_NORMAL_TRANSFERS   = 1 << 0;
-    static constexpr std::uint32_t ALLOW_PRE_CARROT_INPUTS_IN_NORMAL_TRANSFERS = 1 << 1;
+    static constexpr std::uint32_t ALLOW_EXTERNAL_INPUTS_IN_NORMAL_TRANSFERS   = 1 << 0; // 000..00000001
+    static constexpr std::uint32_t ALLOW_PRE_CARROT_INPUTS_IN_NORMAL_TRANSFERS = 1 << 1; // 000..00000010
     static constexpr std::uint32_t ALLOW_MIXED_INTERNAL_EXTERNAL               = 1 << 2;
     static constexpr std::uint32_t ALLOW_MIXED_CARROT_PRE_CARROT               = 1 << 3;
 
     // Amount handling
     static constexpr std::uint32_t IS_KNOWN_FEE_SUBTRACTABLE                   = 1 << 4;
     static constexpr std::uint32_t ALLOW_DUST                                  = 1 << 5;
+    
+    // Token transfer (fee is paid separately in SAL1 via rollup tx, so no fee for input selection)
+    static constexpr std::uint32_t IS_TOKEN_TRANSFER                           = 1 << 6;
 }
 
 /**
diff --git a/src/carrot_impl/tx_builder_outputs.cpp b/src/carrot_impl/tx_builder_outputs.cpp
index 14c59ccc2..ddd73b99d 100644
--- a/src/carrot_impl/tx_builder_outputs.cpp
+++ b/src/carrot_impl/tx_builder_outputs.cpp
@@ -132,7 +132,9 @@ void make_pruned_transaction_from_proposal_v1(const CarrotTransactionProposalV1
         0, // tx_amount_burnt
         {}, // change_masks
         {}, // return_enote
-        encrypted_payment_id);
+        {0},
+        encrypted_payment_id,
+        /*hf_version=*/10);
 
     // add extra payload and sort
     if (!tx_proposal.extra.empty())
diff --git a/src/carrot_impl/tx_proposal.h b/src/carrot_impl/tx_proposal.h
index 2e0325a7f..dfa8cb0c3 100644
--- a/src/carrot_impl/tx_proposal.h
+++ b/src/carrot_impl/tx_proposal.h
@@ -67,8 +67,8 @@ struct CarrotPaymentProposalVerifiableSelfSendV1
  *
  * For exact details on what goes into the signable transaction hash, see `rct::get_pre_mlsag_hash`.
  */
-struct CarrotTransactionProposalV1
-{
+  struct CarrotTransactionProposalV1
+  {
     /// Key images sorted in std::greater order
     std::vector<crypto::key_image> key_images_sorted;
     // sources in the same order as key_images_sorted.
@@ -89,8 +89,18 @@ struct CarrotTransactionProposalV1
     /// how much money tx burns
     rct::xmr_amount amount_burnt;
 
+    /// used if this is a CREATE_TOKEN transaction
+    cryptonote::token_metadata_t token;
+
     /// This field is truly "extra". It should contain only tx.extra fields that aren't present in a
     /// normal Carrot transaction, i.e. NOT ephemeral pubkeys nor encrypted PIDs
     std::vector<std::uint8_t> extra;
-};
+
+    /// Used if this is a TOKEN_TRANSFER or ROLLUP transaction
+    carrot::rollup_binding_tag_t rollup_binding_tag;
+
+    /// Used if this is a ROLLUP transaction
+    cryptonote::layer2_rollup_data_t layer2_rollup_data;
+  };
+  
 } //namespace carrot
diff --git a/src/carrot_impl/tx_proposal_utils.cpp b/src/carrot_impl/tx_proposal_utils.cpp
index 50026fcf8..98f778145 100644
--- a/src/carrot_impl/tx_proposal_utils.cpp
+++ b/src/carrot_impl/tx_proposal_utils.cpp
@@ -209,17 +209,34 @@ void make_carrot_transaction_proposal_v1(const std::vector<CarrotPaymentProposal
         input_amount_sum += selected_input.amount;
 
     // callback to balance the outputs with the fee and input sum
-    carve_fees_and_balance(input_amount_sum, tx_proposal_out.fee, normal_payment_proposals, selfsend_payment_proposals);
+    std::string asset_type = "SAL1"; // default to SAL1
+    if (!normal_payment_proposals.empty()) {
+        asset_type = normal_payment_proposals.at(0).asset_type;
+    } else if (!selfsend_payment_proposals.empty()) {
+        asset_type = selfsend_payment_proposals.at(0).proposal.asset_type;
+    }
+    uint64_t fee = tx_proposal_out.fee;
+    if (asset_type != "SAL1") {
+      if (tx_type != cryptonote::transaction_type::BURN || asset_type != "SAL") {
+        CARROT_CHECK_AND_THROW(cryptonote::is_valid_custom_asset_type(asset_type),
+                               carrot_logic_error, "make_carrot_transaction_proposal_v1: invalid asset type in payment proposals: " << asset_type);
+      }
+        
+      fee = 0; //fee is always in SAL1
+    }
+    carve_fees_and_balance(input_amount_sum, fee, normal_payment_proposals, selfsend_payment_proposals);
 
     // sanity check balance
-    input_amount_sum -= tx_proposal_out.fee;
+    input_amount_sum -= fee;
     for (const CarrotPaymentProposalV1 &normal_payment_proposal : normal_payment_proposals)
         input_amount_sum -= normal_payment_proposal.amount;
     for (const CarrotPaymentProposalVerifiableSelfSendV1 &selfsend_payment_proposal : selfsend_payment_proposals)
         input_amount_sum -= selfsend_payment_proposal.proposal.amount;
 
     if (tx_type != cryptonote::transaction_type::STAKE &&
-        tx_type != cryptonote::transaction_type::BURN)
+        tx_type != cryptonote::transaction_type::BURN &&
+        tx_type != cryptonote::transaction_type::CREATE_TOKEN &&
+        tx_type != cryptonote::transaction_type::ROLLUP)
     {
         CHECK_AND_ASSERT_THROW_MES(input_amount_sum == 0,
             "make_carrot_transaction_proposal_v1: post-carved transaction does not balance");
@@ -239,7 +256,7 @@ void make_carrot_transaction_proposal_v1(const std::vector<CarrotPaymentProposal
         tx_proposal_out.key_images_sorted.end(),
         std::greater{}); // consensus rules dictate inputs sorted in *reverse* lexicographical order since v7
 
-    // set the transaction type
+    // set the transaction type & new asset type
     tx_proposal_out.tx_type = tx_type;
 }
 //-------------------------------------------------------------------------------------------------------------------
@@ -255,6 +272,7 @@ void make_carrot_transaction_proposal_v1_transfer(
     const subaddress_index_extended &change_address_index,
     const std::set<std::size_t> &subtractable_normal_payment_proposals,
     const std::set<std::size_t> &subtractable_selfsend_payment_proposals,
+    const std::string &asset_type,
     CarrotTransactionProposalV1 &tx_proposal_out)
 {
     std::vector<CarrotPaymentProposalVerifiableSelfSendV1> selfsend_payment_proposals = selfsend_payment_proposals_in;
@@ -276,7 +294,7 @@ void make_carrot_transaction_proposal_v1_transfer(
             .destination_address_spend_pubkey = change_address_spend_pubkey,
             .amount = 0,
             .enote_type = add_payment_type_selfsend ? CarrotEnoteType::PAYMENT : CarrotEnoteType::CHANGE,
-            .asset_type = "SAL1"
+            .asset_type = asset_type
         },
         .subaddr_index = change_address_index
     });
@@ -398,10 +416,13 @@ void make_carrot_transaction_proposal_v1_transfer(
         
         // remove the self send payment we have made to ourself now that we have our change payment.
         if (tx_type == cryptonote::transaction_type::STAKE ||
-            tx_type == cryptonote::transaction_type::BURN)
+            tx_type == cryptonote::transaction_type::BURN ||
+            tx_type == cryptonote::transaction_type::CREATE_TOKEN ||
+            tx_type == cryptonote::transaction_type::ROLLUP)
         {
             selfsend_payment_proposals.back().proposal.enote_ephemeral_pubkey = 
                 selfsend_payment_proposals.front().proposal.enote_ephemeral_pubkey;
+
             selfsend_payment_proposals.erase(selfsend_payment_proposals.begin());
         }
 
@@ -431,6 +452,7 @@ void make_carrot_transaction_proposal_v1_sweep(
     std::vector<CarrotSelectedInput> &&selected_inputs,
     const crypto::public_key &change_address_spend_pubkey,
     const subaddress_index_extended &change_address_index,
+    const std::string &asset_type,
     CarrotTransactionProposalV1 &tx_proposal_out)
 {
     // sanity check payment proposals are provided
@@ -453,6 +475,19 @@ void make_carrot_transaction_proposal_v1_sweep(
     CHECK_AND_ASSERT_THROW_MES(bool(normal_payment_proposals.size()) ^ bool(selfsend_payment_proposals.size()),
         "make carrot transaction proposal v1 sweep: both normal and self-send payment proposals are provided");
 
+    std::vector<CarrotPaymentProposalVerifiableSelfSendV1> selfsend_payment_proposals_inout{selfsend_payment_proposals};
+    //if (tx_type == cryptonote::transaction_type::RETURN) {
+      selfsend_payment_proposals_inout.push_back(carrot::CarrotPaymentProposalVerifiableSelfSendV1{
+              .proposal = carrot::CarrotPaymentProposalSelfSendV1{
+                .destination_address_spend_pubkey = change_address_spend_pubkey,
+                .amount = 0,
+                .enote_type = carrot::CarrotEnoteType::CHANGE,
+                .asset_type = asset_type
+              },
+              .subaddr_index = change_address_index
+            });
+      //   }
+    
     const bool is_selfsend_sweep = !selfsend_payment_proposals.empty();
 
     // define input selection callback, which is just a shuttle for `selected_inputs`
@@ -503,7 +538,7 @@ void make_carrot_transaction_proposal_v1_sweep(
 
     // make unsigned transaction with sweep carving callback and selected inputs
     make_carrot_transaction_proposal_v1(normal_payment_proposals,
-        selfsend_payment_proposals,
+        selfsend_payment_proposals_inout,
         fee_per_weight,
         fee_quantization_mask,
         extra,
diff --git a/src/carrot_impl/tx_proposal_utils.h b/src/carrot_impl/tx_proposal_utils.h
index f35407614..701e8903f 100644
--- a/src/carrot_impl/tx_proposal_utils.h
+++ b/src/carrot_impl/tx_proposal_utils.h
@@ -213,6 +213,7 @@ void make_carrot_transaction_proposal_v1_transfer(
     const subaddress_index_extended &change_address_index,
     const std::set<std::size_t> &subtractable_normal_payment_proposals,
     const std::set<std::size_t> &subtractable_selfsend_payment_proposals,
+    const std::string &asset_type,
     CarrotTransactionProposalV1 &tx_proposal_out);
 
 void make_carrot_transaction_proposal_v1_sweep(
@@ -225,6 +226,7 @@ void make_carrot_transaction_proposal_v1_sweep(
     std::vector<CarrotSelectedInput> &&selected_inputs,
     const crypto::public_key &change_address_spend_pubkey,
     const subaddress_index_extended &change_address_index,
+    const std::string &asset_type,
     CarrotTransactionProposalV1 &tx_proposal_out);
 
 } //namespace carrot
diff --git a/src/cryptonote_basic/cryptonote_basic.h b/src/cryptonote_basic/cryptonote_basic.h
index eab5fe431..563a25664 100644
--- a/src/cryptonote_basic/cryptonote_basic.h
+++ b/src/cryptonote_basic/cryptonote_basic.h
@@ -44,6 +44,7 @@
 #include "serialization/debug_archive.h"
 #include "serialization/crypto.h"
 #include "serialization/keyvalue_serialization.h" // eepe named serialization
+#include "serialization/pair.h"
 #include "serialization/string.h"
 #include "carrot_core/core_types.h"
 #include "carrot_impl/carrot_chain_serialization.h"
@@ -193,8 +194,6 @@ namespace cryptonote
       VARINT_FIELD(amount)
       FIELD(target)
     END_SERIALIZE()
-
-
   };
 
   class protocol_tx_data_t {
@@ -214,6 +213,99 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  struct erc_token_t
+  {
+    uint8_t version;
+    std::string contract_address;
+    std::string lockbox_address;
+    std::string ticker;
+    uint64_t erc20_asset_id; // NOTE: this is NOT the Salvium `asset_type_id`!!!
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(version)
+      FIELD(contract_address)
+      FIELD(lockbox_address)
+      FIELD(ticker)
+      VARINT_FIELD(erc20_asset_id)
+    END_SERIALIZE()
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE(contract_address)
+      KV_SERIALIZE(lockbox_address)
+      KV_SERIALIZE(ticker)
+      KV_SERIALIZE(erc20_asset_id)
+    END_KV_SERIALIZE_MAP()
+  };
+
+  struct sal_token_t
+  {
+    uint8_t version;
+    uint64_t supply;
+    uint64_t size;
+    std::string name;
+    std::string url;
+    crypto::hash signature;
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(version)
+      VARINT_FIELD(supply)
+      VARINT_FIELD(size)
+      FIELD(name)
+      FIELD(url)
+      FIELD(signature)
+    END_SERIALIZE()
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE(supply)
+      KV_SERIALIZE(size)
+      KV_SERIALIZE(name)
+      KV_SERIALIZE(url)
+    END_KV_SERIALIZE_MAP()
+  };
+
+  #define TOKEN_TYPE_UNSET 0
+  #define TOKEN_TYPE_ERC20 1
+  #define TOKEN_TYPE_SAL   2 
+
+  typedef boost::variant<erc_token_t, sal_token_t> token_v;
+  
+  struct token_metadata_t
+  {
+    uint8_t version;
+    std::string asset_type;
+    token_v token;
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(version)
+      FIELD(asset_type)
+      FIELD(token)
+    END_SERIALIZE()
+  };
+
+  class layer2_rollup_tx_t {
+  public:
+    crypto::hash tx_prefix_hash;
+    crypto::key_image first_key_image;
+    uint64_t tx_fee;
+
+    BEGIN_SERIALIZE_OBJECT()
+      FIELD(tx_prefix_hash)
+      FIELD(first_key_image)
+      VARINT_FIELD(tx_fee)
+    END_SERIALIZE()
+  };
+
+  class layer2_rollup_data_t {
+  public:
+    uint8_t version;
+    std::vector<layer2_rollup_tx_t> txs;
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(version)
+      FIELD(txs)
+    END_SERIALIZE()
+  };
+
   class transaction_prefix
   {
 
@@ -246,6 +338,10 @@ namespace cryptonote
 
     protocol_tx_data_t protocol_tx_data;
 
+    carrot::rollup_binding_tag_t rollup_binding_tag;
+    token_metadata_t token_metadata;
+    layer2_rollup_data_t layer2_rollup_data;
+    
     BEGIN_SERIALIZE()
       VARINT_FIELD(version)
       if(version == 0 || CURRENT_TRANSACTION_VERSION < version) return false;
@@ -263,9 +359,8 @@ namespace cryptonote
             FIELD(return_address_list)
             FIELD(return_address_change_mask)
           } else {
-            if (type == cryptonote::transaction_type::STAKE &&
-                version >= TRANSACTION_VERSION_CARROT)
-            {
+            if ((type == cryptonote::transaction_type::STAKE || type == cryptonote::transaction_type::CREATE_TOKEN) &&
+                (version >= TRANSACTION_VERSION_CARROT)) {
               FIELD(protocol_tx_data)
             } else {
               FIELD(return_address)
@@ -277,6 +372,17 @@ namespace cryptonote
           VARINT_FIELD(amount_slippage_limit)
         }
       }
+      if (version < TRANSACTION_VERSION_ENABLE_TOKENS) {
+        return true;
+      }
+      if (type == cryptonote::transaction_type::CREATE_TOKEN) {
+        FIELD(token_metadata)
+      } else if (type == cryptonote::transaction_type::TRANSFER) {
+        FIELD(rollup_binding_tag)
+      } else if (type == cryptonote::transaction_type::ROLLUP) {
+        FIELD(rollup_binding_tag)
+        FIELD(layer2_rollup_data)
+      }
     END_SERIALIZE()
 
   public:
@@ -297,10 +403,14 @@ namespace cryptonote
       protocol_tx_data.return_pubkey = crypto::null_pkey;
       protocol_tx_data.return_view_tag = {};
       protocol_tx_data.return_anchor_enc = {};
+      token_metadata.version = 0;
       source_asset_type.clear();
       destination_asset_type.clear();
       amount_burnt = 0;
       amount_slippage_limit = 0;
+      rollup_binding_tag = {0};
+      token_metadata = {};
+      layer2_rollup_data = {};
     }
   };
 
@@ -564,6 +674,91 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  struct token_block_info {
+    uint64_t block_height;
+    std::map<uint32_t, uint64_t> token_info;  // Replaces the vector
+
+    token_block_info() = default; // default ctor
+
+    explicit token_block_info(const uint64_t h)
+      : block_height(h) {}
+
+    void clear() {
+      block_height = 0;
+      token_info.clear();
+    }
+    
+    std::vector<uint8_t> serialize() const noexcept {
+      constexpr uint8_t version = 1;  // Bump if format changes
+      uint32_t sz = static_cast<uint32_t>(token_info.size());
+      size_t total_size = sizeof(uint8_t) + sizeof(uint64_t) + sizeof(uint32_t) + (sz * (sizeof(uint32_t) + sizeof(uint64_t)));
+      std::vector<uint8_t> buf(total_size);
+      uint8_t* ptr = buf.data();
+
+      std::memcpy(ptr, &version, sizeof(uint8_t));
+      ptr += sizeof(uint8_t);
+
+      std::memcpy(ptr, &block_height, sizeof(uint64_t));
+      ptr += sizeof(uint64_t);
+
+      std::memcpy(ptr, &sz, sizeof(uint32_t));
+      ptr += sizeof(uint32_t);
+
+      for (const auto& p : token_info) {  // Iterates in sorted order
+        std::memcpy(ptr, &p.first, sizeof(uint32_t));
+        ptr += sizeof(uint32_t);
+        std::memcpy(ptr, &p.second, sizeof(uint64_t));
+        ptr += sizeof(uint64_t);
+      }
+      return buf;
+    }
+
+    void deserialize(const uint8_t* data, size_t len) {
+      if (len < sizeof(uint32_t)) {
+        throw std::runtime_error("Invalid serialized data");
+      }
+
+      uint8_t version;
+      std::memcpy(&version, data, sizeof(uint8_t));
+      data += sizeof(uint8_t);
+      len -= sizeof(uint8_t);
+
+      if (version == 0) {  // Legacy: No height/version (your current format)
+        // Handle old blobs: Caller must set block_height externally
+        block_height = 0;  // Or throw if height is mandatory
+      } else if (version == 1) {
+        if (len < sizeof(uint64_t) + sizeof(uint32_t)) {
+          throw std::runtime_error("Invalid serialized data");
+        }
+        std::memcpy(&block_height, data, sizeof(uint64_t));
+        data += sizeof(uint64_t);
+        len -= sizeof(uint64_t);
+      } else {
+        throw std::runtime_error("Unsupported version");
+      }
+
+      uint32_t sz;
+      std::memcpy(&sz, data, sizeof(uint32_t));
+      data += sizeof(uint32_t);
+      len -= sizeof(uint32_t);
+
+      if (len != sz * (sizeof(uint32_t) + sizeof(uint64_t))) {
+        throw std::runtime_error("Invalid serialized data length");
+      }
+
+      token_info.clear();
+      for (uint32_t i = 0; i < sz; ++i) {
+        uint32_t k;
+        uint64_t v;
+        std::memcpy(&k, data, sizeof(uint32_t));
+        data += sizeof(uint32_t);
+        std::memcpy(&v, data, sizeof(uint64_t));
+        data += sizeof(uint64_t);
+        token_info[k] = v;  // Map handles sorting/uniquness
+      }
+    }
+  };
+  
   struct yield_block_info {
     uint64_t block_height;
     uint64_t slippage_total_this_block;
@@ -784,6 +979,9 @@ VARIANT_TAG(binary_archive, cryptonote::txout_to_key, 0x2);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_tagged_key, 0x3);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_carrot_v1, 0x4);
 VARIANT_TAG(binary_archive, cryptonote::protocol_tx_data_t, 0x0);
+VARIANT_TAG(binary_archive, cryptonote::token_metadata_t, 0x0);
+VARIANT_TAG(binary_archive, cryptonote::erc_token_t, 0x0);
+VARIANT_TAG(binary_archive, cryptonote::sal_token_t, 0x1);
 VARIANT_TAG(binary_archive, cryptonote::transaction, 0xcc);
 VARIANT_TAG(binary_archive, cryptonote::block, 0xbb);
 
@@ -797,6 +995,9 @@ VARIANT_TAG(json_archive, cryptonote::txout_to_key, "key");
 VARIANT_TAG(json_archive, cryptonote::txout_to_tagged_key, "tagged_key");
 VARIANT_TAG(json_archive, cryptonote::txout_to_carrot_v1, "carrot_v1");
 VARIANT_TAG(json_archive, cryptonote::protocol_tx_data_t, "protocol_tx_data");
+VARIANT_TAG(json_archive, cryptonote::token_metadata_t, "token_metadata");
+VARIANT_TAG(json_archive, cryptonote::erc_token_t, "erc_token");
+VARIANT_TAG(json_archive, cryptonote::sal_token_t, "sal_token");
 VARIANT_TAG(json_archive, cryptonote::transaction, "tx");
 VARIANT_TAG(json_archive, cryptonote::block, "block");
 
@@ -810,5 +1011,8 @@ VARIANT_TAG(debug_archive, cryptonote::txout_to_key, "key");
 VARIANT_TAG(debug_archive, cryptonote::txout_to_tagged_key, "tagged_key");
 VARIANT_TAG(debug_archive, cryptonote::txout_to_carrot_v1, "carrot_v1");
 VARIANT_TAG(debug_archive, cryptonote::protocol_tx_data_t, "protocol_tx_data");
+VARIANT_TAG(debug_archive, cryptonote::token_metadata_t, "token_metadata");
+VARIANT_TAG(debug_archive, cryptonote::erc_token_t, "erc_token");
+VARIANT_TAG(debug_archive, cryptonote::sal_token_t, "sal_token");
 VARIANT_TAG(debug_archive, cryptonote::transaction, "tx");
 VARIANT_TAG(debug_archive, cryptonote::block, "block");
diff --git a/src/cryptonote_basic/cryptonote_boost_serialization.h b/src/cryptonote_basic/cryptonote_boost_serialization.h
index 1f55a3f60..d673db89a 100644
--- a/src/cryptonote_basic/cryptonote_boost_serialization.h
+++ b/src/cryptonote_basic/cryptonote_boost_serialization.h
@@ -45,6 +45,7 @@
 #include "crypto/crypto.h"
 #include "ringct/rctTypes.h"
 #include "ringct/rctOps.h"
+#include "serialization/containers.h"
 
 namespace boost
 {
@@ -181,6 +182,50 @@ namespace boost
     a & x.return_anchor_enc;
   }
 
+  template <class Archive>
+  inline void serialize(Archive &a, cryptonote::erc_token_t &x, const boost::serialization::version_type ver)
+  {
+    a & x.version;
+    a & x.contract_address;
+    a & x.lockbox_address;
+    a & x.ticker;
+    a & x.erc20_asset_id;
+  }
+
+  template <class Archive>
+  inline void serialize(Archive &a, cryptonote::sal_token_t &x, const boost::serialization::version_type ver)
+  {
+    a & x.version;
+    a & x.supply;
+    a & x.size;
+    a & x.name;
+    a & x.url;
+    a & x.signature;
+  }
+
+  template <class Archive>
+  inline void serialize(Archive &a, cryptonote::token_metadata_t &x, const boost::serialization::version_type ver)
+  {
+    a & x.version;
+    a & x.asset_type;
+    a & x.token;
+  }
+
+  template <class Archive>
+  inline void serialize(Archive &a, cryptonote::layer2_rollup_tx_t &x, const boost::serialization::version_type ver)
+  {
+    a & x.tx_prefix_hash;
+    a & x.first_key_image;
+    a & x.tx_fee;
+  }
+
+  template <class Archive>
+  inline void serialize(Archive &a, cryptonote::layer2_rollup_data_t &x, const boost::serialization::version_type ver)
+  {
+    a & x.version;
+    a & x.txs;
+  }
+
   template <class Archive>
   inline void serialize(Archive &a, cryptonote::transaction_prefix &x, const boost::serialization::version_type ver)
   {
@@ -197,9 +242,8 @@ namespace boost
           a & x.return_address_list;
           a & x.return_address_change_mask;
         } else {
-          if (x.type == cryptonote::transaction_type::STAKE &&
-              x.version >= TRANSACTION_VERSION_CARROT)
-          {
+          if ((x.type == cryptonote::transaction_type::STAKE || x.type == cryptonote::transaction_type::CREATE_TOKEN) &&
+              (x.version >= TRANSACTION_VERSION_CARROT)) {
             a & x.protocol_tx_data;
           } else {
             a & x.return_address;
@@ -211,6 +255,16 @@ namespace boost
         a & x.amount_slippage_limit;
       }
     }
+    if (x.version >= TRANSACTION_VERSION_ENABLE_TOKENS) {
+      if (x.type == cryptonote::transaction_type::CREATE_TOKEN) {
+        a & x.token_metadata;
+      } else if (x.type == cryptonote::transaction_type::TRANSFER) {
+        a & x.rollup_binding_tag;
+      } else if (x.type == cryptonote::transaction_type::ROLLUP) {
+        a & x.rollup_binding_tag;
+        a & x.layer2_rollup_data;
+      }
+    }
   }
 
   template <class Archive>
@@ -229,9 +283,8 @@ namespace boost
           a & x.return_address_list;
           a & x.return_address_change_mask;
         } else {
-          if (x.type == cryptonote::transaction_type::STAKE &&
-              x.version >= TRANSACTION_VERSION_CARROT)
-          {
+          if ((x.type == cryptonote::transaction_type::STAKE || x.type == cryptonote::transaction_type::CREATE_TOKEN) &&
+              (x.version >= TRANSACTION_VERSION_CARROT)) {
             a & x.protocol_tx_data;
           } else {
             a & x.return_address;
@@ -242,6 +295,16 @@ namespace boost
         a & x.destination_asset_type;
         a & x.amount_slippage_limit;
       }
+      if (x.version >= TRANSACTION_VERSION_ENABLE_TOKENS) {
+        if (x.type == cryptonote::transaction_type::CREATE_TOKEN) {
+          a & x.token_metadata;
+        } else if (x.type == cryptonote::transaction_type::TRANSFER) {
+          a & x.rollup_binding_tag;
+        } else if (x.type == cryptonote::transaction_type::ROLLUP) {
+          a & x.rollup_binding_tag;
+          a & x.layer2_rollup_data;
+        }
+      }
     }
     if (x.version == 1)
     {
diff --git a/src/cryptonote_basic/cryptonote_format_utils.cpp b/src/cryptonote_basic/cryptonote_format_utils.cpp
index 22c9eb7e5..fed785034 100644
--- a/src/cryptonote_basic/cryptonote_format_utils.cpp
+++ b/src/cryptonote_basic/cryptonote_format_utils.cpp
@@ -31,6 +31,7 @@
 
 #include <atomic>
 #include <csignal>
+#include <map>
 #include <boost/algorithm/string.hpp>
 #include "wipeable_string.h"
 #include "string_tools.h"
@@ -43,6 +44,7 @@
 #include "crypto/hash.h"
 #include "ringct/rctSigs.h"
 #include "oracle/asset_types.h"
+#include "common/debugging.h"
 
 using namespace epee;
 
@@ -1114,7 +1116,37 @@ namespace cryptonote
     default:
       break;
     }
+    if (asset_type_id)
+    {
+      // Check to see if 1st byte is permitted
+      std::string s, s_prefix;
+      switch (asset_type_id >> 24) {
+      case 0x01:
+        // We have a user-generated token
+        s_prefix = "sal";
+        break;
+      case 0x02:
+        s_prefix = "erc";
+        break;
+      default:
+        ASSERT_MES_AND_THROW("Invalid asset_type_id: " << asset_type_id);
+      }
+
+      // Break up the remaining 3 bytes into 4 chunks of base36/64
+      static const char alphabet[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+      uint32_t asset_type_id_temp = asset_type_id & 0x00FFFFFF;
+      for (int i=0; i<4; ++i) {
+        uint8_t val = asset_type_id_temp & 0x0000003F;
+        if (val >= 36) 
+          ASSERT_MES_AND_THROW("Invalid asset_type_id: " << asset_type_id);
+        s.push_back(alphabet[val]);
+        asset_type_id_temp >>= 6;
+      }
+      std::reverse(s.begin(), s.end());
+      return s_prefix + s;
+    } 
     // Should probably throw() here
+    ASSERT_MES_AND_THROW("Invalid asset_type_id: " << asset_type_id);
     return "";
   }
   //---------------------------------------------------------------
@@ -1129,11 +1161,162 @@ namespace cryptonote
     } else if (asset_type == "") {
       return 0x00000000;
     } else {
-      // Should probably throw() here
-      return static_cast<uint32_t>(-1);
+      if (asset_type.length() != 7) {
+        LOG_ERROR("Custom asset type '" << asset_type << "' has invalid length.");
+        return 0x00000000;
+      }
+      static const std::string alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+      // Check the 4-char type
+      std::string s_type = asset_type.substr(3);
+      std::transform(s_type.begin(), s_type.end(), s_type.begin(),
+                     [](unsigned char c){ return std::toupper(c); });
+      uint32_t asset_id = 0x00000000;
+      for (int i=0; i<s_type.length(); ++i) {
+        uint8_t idx = alphabet.find(s_type.at(i));
+        if (idx == std::string::npos || idx >= 36) {
+          LOG_ERROR("Custom asset type contains invalid char.");
+          return 0x00000000;
+        }
+        asset_id = (asset_id << 6) | (idx & 0x3F);
+      }
+      
+      // Check the 3-char prefix
+      std::string s_prefix = asset_type.substr(0,3);
+      std::transform(s_prefix.begin(), s_prefix.end(), s_prefix.begin(),
+                     [](unsigned char c){ return std::tolower(c); });
+      if (s_prefix == "sal") {
+        asset_id |= 0x01000000;
+      } else if (s_prefix == "erc") {
+        asset_id |= 0x02000000;
+      } else {
+        LOG_ERROR("Custom asset type has invalid prefix.");
+        return 0x00000000;
+      }
+      return asset_id;
     }
   }
   //---------------------------------------------------------------
+  bool is_asset_type_token(const std::string& asset_type)
+  {
+    // SAL, SAL1, BURN are base asset types
+    // erc prefix is not included here
+    if (asset_type.length() >= 3) {
+      std::string prefix = asset_type.substr(0, 3);
+      return (prefix == "sal");
+    }
+    return false;
+  }
+  //---------------------------------------------------------------
+  bool is_valid_asset_type(const std::string& asset_type) {
+    // This method does NOT throw()
+    try {
+      uint32_t asset_id = asset_id_from_type(asset_type);
+      std::string asset_type_check = asset_type_from_id(asset_id);
+      return (asset_type_check == asset_type);
+    }
+    catch (std::exception e) {
+      return false;
+    }
+  }
+  //---------------------------------------------------------------
+  bool is_valid_custom_asset_type(const std::string& asset_type)
+  {
+    if (!is_valid_asset_type(asset_type))
+      return false;
+    
+    // double check with reserved IDs
+    uint32_t id = asset_id_from_type(asset_type);
+    if (id == 0x53414C00 || id == 0x53414C31 || id == 0x4255524E || id == 0x00000000) {
+      return false;
+    }
+
+    return true;
+  }
+  //---------------------------------------------------------------
+  uint64_t get_token_creation_price(const std::string& ticker)
+  {
+    static const std::map<std::string, uint64_t> premium_tickers = {
+      // add more
+      {"USDT", 10000 * COIN},
+      {"USDC", 10000 * COIN},
+      {"WBTC", 10000 * COIN},
+      {"DOGE", 10000 * COIN},
+      {"SHIB", 10000 * COIN},
+      {"AVAX", 10000 * COIN},
+      {"ATOM", 10000 * COIN},
+      {"NEAR", 10000 * COIN},
+      {"TRON", 10000 * COIN},
+      {"HBAR", 10000 * COIN},
+      {"AAVE", 10000 * COIN},
+      {"FLOW", 10000 * COIN},
+      {"EGLD", 10000 * COIN},
+      {"KLAY", 10000 * COIN},
+      {"LUNA", 10000 * COIN},
+      {"DASH", 10000 * COIN},
+      {"NANO", 10000 * COIN},
+      {"CORE", 10000 * COIN},
+      {"BEAM", 10000 * COIN},
+      {"DYDX", 10000 * COIN},
+      {"COMP", 10000 * COIN},
+      {"SAND", 10000 * COIN},
+      {"MANA", 10000 * COIN},
+      {"RUNE", 10000 * COIN},
+      {"PYTH", 10000 * COIN},
+      {"ARKM", 10000 * COIN},
+      {"BLUR", 10000 * COIN},
+      {"STRK", 10000 * COIN},
+      {"PEPE", 10000 * COIN},
+      {"BONK", 10000 * COIN},
+      {"VIUM", 10000 * COIN},
+      {"GOLD", 10000 * COIN},
+      {"SILV", 10000 * COIN},
+      {"CASH", 10000 * COIN},
+      {"EURO", 10000 * COIN},
+      {"PESO", 10000 * COIN},
+      {"BOND", 10000 * COIN},
+      {"FUND", 10000 * COIN},
+      {"BANK", 10000 * COIN},
+      {"SWAP", 10000 * COIN},
+      {"LEND", 10000 * COIN},
+      {"LOAN", 10000 * COIN},
+      {"NOTE", 10000 * COIN},
+      {"HOLD", 10000 * COIN},
+      {"BULL", 10000 * COIN},
+      {"BEAR", 10000 * COIN},
+      {"TECH", 10000 * COIN},
+      {"DATA", 10000 * COIN},
+      {"HASH", 10000 * COIN},
+      {"NODE", 10000 * COIN},
+      {"BYTE", 10000 * COIN},
+      {"GRID", 10000 * COIN},
+      {"CODE", 10000 * COIN},
+      {"META", 10000 * COIN},
+      {"WEB3", 10000 * COIN},
+      {"NFTS", 10000 * COIN},
+      {"DEFI", 10000 * COIN},
+      {"LAND", 10000 * COIN},
+      {"REAL", 10000 * COIN},
+      {"RENT", 10000 * COIN},
+      {"FARM", 10000 * COIN},
+      {"OILX", 10000 * COIN},
+      {"ENRG", 10000 * COIN},
+      {"FUEL", 10000 * COIN},
+      {"VOTE", 10000 * COIN},
+      {"PASS", 10000 * COIN},
+      {"LOCK", 10000 * COIN},
+    };
+
+    // is it a premium ticker
+    auto it = premium_tickers.find(ticker);
+    if (it != premium_tickers.end()) {
+      return it->second;
+    }
+
+    // not premium
+    return 1000 * COIN;
+  }
+  //---------------------------------------------------------------
   /**
    * The various scenarios that are permitted for Salvium are more extensive than
    * they are for Zepyhr / Havan. Specifically, we permit:
@@ -1406,32 +1589,6 @@ namespace cryptonote
           << o.target.type().name() << " and " << tx.vout[0].target.type().name() << ", "
           << "expected matching variant types in transaction");
       }
-
-      // Verify the asset type
-      std::string asset_type;
-      CHECK_AND_ASSERT_MES(cryptonote::get_output_asset_type(o, asset_type), false, "failed to get asset type");
-      if (hf_version < HF_VERSION_SALVIUM_ONE_PROOFS) {
-        // Prior to the first audit, ONLY SAL was supported
-        CHECK_AND_ASSERT_MES(asset_type == "SAL", false, "wrong output asset type:" << asset_type);
-      } else {
-        if (tx.type == cryptonote::transaction_type::AUDIT) {
-          // HERE BE DRAGONS!!!
-          // SRCG: This will NOT always be the case - when we add an audit for SALx it'll need to support that as well
-          // The CHANGE for an AUDIT TX must be SAL (and 0 value, and unspendable, and to the origin wallet, and ...)
-          CHECK_AND_ASSERT_MES(asset_type == "SAL", false, "wrong output asset type:" << asset_type);
-          // LAND AHOY!!!
-        } else if (tx.type == cryptonote::transaction_type::PROTOCOL) {
-          if (hf_version < HF_VERSION_AUDIT1_PAUSE) {
-            // PROTOCOL TXs are responsible for paying out SAL and SAL1 during the first AUDIT
-            CHECK_AND_ASSERT_MES(asset_type == "SAL1" || asset_type == "SAL", false, "wrong output asset type:" << asset_type);
-          } else {
-            CHECK_AND_ASSERT_MES(asset_type == "SAL1", false, "wrong output asset type:" << asset_type);
-          }
-        } else {
-          // All other TX types must only spend + create SAL1 (MINER, TRANSFER)
-          CHECK_AND_ASSERT_MES(asset_type == "SAL1", false, "wrong output asset type:" << asset_type);
-        }
-      }
     }
     return true;
   }
diff --git a/src/cryptonote_basic/cryptonote_format_utils.h b/src/cryptonote_basic/cryptonote_format_utils.h
index c7a83ea8d..2dc4f4107 100644
--- a/src/cryptonote_basic/cryptonote_format_utils.h
+++ b/src/cryptonote_basic/cryptonote_format_utils.h
@@ -135,6 +135,10 @@ namespace cryptonote
   uint64_t get_outs_money_amount(const transaction& tx);
   std::string asset_type_from_id(const uint32_t asset_type_id);
   uint32_t asset_id_from_type(const std::string asset_type);
+  bool is_valid_custom_asset_type(const std::string& asset_type);
+  bool is_valid_asset_type(const std::string& asset_type);
+  bool is_asset_type_token(const std::string& asset_type);
+  uint64_t get_token_creation_price(const std::string& ticker);
   bool get_tx_asset_types(const transaction& tx, const crypto::hash &txid, std::string& source, std::string& destination, const bool is_miner_tx);
   bool get_output_public_key(const cryptonote::tx_out& out, crypto::public_key& output_public_key);
   boost::optional<crypto::view_tag> get_output_view_tag(const cryptonote::tx_out& out);
diff --git a/src/cryptonote_basic/tx_extra.h b/src/cryptonote_basic/tx_extra.h
index 0538f2007..48f21de10 100644
--- a/src/cryptonote_basic/tx_extra.h
+++ b/src/cryptonote_basic/tx_extra.h
@@ -39,6 +39,7 @@
 #define TX_EXTRA_NONCE                      0x02
 #define TX_EXTRA_MERGE_MINING_TAG           0x03
 #define TX_EXTRA_TAG_ADDITIONAL_PUBKEYS     0x04
+#define TX_EXTRA_TAG_TOKEN                  0x80
 #define TX_EXTRA_MYSTERIOUS_MINERGATE_TAG   0xDE
 
 #define TX_EXTRA_NONCE_PAYMENT_ID           0x00
@@ -167,6 +168,15 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  struct tx_extra_token
+  {
+    cryptonote::token_metadata_t token;
+
+    BEGIN_SERIALIZE()
+      FIELD(token)
+    END_SERIALIZE()
+  };
+
   struct tx_extra_mysterious_minergate
   {
     std::string data;
@@ -180,7 +190,7 @@ namespace cryptonote
   //   varint tag;
   //   varint size;
   //   varint data[];
-  typedef boost::variant<tx_extra_padding, tx_extra_pub_key, tx_extra_nonce, tx_extra_merge_mining_tag, tx_extra_additional_pub_keys, tx_extra_mysterious_minergate> tx_extra_field;
+  typedef boost::variant<tx_extra_padding, tx_extra_pub_key, tx_extra_nonce, tx_extra_merge_mining_tag, tx_extra_additional_pub_keys, tx_extra_mysterious_minergate, tx_extra_token> tx_extra_field;
 }
 
 VARIANT_TAG(binary_archive, cryptonote::tx_extra_padding, TX_EXTRA_TAG_PADDING);
@@ -189,3 +199,4 @@ VARIANT_TAG(binary_archive, cryptonote::tx_extra_nonce, TX_EXTRA_NONCE);
 VARIANT_TAG(binary_archive, cryptonote::tx_extra_merge_mining_tag, TX_EXTRA_MERGE_MINING_TAG);
 VARIANT_TAG(binary_archive, cryptonote::tx_extra_additional_pub_keys, TX_EXTRA_TAG_ADDITIONAL_PUBKEYS);
 VARIANT_TAG(binary_archive, cryptonote::tx_extra_mysterious_minergate, TX_EXTRA_MYSTERIOUS_MINERGATE_TAG);
+VARIANT_TAG(binary_archive, cryptonote::tx_extra_token, TX_EXTRA_TAG_TOKEN);
diff --git a/src/cryptonote_config.h b/src/cryptonote_config.h
index f75a6fd3f..90cc27253 100644
--- a/src/cryptonote_config.h
+++ b/src/cryptonote_config.h
@@ -44,10 +44,11 @@
 #define CRYPTONOTE_MAX_TX_PER_BLOCK                     0x10000000
 #define CRYPTONOTE_PUBLIC_ADDRESS_TEXTBLOB_VER          0
 #define CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW            60
-#define CURRENT_TRANSACTION_VERSION                     4
+#define CURRENT_TRANSACTION_VERSION                     5
 #define TRANSACTION_VERSION_2_OUTS                      2
 #define TRANSACTION_VERSION_N_OUTS                      3
 #define TRANSACTION_VERSION_CARROT                      4
+#define TRANSACTION_VERSION_ENABLE_TOKENS               5
 #define CURRENT_BLOCK_MAJOR_VERSION                     1
 #define CURRENT_BLOCK_MINOR_VERSION                     1
 #define CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT              60*60*2
@@ -91,6 +92,8 @@
 #define TREASURY_SAL1_MINT_AMOUNT                       ((uint64_t)130000000000000ull)  // 1.3M
 #define TREASURY_SAL1_MINT_COUNT                        8                               // 8 times
 
+#define CREATE_TOKEN_LOCK_PERIOD                        10
+
 #define DIFFICULTY_TARGET_V2                            120  // seconds
 #define DIFFICULTY_TARGET_V1                            60  // seconds - before first fork
 #define DIFFICULTY_WINDOW_V2                            70 // blocks
@@ -244,6 +247,7 @@
 #define HF_VERSION_AUDIT2                       8
 #define HF_VERSION_AUDIT2_PAUSE                 9
 #define HF_VERSION_CARROT                       10
+#define HF_VERSION_ENABLE_TOKENS                 11
 
 #define HF_VERSION_REQUIRE_VIEW_TAGS            255
 #define HF_VERSION_ENABLE_CONVERT               255
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 567daffe9..82adc191a 100644
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -38,6 +38,7 @@
 
 #include "include_base_utils.h"
 #include "cryptonote_basic/cryptonote_basic_impl.h"
+#include "cryptonote_basic/cryptonote_format_utils.h"
 #include "tx_pool.h"
 #include "blockchain.h"
 #include "blockchain_db/locked_txn.h"
@@ -66,6 +67,8 @@
 #include "net/http_client.h"
 #include "storages/http_abstract_invoke.h"
 
+#include "common/debugging.h"
+
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "blockchain"
 
@@ -1407,7 +1410,7 @@ bool Blockchain::prevalidate_protocol_transaction(const block& b, uint64_t heigh
   uint64_t stake_lock_period = get_config(m_nettype).STAKE_LOCK_PERIOD;
   uint8_t hf_version_submitted = get_ideal_hard_fork_version(height - stake_lock_period - 1);
 
-  if (hf_version >= HF_VERSION_CARROT) {
+  if (hf_version == HF_VERSION_CARROT) {
     if (hf_version_submitted >= HF_VERSION_CARROT || b.protocol_tx.vout.size() == 0) {
       CHECK_AND_ASSERT_MES(b.protocol_tx.version == TRANSACTION_VERSION_CARROT, false, "protocol transaction has wrong version");
     } else {
@@ -1525,6 +1528,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
   case HF_VERSION_AUDIT2:
   case HF_VERSION_AUDIT2_PAUSE:
   case HF_VERSION_CARROT:
+  case HF_VERSION_ENABLE_TOKENS:
     if (b.miner_tx.amount_burnt > 0) {
       CHECK_AND_ASSERT_MES(money_in_use + b.miner_tx.amount_burnt > money_in_use, false, "miner transaction is overflowed by amount_burnt");
       money_in_use += b.miner_tx.amount_burnt;
@@ -1557,7 +1561,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
 }
 //------------------------------------------------------------------
 // SRCG
-bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height, uint8_t hf_version)
+bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height, uint8_t hf_version, const std::vector<std::pair<transaction, blobdata>>& txs)
 {
   LOG_PRINT_L3("Blockchain::" << __func__);
 
@@ -1633,9 +1637,20 @@ bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height,
     }
   }
 
+  // Count CREATE_TOKEN transactions if we're at the right hard fork version
+  size_t create_token_count = 0;
+  if (hf_version >= HF_VERSION_ENABLE_TOKENS && !txs.empty()) {
+    for (const auto& tx_pair : txs) {
+      const transaction& tx = tx_pair.first;
+      if (tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+        create_token_count++;
+      }
+    }
+  }
+
   // Check we have the correct number of entries
   CHECK_AND_ASSERT_MES(
-    b.protocol_tx.vout.size() == yield_payouts.size() + audit_payouts.size() + carrot_yield_payouts.size(), 
+    b.protocol_tx.vout.size() == yield_payouts.size() + audit_payouts.size() + carrot_yield_payouts.size() + create_token_count, 
     false, "Invalid number of outputs in protocol_tx - aborting"
   );
 
@@ -1682,6 +1697,71 @@ bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height,
       );
     }
 
+    if (hf_version >= HF_VERSION_ENABLE_TOKENS) {
+      // Validate create_coin transaction outputs
+      std::vector<std::pair<protocol_tx_data_t, token_metadata_t>> create_token_data;
+      
+      for (const auto& tx_pair : txs) {
+        const transaction& tx = tx_pair.first;
+        if (tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+          create_token_data.push_back(std::make_pair(tx.protocol_tx_data, tx.token_metadata));
+        }
+      }
+      
+      for (const auto& ct_data : create_token_data) {
+        // Verify the output key
+        crypto::public_key out_key;
+        cryptonote::get_output_public_key(b.protocol_tx.vout[output_idx], out_key);
+        CHECK_AND_ASSERT_MES(out_key == ct_data.first.return_address, false, "Incorrect CREATE_TOKEN output key detected in protocol_tx");
+
+        // Verify the return pubkey
+        if (b.protocol_tx.vout.size() > 1) {
+          const auto additional_pubkeys = cryptonote::get_additional_tx_pub_keys_from_extra(b.protocol_tx.extra);
+          CHECK_AND_ASSERT_MES(additional_pubkeys.size() > output_idx, false, "Missing CREATE_TOKEN return pubkey detected in protocol_tx");
+          CHECK_AND_ASSERT_MES(additional_pubkeys[output_idx] == ct_data.first.return_pubkey, false, "Incorrect CREATE_TOKEN return pubkey detected in protocol_tx");
+        } else {
+          const auto main_pubkey = cryptonote::get_tx_pub_key_from_extra(b.protocol_tx.extra);
+          CHECK_AND_ASSERT_MES(main_pubkey == ct_data.first.return_pubkey, false, "Incorrect CREATE_TOKEN return pubkey detected in protocol_tx");
+        }
+
+        // Verify the correct metadata type is provided
+        CHECK_AND_ASSERT_MES(ct_data.second.token.type() == typeid(cryptonote::sal_token_t), false, "Incorred CREATE_TOKEN metadata type detected in protocol_tx");
+        cryptonote::sal_token_t token = boost::get<cryptonote::sal_token_t>(ct_data.second.token);
+        
+        // Verify the output amount
+        uint64_t hi, lo;
+        CHECK_AND_ASSERT_MES(token.supply <= (MONEY_SUPPLY / COIN), false, "Invalid SUPPLY value for CREATE_TOKEN when constructing protocol_tx");
+        lo = mul128(token.supply, COIN, &hi);
+        CHECK_AND_ASSERT_MES(hi == 0, false, "Numeric overflow in CREATE_TOKEN supply");
+        CHECK_AND_ASSERT_MES(b.protocol_tx.vout[output_idx].amount == lo, false, "Incorrect CREATE_TOKEN output amount detected in protocol_tx");
+        
+        // Verify the output asset type (should be the new asset type from protocol_tx_data)
+        std::string expected_asset_type = "sal" + ct_data.second.asset_type;
+        std::string out_asset_type;
+        cryptonote::get_output_asset_type(b.protocol_tx.vout[output_idx], out_asset_type);
+        CHECK_AND_ASSERT_MES(out_asset_type == expected_asset_type, false, "Incorrect CREATE_TOKEN output asset_type detected in protocol_tx");
+        
+        // Validate custom asset type format
+        CHECK_AND_ASSERT_MES(cryptonote::is_valid_custom_asset_type(out_asset_type), false, "CREATE_TOKEN asset type is invalid");
+
+        // Verify the view tag
+        CHECK_AND_ASSERT_MES(
+          boost::get<cryptonote::txout_to_carrot_v1>(
+            b.protocol_tx.vout[output_idx].target
+          ).view_tag == ct_data.first.return_view_tag, false, "Incorrect CREATE_TOKEN view tag detected in protocol_tx"
+        );
+
+        // Verify the anchor encrypted
+        CHECK_AND_ASSERT_MES(
+          boost::get<cryptonote::txout_to_carrot_v1>(
+            b.protocol_tx.vout[output_idx].target
+          ).encrypted_janus_anchor == ct_data.first.return_anchor_enc, false, "Incorrect CREATE_TOKEN anchor detected in protocol_tx"
+        );
+        
+        output_idx++;
+      }
+    }
+
     return true;
   }
   
@@ -1974,19 +2054,46 @@ bool Blockchain::create_block_template(block& b, const crypto::hash *from_block,
   
   CHECK_AND_ASSERT_MES(diffic, false, "difficulty overhead.");
 
+  std::vector<cryptonote::protocol_data_entry> protocol_entries;
   size_t txs_weight;
   uint64_t fee;
-  
-  if (!m_tx_pool.fill_block_template(b, median_weight, already_generated_coins, txs_weight, fee, expected_reward, b.major_version))
+  std::vector<std::pair<protocol_tx_data_t, token_metadata_t>> create_token_entries;
+  if (!m_tx_pool.fill_block_template(b, median_weight, already_generated_coins, txs_weight, fee, expected_reward, create_token_entries, b.major_version))
   {
     return false;
   }
 
+  // create the protocol transaction entries for CREATE_TOKEN TXs
+  if (b.major_version >= HF_VERSION_ENABLE_TOKENS) {
+    for (const auto& ct_data_entry: create_token_entries) {
+      CHECK_AND_ASSERT_MES(ct_data_entry.second.token.type() == typeid(cryptonote::sal_token_t), false, "Incorred CREATE_TOKEN metadata type detected in protocol_tx");
+      cryptonote::sal_token_t token = boost::get<cryptonote::sal_token_t>(ct_data_entry.second.token);
+      cryptonote::protocol_data_entry entry;
+      uint64_t hi, lo;
+      CHECK_AND_ASSERT_MES(token.supply <= (MONEY_SUPPLY / COIN), false, "Invalid SUPPLY value for CREATE_TOKEN when constructing protocol_tx");
+      CHECK_AND_ASSERT_MES(token.supply > 0, false, "Invalid SUPPLY value for CREATE_TOKEN when constructing protocol_tx");
+      lo = mul128(token.supply, COIN, &hi);
+      CHECK_AND_ASSERT_MES(hi == 0, false, "Numeric overflow in CREATE_TOKEN supply");
+      entry.amount_burnt = cryptonote::get_token_creation_price(ct_data_entry.second.asset_type);
+      entry.amount_minted = lo;
+      entry.amount_slippage_limit = 0;
+      entry.source_asset = "SAL1";
+      entry.destination_asset = "sal" + ct_data_entry.second.asset_type;
+      entry.type = cryptonote::transaction_type::CREATE_TOKEN;
+      entry.return_address = ct_data_entry.first.return_address;
+      entry.return_pubkey = ct_data_entry.first.return_pubkey;
+      entry.return_view_tag = ct_data_entry.first.return_view_tag;
+      entry.return_anchor_enc = ct_data_entry.first.return_anchor_enc;
+      entry.is_carrot = true;
+      entry.origin_height = height;
+      protocol_entries.push_back(entry);
+    }
+  }
+
   // Check to see if there are any matured YIELD TXs
   uint64_t yield_lock_period = get_config(m_nettype).STAKE_LOCK_PERIOD;
   uint64_t start_height = (height > yield_lock_period) ? height - yield_lock_period - 1 : 0;
 
-  std::vector<cryptonote::protocol_data_entry> protocol_entries;
   cryptonote::yield_block_info ybi_matured;
   bool ok = get_ybi_entry(start_height, ybi_matured);
   if (ok && ybi_matured.locked_coins_this_block > 0) {
@@ -3727,7 +3834,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
 
   if (hf_version >= HF_VERSION_CARROT) {
     // from v10, force the new SalviumOne RCT data
-    if (tx.type == cryptonote::transaction_type::TRANSFER || tx.type == cryptonote::transaction_type::STAKE || tx.type == cryptonote::transaction_type::BURN || tx.type == cryptonote::transaction_type::CONVERT || tx.type == cryptonote::transaction_type::AUDIT) {
+    if (tx.type == cryptonote::transaction_type::TRANSFER || tx.type == cryptonote::transaction_type::STAKE || tx.type == cryptonote::transaction_type::BURN || tx.type == cryptonote::transaction_type::CONVERT || tx.type == cryptonote::transaction_type::AUDIT || tx.type == cryptonote::transaction_type::CREATE_TOKEN || tx.type == cryptonote::transaction_type::ROLLUP) {
       if (tx.rct_signatures.type != rct::RCTTypeSalviumOne) {
         MERROR_VER("SalviumOne data required after v" + std::to_string(HF_VERSION_CARROT));
         tvc.m_invalid_output = true;
@@ -3782,6 +3889,100 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
 
   return true;
 }
+//------------------------------------------------------------------
+bool Blockchain::check_tx_asset_types(const transaction& tx, tx_verification_context &tvc) const
+{
+  LOG_PRINT_L3("Blockchain::" << __func__);
+  CRITICAL_REGION_LOCAL(m_blockchain_lock);
+
+  const uint8_t hf_version = m_hardfork->get_current_version();
+  if (hf_version >= HF_VERSION_ENABLE_TOKENS) {
+
+    // Get the valid tokens according to the DB
+    std::map<std::string, cryptonote::token_metadata_t> mapTokens = m_db->get_tokens();
+    
+    if (tx.type == cryptonote::transaction_type::PROTOCOL || tx.type == cryptonote::transaction_type::MINER) {
+      return true;
+    } else if (
+      tx.type == cryptonote::transaction_type::CREATE_TOKEN ||
+      tx.type == cryptonote::transaction_type::ROLLUP ||
+      tx.type == cryptonote::transaction_type::STAKE
+    ) {
+      if (tx.source_asset_type != "SAL1" || tx.destination_asset_type != "SAL1") {
+        MERROR_VER("Invalid source/dest asset type for CREATE_TOKEN / ROLLUP / STAKE - provided source asset: " << tx.source_asset_type << ", and destination asset: " << tx.destination_asset_type << ", expected SAL1");
+        tvc.m_verifivation_failed = true; 
+        return false;
+      }
+    } else if (tx.type == cryptonote::transaction_type::BURN) {
+      if ((tx.source_asset_type != "SAL" && tx.source_asset_type != "SAL1") || tx.destination_asset_type != tx.source_asset_type) {
+        MERROR_VER("Invalid source/dest asset type for BURN - provided source asset: " << tx.source_asset_type << ", and destination asset: " << tx.destination_asset_type << ", expected (matching) SAL/SAL1");
+        tvc.m_verifivation_failed = true; 
+        return false;
+      }
+    } else if (tx.type == cryptonote::transaction_type::TRANSFER) {
+      if (tx.source_asset_type != tx.destination_asset_type) {
+        MERROR_VER("Mismatched asset types for TRANSFER - provided source asset: " << tx.source_asset_type << ", provided destination asset: " << tx.destination_asset_type << ", expected them to match");
+        tvc.m_verifivation_failed = true;
+        return false;
+      } else if (!(tx.source_asset_type == "SAL1" || mapTokens.count(tx.source_asset_type))) {
+        MERROR_VER("Invalid source asset type for TRANSFER - provided source asset: " << tx.source_asset_type << ", expected valid token type or SAL1");
+        tvc.m_verifivation_failed = true;
+        return false;
+      } else if (tx.destination_asset_type != "SAL1" && !mapTokens.count(tx.destination_asset_type)) {
+        MERROR_VER("Invalid destination asset type for TRANSFER - provided destination asset: " << tx.destination_asset_type << ", expected valid token type or SAL1");
+        tvc.m_verifivation_failed = true;
+        return false;
+      }
+    } else if (tx.type == cryptonote::transaction_type::AUDIT || tx.type == cryptonote::transaction_type::CONVERT) {
+      MERROR_VER("AUDIT and CONVERT transaction types are not allowed in this hardfork version:" << std::to_string(HF_VERSION_ENABLE_TOKENS));
+    } else {
+      MERROR_VER("Unknown transaction type: " << tx.type << ".");
+      tvc.m_verifivation_failed = true;
+      return false;
+    }
+  } else if (hf_version >= HF_VERSION_CARROT) {
+    if (tx.source_asset_type != "SAL1" || tx.destination_asset_type != "SAL1") {
+      MERROR_VER("Invalid destination/source asset type - provided destination asset: " << tx.destination_asset_type << ", expected SAL1" << ", provided source asset: " << tx.source_asset_type << ", expected SAL1");
+      tvc.m_verifivation_failed = true;
+      return false;
+    }
+    // }
+  } else if (hf_version >= HF_VERSION_SALVIUM_ONE_PROOFS) {
+    // protocol and miner txs don't have source and destination asset types
+    if (tx.type == cryptonote::transaction_type::PROTOCOL || tx.type == cryptonote::transaction_type::MINER) {
+      return true;
+    } else if (tx.type == cryptonote::transaction_type::AUDIT) {
+      CHECK_AND_ASSERT_MES(tx.source_asset_type == "SAL" && tx.destination_asset_type == "SAL", false, "wrong source/destination asset type: provided source asset " << tx.source_asset_type << " expected SAL and provided destination asset " << tx.destination_asset_type << " expected SAL");
+    } else if (tx.type == cryptonote::transaction_type::BURN) {
+      if (tx.source_asset_type != "SAL1" || tx.destination_asset_type != "BURN") {
+        MERROR_VER("Invalid source/dest asset type for BURN - provided source asset: " << tx.source_asset_type << ", and destination asset: " << tx.destination_asset_type << ", expected SAL1 and BURN respectively");
+        tvc.m_verifivation_failed = true;
+        return false;
+      }
+    } else {
+      CHECK_AND_ASSERT_MES(tx.source_asset_type == "SAL1" && tx.destination_asset_type == "SAL1", false, "wrong source/destination asset type: provided source asset: " << tx.source_asset_type << " expected SAL1 and provided destination asset: " << tx.destination_asset_type << " expected SAL1");
+    }
+  } else {
+    if (tx.type == cryptonote::transaction_type::BURN) {
+      if (tx.source_asset_type != "SAL" || tx.destination_asset_type != "BURN") {
+        MERROR_VER("Invalid source/dest asset type for BURN - provided source asset: " << tx.source_asset_type << ", and destination asset: " << tx.destination_asset_type << ", expected SAL and BURN respectively");
+        tvc.m_verifivation_failed = true;
+        return false;
+      }
+    }
+    //only SAL existed before hf 6
+    else{
+      if (tx.source_asset_type != "SAL" || tx.destination_asset_type != "SAL") {
+      MERROR_VER("Invalid destination/source asset type - provided destination asset: " << tx.destination_asset_type << ", expected SAL" << ", provided source asset: " << tx.source_asset_type << ", expected SAL");
+      tvc.m_verifivation_failed = true;
+      return false;}
+    }
+  }
+
+  return true;
+}
+
+ 
 //------------------------------------------------------------------
 bool Blockchain::check_tx_type_and_version(const transaction& tx, tx_verification_context &tvc) const
 {
@@ -3808,6 +4009,25 @@ bool Blockchain::check_tx_type_and_version(const transaction& tx, tx_verificatio
     }
   }
 
+  // Reverse the order of checking now, because we're using >=
+  if (hf_version >= HF_VERSION_ENABLE_TOKENS) {
+    if (tx.type == cryptonote::transaction_type::TRANSFER ||
+        tx.type == cryptonote::transaction_type::RETURN ||
+        tx.type == cryptonote::transaction_type::ROLLUP ||
+        tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+      if (tx.version < TRANSACTION_VERSION_ENABLE_TOKENS) {
+      }
+    } else {
+      if (tx.version != TRANSACTION_VERSION_ENABLE_TOKENS) {
+      }
+      if (tx.type == cryptonote::transaction_type::PROTOCOL) {
+        // Allowed multiple asset_types for `vout` entries 
+      } else {
+        // No mixing of asset_types permitted - verify here
+      }
+    }
+  }
+  
   // After v2 allow N-out TXs for TRANSFER ONLY
   if (hf_version >= HF_VERSION_ENABLE_N_OUTS && hf_version < HF_VERSION_CARROT) {
     if (tx.version >= TRANSACTION_VERSION_N_OUTS && tx.type != cryptonote::transaction_type::TRANSFER) {
@@ -3817,7 +4037,15 @@ bool Blockchain::check_tx_type_and_version(const transaction& tx, tx_verificatio
     }
   }
 
-  if (hf_version >= HF_VERSION_CARROT) {
+  if (hf_version >= HF_VERSION_ENABLE_TOKENS) {
+    if (tx.version != TRANSACTION_VERSION_ENABLE_TOKENS) {
+      MERROR("TX version " + std::to_string(tx.version) + " is not supported, expected " + std::to_string(TRANSACTION_VERSION_ENABLE_TOKENS));
+      tvc.m_version_mismatch = true;
+      return false;
+    }
+  }
+
+  if (hf_version == HF_VERSION_CARROT) {
     if (tx.version != TRANSACTION_VERSION_CARROT) {
       MERROR("TX version " + std::to_string(tx.version) + " is not supported, expected " + std::to_string(TRANSACTION_VERSION_CARROT));
       tvc.m_version_mismatch = true;
@@ -3834,6 +4062,19 @@ bool Blockchain::check_tx_type_and_version(const transaction& tx, tx_verificatio
     }
   }
 
+  // Make sure CREATE_TOKEN TXs are disabled until we are ready - belt and braces!
+  if (hf_version < HF_VERSION_ENABLE_TOKENS) {
+    if (tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+      MERROR("CREATE_TOKEN TXs are not permitted prior to v" + std::to_string(HF_VERSION_ENABLE_TOKENS));
+      tvc.m_version_mismatch = true;
+      return false;
+    }
+    if (tx.type == cryptonote::transaction_type::ROLLUP) {
+      MERROR("ROLLUP TXs are not permitted prior to v" + std::to_string(HF_VERSION_ENABLE_TOKENS));
+      tvc.m_version_mismatch = true;
+      return false;
+    }
+  }
 
   if (tx.type == cryptonote::transaction_type::AUDIT) {
     // Make sure we are supposed to accept AUDIT txs at this point
@@ -3841,25 +4082,23 @@ bool Blockchain::check_tx_type_and_version(const transaction& tx, tx_verificatio
     CHECK_AND_ASSERT_MES(audit_hard_forks.find(hf_version) != audit_hard_forks.end(), false, "trying to audit outside an audit fork");
     std::string expected_asset_type = audit_hard_forks.at(hf_version).second.first;
     CHECK_AND_ASSERT_MES(tx.source_asset_type == expected_asset_type, false, "trying to spend " << tx.source_asset_type << " coins in an AUDIT TX");
-  } else {
-    if (hf_version >= HF_VERSION_SALVIUM_ONE_PROOFS) {
-      CHECK_AND_ASSERT_MES(tx.source_asset_type == "SAL1", false, "trying to spend " << tx.source_asset_type << " coins in a non-AUDIT TX");
-    } else {
-      CHECK_AND_ASSERT_MES(tx.source_asset_type == "SAL", false, "trying to spend " << tx.source_asset_type << " coins in a non-AUDIT TX");
-    }
   }
 
-  if (tx.type == cryptonote::transaction_type::BURN) {
-    CHECK_AND_ASSERT_MES(tx.destination_asset_type == "BURN", false, "incorrect burn tx destination type:" << tx.destination_asset_type);
-  } else {
-    if (tx.source_asset_type != tx.destination_asset_type) {
-      MERROR_VER("Tx " << get_transaction_hash(tx) << " has mismatched asset types: " << tx.source_asset_type << " != " << tx.destination_asset_type);
+  if (tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+    // Check that the specific asset_type being created isn't already in our list of tokens
+    std::map<std::string, cryptonote::token_metadata_t> mapTokens = m_db->get_tokens();
+    std::string asset_type = "sal" + tx.token_metadata.asset_type;
+    if (mapTokens.count(asset_type)) {
+      MERROR("TX attempting to create '" + asset_type + "', which already exists");
       tvc.m_verifivation_failed = true;
       return false;
     }
+    // Validate token metadata //! check */
+    CHECK_AND_ASSERT_MES(tx.token_metadata.token.type() == typeid(cryptonote::sal_token_t), false, "Invalid CREATE_TOKEN metadata type");
+    cryptonote::sal_token_t token = boost::get<cryptonote::sal_token_t>(tx.token_metadata.token);
+    CHECK_AND_ASSERT_MES(token.supply > 0 && token.supply <= (MONEY_SUPPLY / COIN), false, "Invalid SUPPLY value for CREATE_TOKEN");
   }
   
-
   // Check for invalid TX types
   if (tx.type == cryptonote::transaction_type::UNSET || tx.type > cryptonote::transaction_type::MAX) {
     MERROR("TX type `" + std::to_string(tx.type) + "' is not supported");
@@ -3894,7 +4133,7 @@ bool Blockchain::have_tx_keyimges_as_spent(const transaction &tx) const
 bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_prefix_hash, const std::vector<std::vector<rct::ctkey>> &pubkeys, const uint8_t &hf_version)
 {
   PERF_TIMER(expand_transaction_2);
-  CHECK_AND_ASSERT_MES(tx.version == 2 || tx.version == 3 || tx.version == 4, false, "Transaction version is not 2/3/4");
+  CHECK_AND_ASSERT_MES(tx.version == 2 || tx.version == 3 || tx.version == 4 || tx.version == 5, false, "Transaction version is not 2/3/5");
 
   rct::rctSig &rv = tx.rct_signatures;
 
@@ -4039,11 +4278,13 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
         const txin_to_key& in_to_key = boost::get<txin_to_key>(txin);
         if (in_to_key.amount == 0)
         {
-          // always consider rct inputs mixable. Even if there's not enough rct
-          // inputs on the chain to mix with, this is going to be the case for
-          // just a few blocks right after the fork at most
-          ++n_mixable;
-        }
+          // don't always consider rct inputs mixable!
+          uint64_t n_outputs = m_db->get_num_outputs_of_asset_type(in_to_key.asset_type);
+          if (n_outputs <= min_mixin)
+            ++n_unmixable;
+          else
+            ++n_mixable;
+        }  
         else
         {
           uint64_t n_outputs = m_db->get_num_outputs(in_to_key.amount);
@@ -4954,6 +5195,18 @@ bool Blockchain::get_ybi_entry(const uint64_t height, cryptonote::yield_block_in
   return true;
 }
 //------------------------------------------------------------------
+bool Blockchain::is_tx_paid_for(const cryptonote::transaction& tx)
+{
+  // Is it a TRANSFER?
+  if (tx.type != cryptonote::transaction_type::TRANSFER)
+    return true;
+  // Is is a TOKEN?
+  if (!cryptonote::is_asset_type_token(tx.source_asset_type))
+    return true;
+  // Has the TRANSFER TOKEN been paid for?
+  return m_db->is_tx_paid_for(tx);
+}
+//------------------------------------------------------------------
 //TODO: revisit, has changed a bit on upstream
 bool Blockchain::check_block_timestamp(std::vector<uint64_t>& timestamps, const block& b, uint64_t& median_ts) const
 {
@@ -5360,7 +5613,7 @@ leave:
   TIME_MEASURE_FINISH(vmt);
 
   TIME_MEASURE_START(vpt);
-  if(!validate_protocol_transaction(bl, blockchain_height, m_hardfork->get_current_version()))
+  if(!validate_protocol_transaction(bl, blockchain_height, m_hardfork->get_current_version(), txs))
   {
     MERROR_VER("Block with id: " << id << " has incorrect protocol transaction");
     bvc.m_verifivation_failed = true;
@@ -6512,7 +6765,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "fb30b46662cb1cfca74d443d66be5860936f9fd904ba5c6f8daecb926ce545f0";
+static const char expected_block_hashes_hash[] = "7e6c9efd949afb36bce062bbb720605f0dd67b03c0124e5167c527fa59c15ce3";
 void Blockchain::load_compiled_in_block_hashes(const GetCheckpointsCallback& get_checkpoints)
 {
   if (get_checkpoints == nullptr || !m_fast_sync)
diff --git a/src/cryptonote_core/blockchain.h b/src/cryptonote_core/blockchain.h
index 138d8a7aa..c3348fdfc 100644
--- a/src/cryptonote_core/blockchain.h
+++ b/src/cryptonote_core/blockchain.h
@@ -726,6 +726,19 @@ namespace cryptonote
      */
     bool check_tx_outputs(const transaction& tx, tx_verification_context &tvc) const;
 
+    /**
+     * @brief check a transaction's input/output/TX asset types conform to current standards
+     *
+     * This function checks, for example at the time of this writing, that
+     * the asset types are supported by the given TX for the current HF version on-chain.
+     *
+     * @param tx the transaction to check the asset types of
+     * @param tvc returned info about tx verification
+     *
+     * @return false if the TX version and/or type is unsupported, otherwise true
+     */
+    bool check_tx_asset_types(const transaction& tx, tx_verification_context &tvc) const;
+    
     /**
      * @brief check that a transaction's version & type conforms to current standards
      *
@@ -1233,6 +1246,8 @@ namespace cryptonote
      */
     bool validate_ybi_cache();
 
+    bool is_tx_paid_for(const cryptonote::transaction& tx);
+    
 #ifndef IN_UNIT_TESTS
   private:
 #endif
@@ -1564,10 +1579,11 @@ namespace cryptonote
      * @param b the block containing the miner transaction to be validated
      * @param height the blockchain's weight
      * @param version hard fork version for that transaction
+     * @param txs create_coin transactions in the block
      *
      * @return false if anything is found wrong with the protocol transaction, otherwise true
      */
-    bool validate_protocol_transaction(const block& b, uint64_t height, uint8_t hf_version);
+    bool validate_protocol_transaction(const block& b, uint64_t height, uint8_t hf_version, const std::vector<std::pair<transaction, blobdata>>& txs = std::vector<std::pair<transaction, blobdata>>());
 
     /**
      * @brief reverts the blockchain to its previous state following a failed switch
diff --git a/src/cryptonote_core/cryptonote_core.cpp b/src/cryptonote_core/cryptonote_core.cpp
index a5de618c5..ea3e54680 100644
--- a/src/cryptonote_core/cryptonote_core.cpp
+++ b/src/cryptonote_core/cryptonote_core.cpp
@@ -843,7 +843,8 @@ namespace cryptonote
     bad_semantics_txes_lock.unlock();
 
     uint8_t hf_version = m_blockchain_storage.get_current_hard_fork_version();
-    const size_t max_tx_version = hf_version >= HF_VERSION_CARROT ? TRANSACTION_VERSION_CARROT :
+    const size_t max_tx_version = hf_version >= HF_VERSION_ENABLE_TOKENS ? TRANSACTION_VERSION_ENABLE_TOKENS :
+                                  hf_version >= HF_VERSION_CARROT ? TRANSACTION_VERSION_CARROT :
                                   hf_version >= HF_VERSION_ENABLE_N_OUTS ? TRANSACTION_VERSION_N_OUTS :
                                   TRANSACTION_VERSION_2_OUTS;
     if (tx.version == 0 || tx.version > max_tx_version)
@@ -904,6 +905,7 @@ namespace cryptonote
   //-----------------------------------------------------------------------------------------------
   bool core::handle_incoming_tx_accumulated_batch(std::vector<tx_verification_batch_info> &tx_info, bool keeped_by_block)
   {
+    const uint8_t hf_version = m_blockchain_storage.get_current_hard_fork_version();
     bool ret = true;
     if (keeped_by_block && get_blockchain_storage().is_within_compiled_block_hash_area())
     {
@@ -925,7 +927,6 @@ namespace cryptonote
       if (tx_info[n].tx->version < 2)
         continue;
       const rct::rctSig &rv = tx_info[n].tx->rct_signatures;
-      const uint8_t hf_version = m_blockchain_storage.get_current_hard_fork_version();
       if (hf_version >= HF_VERSION_CARROT) {
         if (rv.type != rct::RCTTypeNull && rv.type != rct::RCTTypeSalviumOne) {
           MERROR_VER("Invalid RCT type provided");
@@ -950,7 +951,11 @@ namespace cryptonote
           tx_info[n].result = false;
           return false;
         }
-      }            
+      }
+      bool need_rollup = false;
+      if (hf_version >= HF_VERSION_CARROT) {
+        need_rollup = (tx_info[n].tx->source_asset_type != "SAL1");
+      }
       switch (rv.type) {
         case rct::RCTTypeNull:
           // coinbase should not come here, so we reject for all other types
@@ -965,7 +970,8 @@ namespace cryptonote
                                           tx_info[n].tx->type == cryptonote::transaction_type::CONVERT ? tx_info[n].tx->amount_burnt :
                                           tx_info[n].tx->type == cryptonote::transaction_type::STAKE ? tx_info[n].tx->amount_burnt :
                                           tx_info[n].tx->type == cryptonote::transaction_type::AUDIT ? tx_info[n].tx->amount_burnt :
-                                          0
+                                          0,
+                                          need_rollup
                                           ))
           {
             MERROR_VER("rct signature semantics check failed");
@@ -1030,12 +1036,19 @@ namespace cryptonote
           continue;
         if (tx_info[n].tx->rct_signatures.type != rct::RCTTypeBulletproof && tx_info[n].tx->rct_signatures.type != rct::RCTTypeBulletproof2 && tx_info[n].tx->rct_signatures.type != rct::RCTTypeCLSAG && tx_info[n].tx->rct_signatures.type != rct::RCTTypeBulletproofPlus && tx_info[n].tx->rct_signatures.type != rct::RCTTypeFullProofs && tx_info[n].tx->rct_signatures.type != rct::RCTTypeSalviumZero && tx_info[n].tx->rct_signatures.type != rct::RCTTypeSalviumOne)
           continue;
+        bool need_rollup = false;
+        if (hf_version >= HF_VERSION_CARROT) {
+          need_rollup = (tx_info[n].tx->source_asset_type != "SAL1");
+        }
         if (!rct::verRctSemanticsSimple(tx_info[n].tx->rct_signatures,
                                         tx_info[n].tx->type == cryptonote::transaction_type::BURN ? tx_info[n].tx->amount_burnt :
                                         tx_info[n].tx->type == cryptonote::transaction_type::CONVERT ? tx_info[n].tx->amount_burnt :
                                         tx_info[n].tx->type == cryptonote::transaction_type::STAKE ? tx_info[n].tx->amount_burnt :
                                         tx_info[n].tx->type == cryptonote::transaction_type::AUDIT ? tx_info[n].tx->amount_burnt :
-                                        0
+                                        tx_info[n].tx->type == cryptonote::transaction_type::CREATE_TOKEN ? tx_info[n].tx->amount_burnt :
+                                        tx_info[n].tx->type == cryptonote::transaction_type::ROLLUP ? tx_info[n].tx->amount_burnt :
+                                        0,
+                                        need_rollup
                                         ))
         {
           set_semantics_failed(tx_info[n].tx_hash);
@@ -1249,6 +1262,13 @@ namespace cryptonote
       return false;
     }
 
+    /*
+    if (hf_version >= HF_VERSION_ENABLE_TOKENS && !m_blockchain_storage.is_tx_paid_for(tx))
+    {
+      MERROR_VER("tx has not been paid for by ROLLUP");
+      return false;
+    }
+    */
     return true;
   }
   //-----------------------------------------------------------------------------------------------
diff --git a/src/cryptonote_core/cryptonote_tx_utils.cpp b/src/cryptonote_core/cryptonote_tx_utils.cpp
index 7f821135e..a9ead0ff4 100644
--- a/src/cryptonote_core/cryptonote_tx_utils.cpp
+++ b/src/cryptonote_core/cryptonote_tx_utils.cpp
@@ -346,7 +346,7 @@ namespace cryptonote
 
     // Clear the TX contents
     tx.set_null();
-    tx.version = 2;
+    tx.version = (hard_fork_version >= HF_VERSION_ENABLE_TOKENS) ? 3 : 2;
     bool carrot_found = false;
     bool noncarrot_found = false;
     tx.type = cryptonote::transaction_type::PROTOCOL;
@@ -356,7 +356,7 @@ namespace cryptonote
       if (entry.is_carrot) carrot_found = true;
       else noncarrot_found = true;
     }
-    
+
     if (carrot_found && noncarrot_found) {
       LOG_ERROR("Cannot mix Carrot and non-Carrot outputs in the same protocol transaction");
       return false;
@@ -365,7 +365,7 @@ namespace cryptonote
       LOG_ERROR("Carrot outputs found in CryptoNote protocol transaction");
       return false;
     }
-    
+
     if (carrot_found || (!noncarrot_found && hard_fork_version >= HF_VERSION_CARROT))
     {
       // Ensure the TX version is correct
@@ -381,7 +381,8 @@ namespace cryptonote
           // Build the proposal
           carrot::CarrotCoinbaseEnoteV1 e;
           e.onetime_address = entry.return_address;
-          e.amount = entry.amount_burnt;
+          // amount_minted for CREATE_TOKEN, amount_burnt for STAKE/AUDIT
+          e.amount = (entry.type == cryptonote::transaction_type::CREATE_TOKEN) ? entry.amount_minted : entry.amount_burnt;
           e.asset_type = entry.destination_asset;
           e.view_tag = entry.return_view_tag;
           e.anchor_enc = entry.return_anchor_enc;
@@ -597,6 +598,7 @@ namespace cryptonote
       case HF_VERSION_AUDIT2:
       case HF_VERSION_AUDIT2_PAUSE:
       case HF_VERSION_CARROT:
+      case HF_VERSION_ENABLE_TOKENS:
         // SRCG: subtract 20% that will be rewarded to staking users
         CHECK_AND_ASSERT_MES(tx.amount_burnt == 0, false, "while creating outs: amount_burnt is nonzero");
         tx.amount_burnt = amount / 5;
diff --git a/src/cryptonote_core/tx_pool.cpp b/src/cryptonote_core/tx_pool.cpp
index 3dfdf6a35..a8d510c1c 100644
--- a/src/cryptonote_core/tx_pool.cpp
+++ b/src/cryptonote_core/tx_pool.cpp
@@ -47,6 +47,7 @@
 #include "common/perf_timer.h"
 #include "crypto/hash.h"
 #include "crypto/duration.h"
+#include "common/debugging.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "txpool"
@@ -266,7 +267,14 @@ namespace cryptonote
       tvc.m_verifivation_failed = true;
       return false;
     }
-    
+
+    // Check the TX asset types
+    if (!m_blockchain.check_tx_asset_types(tx, tvc)) {
+      LOG_PRINT_L1("Transaction with id= "<< id << " has invalid asset type(s)");
+      tvc.m_verifivation_failed = true;
+      return false;
+    }
+
     // assume failure during verification steps until success is certain
     tvc.m_verifivation_failed = true;
 
@@ -1505,6 +1513,10 @@ namespace cryptonote
       return false;
     }
 
+    // Check that `transfer token` TXs have been paid for before accepting them into a block template
+    if (!m_blockchain.is_tx_paid_for(lazy_tx()))
+        return false;
+
     //transaction is ok.
     return true;
   }
@@ -1614,7 +1626,7 @@ namespace cryptonote
   //---------------------------------------------------------------------------------
   //---------------------------------------------------------------------------------
   //TODO: investigate whether boolean return is appropriate
-  bool tx_memory_pool::fill_block_template(block &bl, size_t median_weight, uint64_t already_generated_coins, size_t &total_weight, uint64_t &fee, uint64_t &expected_reward, uint8_t version)
+  bool tx_memory_pool::fill_block_template(block &bl, size_t median_weight, uint64_t already_generated_coins, size_t &total_weight, uint64_t &fee, uint64_t &expected_reward, std::vector<std::pair<protocol_tx_data_t, token_metadata_t>> &create_token_entries, uint8_t version)
   {
     CRITICAL_REGION_LOCAL(m_transactions_lock);
     CRITICAL_REGION_LOCAL1(m_blockchain);
@@ -1630,7 +1642,6 @@ namespace cryptonote
       return false;
     }
 
-
     size_t max_total_weight_pre_v5 = (130 * median_weight) / 100 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
     size_t max_total_weight_v5 = 2 * median_weight - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
     size_t max_total_weight = version >= 5 ? max_total_weight_v5 : max_total_weight_pre_v5;
@@ -1640,6 +1651,9 @@ namespace cryptonote
 
     LockedTXN lock(m_blockchain.get_db());
 
+    // Store list of tokens being created
+    std::set<std::string> tokens;
+    
     auto sorted_it = m_txs_by_fee_and_receive_time.begin();
     for (; sorted_it != m_txs_by_fee_and_receive_time.end(); ++sorted_it)
     {
@@ -1760,6 +1774,39 @@ namespace cryptonote
         continue;
       }
 
+      // check for ROLLUP TXs
+      if (tx.type == cryptonote::transaction_type::ROLLUP)
+      {
+        if (version < HF_VERSION_ENABLE_TOKENS) {
+          LOG_PRINT_L2("  is a ROLLUP transaction before they are permitted - cannot be mined");
+          continue;
+        }
+      }
+      
+      // check and include create token entries
+      if (tx.type == transaction_type::CREATE_TOKEN)
+      {
+        if (version < HF_VERSION_ENABLE_TOKENS) {
+          LOG_PRINT_L2("  is a CREATE_TOKEN transaction before they are permitted - cannot be mined");
+          continue;
+        }
+
+        std::string asset_type = "sal" + tx.token_metadata.asset_type;
+        if (!cryptonote::is_valid_asset_type(asset_type)) {
+          LOG_PRINT_L2("  is a CREATE_TOKEN transaction with an invalid asset_type - cannot be mined");
+          continue;
+        }
+
+        // Check to see if token is already being created
+        if (tokens.find(tx.token_metadata.asset_type) != tokens.end()) {
+          LOG_PRINT_L2("  is a CREATE_TOKEN transaction with an asset_type already in the block template - cannot be mined");
+          continue;
+        }
+
+        tokens.insert(tx.token_metadata.asset_type);
+        create_token_entries.push_back(std::make_pair(tx.protocol_tx_data, tx.token_metadata));
+      }
+
       bl.tx_hashes.push_back(sorted_it->second);
       total_weight += meta.weight;
       fee += meta.fee;
diff --git a/src/cryptonote_core/tx_pool.h b/src/cryptonote_core/tx_pool.h
index 0b279ee5a..2519fe209 100644
--- a/src/cryptonote_core/tx_pool.h
+++ b/src/cryptonote_core/tx_pool.h
@@ -226,11 +226,12 @@ namespace cryptonote
      * @param total_weight return-by-reference the total weight of the new block
      * @param fee return-by-reference the total of fees from the included transactions
      * @param expected_reward return-by-reference the total reward awarded to the miner finding this block, including transaction fees
+     * @param create_token_entries list of create coin entries to include in protocol tx
      * @param version hard fork version to use for consensus rules
      *
      * @return true
      */
-    bool fill_block_template(block &bl, size_t median_weight, uint64_t already_generated_coins, size_t &total_weight, uint64_t &fee, uint64_t &expected_reward, uint8_t version);
+    bool fill_block_template(block &bl, size_t median_weight, uint64_t already_generated_coins, size_t &total_weight, uint64_t &fee, uint64_t &expected_reward, std::vector<std::pair<protocol_tx_data_t, token_metadata_t>> &create_token_entries, uint8_t version);
 
     /**
      * @brief get a list of all transactions in the pool
diff --git a/src/cryptonote_core/tx_verification_utils.cpp b/src/cryptonote_core/tx_verification_utils.cpp
index 19d601a8e..e2bb004d1 100644
--- a/src/cryptonote_core/tx_verification_utils.cpp
+++ b/src/cryptonote_core/tx_verification_utils.cpp
@@ -187,7 +187,7 @@ bool ver_rct_non_semantics_simple_cached
     // mixring. Future versions of the protocol may differ in this regard, but if this assumptions
     // holds true in the future, enable the verification hash by modifying the `untested_tx`
     // condition below.
-    const bool untested_tx = tx.version > 4 || tx.rct_signatures.type > rct::RCTTypeSalviumOne;
+    const bool untested_tx = tx.version > TRANSACTION_VERSION_ENABLE_TOKENS || tx.rct_signatures.type > rct::RCTTypeSalviumOne;
     VER_ASSERT(!untested_tx, "Unknown TX type. Make sure RCT cache works correctly with this type and then enable it in the code here.");
 
     // Don't cache older (or newer) rctSig types
diff --git a/src/cryptonote_protocol/enums.h b/src/cryptonote_protocol/enums.h
index 669a1459b..28470b48e 100644
--- a/src/cryptonote_protocol/enums.h
+++ b/src/cryptonote_protocol/enums.h
@@ -54,6 +54,8 @@ namespace cryptonote
     STAKE = 6,
     RETURN = 7,
     AUDIT = 8,
-    MAX = 8
+    CREATE_TOKEN = 9,
+    ROLLUP = 10,
+    MAX = 10
   };
 }
diff --git a/src/hardforks/hardforks.cpp b/src/hardforks/hardforks.cpp
index 43bb26846..9fa111fa4 100644
--- a/src/hardforks/hardforks.cpp
+++ b/src/hardforks/hardforks.cpp
@@ -95,6 +95,9 @@ const hardfork_t testnet_hard_forks[] = {
 
   // version 10 Carrot - including treasury mint - starts from block 1100
   {10, 1100, 0, 1739780005 },
+  
+  // version 11
+  {11, 1200, 0, 1739880005 },
 };
 const size_t num_testnet_hard_forks = sizeof(testnet_hard_forks) / sizeof(testnet_hard_forks[0]);
 const uint64_t testnet_hard_fork_version_1_till = ((uint64_t)-1);
diff --git a/src/oracle/asset_types.h b/src/oracle/asset_types.h
index e35e4f637..4272ffd2e 100644
--- a/src/oracle/asset_types.h
+++ b/src/oracle/asset_types.h
@@ -26,6 +26,8 @@
 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #pragma once
+#include <cstdint>  // For uint8_t, etc.
+#include <cstring>  // For memcpy
 #include <string>
 #include <vector>
 
@@ -74,4 +76,122 @@ namespace oracle {
         }
       }
   };
+
+  class asset_type_counts_v2
+  {
+
+  public:
+
+    // Fields
+    std::map<uint32_t, uint64_t> asset_counts;
+
+    asset_type_counts_v2() noexcept
+    : asset_counts{}
+    {
+    }
+
+    uint64_t operator[](const uint32_t asset_type_id) const noexcept
+    {
+      if (asset_counts.count(asset_type_id) == 0)
+        return 0;
+      else
+        return asset_counts.at(asset_type_id);
+    }
+
+    bool add(const uint32_t asset_type_id, const uint64_t amount)
+    {
+      if (asset_counts.count(asset_type_id) == 0)
+        return false;
+      asset_counts[asset_type_id] += amount;
+      return true;
+    }
+
+    bool add_asset_type(const uint32_t asset_type_id)
+    {
+      if (asset_counts.count(asset_type_id) != 0)
+        return false;
+      asset_counts[asset_type_id] = 0;
+      return true;
+    }
+    
+    std::map<uint32_t, uint64_t> get()
+    {
+      return asset_counts;
+    }
+    
+    std::vector<uint32_t> get_asset_types() const noexcept
+    {
+      std::vector<uint32_t> asset_type_ids;
+      for (const auto& entry: asset_counts) {
+        asset_type_ids.push_back(entry.first);
+      }
+      return asset_type_ids;
+    }
+
+    bool has_asset_type(const uint32_t asset_type_id) const noexcept
+    {
+      return asset_counts.count(asset_type_id) == 1;
+    }
+    
+    std::vector<uint8_t> serialize() const noexcept {
+      constexpr uint8_t version = 1;  // Bump if format changes
+      uint32_t sz = static_cast<uint32_t>(asset_counts.size());
+      size_t total_size = sizeof(uint8_t) + sizeof(uint32_t) + (sz * (sizeof(uint32_t) + sizeof(uint64_t)));
+      std::vector<uint8_t> buf(total_size);
+      uint8_t* ptr = buf.data();
+
+      std::memcpy(ptr, &version, sizeof(uint8_t));
+      ptr += sizeof(uint8_t);
+
+      std::memcpy(ptr, &sz, sizeof(uint32_t));
+      ptr += sizeof(uint32_t);
+
+      for (const auto& p : asset_counts) {  // Iterates in sorted order
+        std::memcpy(ptr, &p.first, sizeof(uint32_t));
+        ptr += sizeof(uint32_t);
+        std::memcpy(ptr, &p.second, sizeof(uint64_t));
+        ptr += sizeof(uint64_t);
+      }
+      return buf;
+    }
+
+    void deserialize(const uint8_t* data, size_t len) {
+      if (len < sizeof(uint32_t)) {
+        throw std::runtime_error("Invalid serialized data");
+      }
+
+      uint8_t version;
+      std::memcpy(&version, data, sizeof(uint8_t));
+      data += sizeof(uint8_t);
+      len -= sizeof(uint8_t);
+
+      if (version == 1) {
+        if (len < sizeof(uint32_t)) {
+          throw std::runtime_error("Invalid serialized data");
+        }
+      } else {
+        throw std::runtime_error("Unsupported version");
+      }
+
+      uint32_t sz;
+      std::memcpy(&sz, data, sizeof(uint32_t));
+      data += sizeof(uint32_t);
+      len -= sizeof(uint32_t);
+
+      if (len != sz * (sizeof(uint32_t) + sizeof(uint64_t))) {
+        throw std::runtime_error("Invalid serialized data length");
+      }
+
+      asset_counts.clear();
+      for (uint32_t i = 0; i < sz; ++i) {
+        uint32_t k;
+        uint64_t v;
+        std::memcpy(&k, data, sizeof(uint32_t));
+        data += sizeof(uint32_t);
+        std::memcpy(&v, data, sizeof(uint64_t));
+        data += sizeof(uint64_t);
+        asset_counts[k] = v;  // Map handles sorting/uniquness
+      }
+    }
+  };
 }
diff --git a/src/ringct/rctSigs.cpp b/src/ringct/rctSigs.cpp
index cfe23c93b..ad7a86df6 100644
--- a/src/ringct/rctSigs.cpp
+++ b/src/ringct/rctSigs.cpp
@@ -1961,7 +1961,7 @@ namespace rct {
 
     //ver RingCT simple
     //assumes only post-rct style inputs (at least for max anonymity)
-    bool verRctSemanticsSimple(const rctSig & rv, const uint64_t amount_burnt)
+    bool verRctSemanticsSimple(const rctSig & rv, const uint64_t amount_burnt, const bool fee_paid_for_in_rollup)
     {
       try
       {
@@ -2027,8 +2027,10 @@ namespace rct {
         }
         key sumOutpks = addKeys(masks);
         DP(sumOutpks);
-        const key txnFeeKey = scalarmultH(d2h(rv.txnFee));
-        addKeys(sumOutpks, txnFeeKey, sumOutpks);
+        if (!fee_paid_for_in_rollup) {
+          const key txnFeeKey = scalarmultH(d2h(rv.txnFee));
+          addKeys(sumOutpks, txnFeeKey, sumOutpks);
+        }
         
         const key txnAmountBurntKey = scalarmultH(d2h(amount_burnt));
         addKeys(sumOutpks, txnAmountBurntKey, sumOutpks);
diff --git a/src/ringct/rctSigs.h b/src/ringct/rctSigs.h
index 81253f9bf..281cefc0a 100644
--- a/src/ringct/rctSigs.h
+++ b/src/ringct/rctSigs.h
@@ -202,9 +202,11 @@ namespace rct {
     );
     bool verRct(const rctSig & rv, bool semantics);
     static inline bool verRct(const rctSig & rv) { return verRct(rv, true) && verRct(rv, false); }
-    bool verRctSemanticsSimple(const rctSig & rv, const uint64_t amount_burnt=0);
+    bool verRctSemanticsSimple(const rctSig & rv, const uint64_t amount_burnt=0, const bool fee_paid_for_in_rollup=false);
     bool verRctNonSemanticsSimple(const rctSig & rv);
-  static inline bool verRctSimple(const rctSig & rv, const uint64_t amount_burnt=0) { return verRctSemanticsSimple(rv, amount_burnt) && verRctNonSemanticsSimple(rv); }
+    static inline bool verRctSimple(const rctSig & rv, const uint64_t amount_burnt=0, const bool fee_paid_for_in_rollup=false) {
+      return verRctSemanticsSimple(rv, amount_burnt, fee_paid_for_in_rollup) && verRctNonSemanticsSimple(rv);
+    }
     xmr_amount decodeRct(const rctSig & rv, const key & sk, unsigned int i, key & mask, hw::device &hwdev);
     xmr_amount decodeRct(const rctSig & rv, const key & sk, unsigned int i, hw::device &hwdev);
     xmr_amount decodeRctSimple(const rctSig & rv, const key & sk, unsigned int i, key & mask, hw::device &hwdev);
diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index 17548241c..a47d8bed7 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -28,6 +28,7 @@
 // 
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
+#include <regex>
 #include <boost/preprocessor/stringize.hpp>
 #include <boost/uuid/nil_generator.hpp>
 #include <boost/filesystem.hpp>
@@ -3062,6 +3063,52 @@ namespace cryptonote
     return true;    
   }
   //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_get_tokens(const COMMAND_RPC_GET_TOKENS::request& req, COMMAND_RPC_GET_TOKENS::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx)
+  {
+    PERF_TIMER(on_get_tokens);
+    std::map<std::string, cryptonote::token_metadata_t> tokens = m_core.get_blockchain_storage().get_db().get_tokens();
+    for (const auto &token: tokens) {
+      if (req.filter == "") {
+        // Match anything
+        res.tokens.push_back(token.first);
+      } else if (token.first.find(req.filter) != std::string::npos) {
+        // Match ticker
+        res.tokens.push_back(token.first);
+      } else if (token.second.token.type() == typeid(cryptonote::sal_token_t)) {
+        // Check SAL tokens
+        if (boost::get<cryptonote::sal_token_t>(token.second.token).name.find(req.filter) != std::string::npos) {
+          // Match name
+          res.tokens.push_back(token.first);
+        }
+      }
+    }
+    res.status = CORE_RPC_STATUS_OK;
+    return true;    
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_get_token_info(const COMMAND_RPC_GET_TOKEN_INFO::request& req, COMMAND_RPC_GET_TOKEN_INFO::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx)
+  {
+    PERF_TIMER(on_token_info);
+    std::map<std::string, cryptonote::token_metadata_t> tokens = m_core.get_blockchain_storage().get_db().get_tokens();
+    if (tokens.count(req.asset_type) == 0) {
+      res.status = "Token not found";
+      return true;
+    }
+
+    res.token = tokens[req.asset_type];
+
+    if (res.token.token.type() == typeid(cryptonote::erc_token_t)) {
+      res.token_type = TOKEN_TYPE_ERC20;
+      res.erc_token = boost::get<cryptonote::erc_token_t>(res.token.token);
+    } else if (res.token.token.type() == typeid(cryptonote::sal_token_t)) {
+      res.token_type = TOKEN_TYPE_SAL;
+      res.sal_token = boost::get<cryptonote::sal_token_t>(res.token.token);
+    }
+
+    res.status = CORE_RPC_STATUS_OK;
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_get_yield_info(const COMMAND_RPC_GET_YIELD_INFO::request& req, COMMAND_RPC_GET_YIELD_INFO::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx)
   {
     CHECK_CORE_READY();
diff --git a/src/rpc/core_rpc_server.h b/src/rpc/core_rpc_server.h
index 650326703..3abb17d5b 100644
--- a/src/rpc/core_rpc_server.h
+++ b/src/rpc/core_rpc_server.h
@@ -175,6 +175,8 @@ namespace cryptonote
         MAP_JON_RPC_WE_IF("get_coinbase_tx_sum", on_get_coinbase_tx_sum,        COMMAND_RPC_GET_COINBASE_TX_SUM, !m_restricted)
         MAP_JON_RPC_WE("get_supply_info",        on_get_supply_info,            COMMAND_RPC_GET_SUPPLY_INFO)
         MAP_JON_RPC_WE("get_yield_info",         on_get_yield_info,             COMMAND_RPC_GET_YIELD_INFO)
+        MAP_JON_RPC_WE("get_tokens",             on_get_tokens,                 COMMAND_RPC_GET_TOKENS)
+        MAP_JON_RPC_WE("get_token_info",         on_get_token_info,             COMMAND_RPC_GET_TOKEN_INFO)
         MAP_JON_RPC_WE("get_fee_estimate",       on_get_base_fee_estimate,      COMMAND_RPC_GET_BASE_FEE_ESTIMATE)
         MAP_JON_RPC_WE_IF("get_alternate_chains",on_get_alternate_chains,       COMMAND_RPC_GET_ALTERNATE_CHAINS, !m_restricted)
         MAP_JON_RPC_WE_IF("relay_tx",            on_relay_tx,                   COMMAND_RPC_RELAY_TX, !m_restricted)
@@ -254,6 +256,8 @@ namespace cryptonote
     bool on_get_coinbase_tx_sum(const COMMAND_RPC_GET_COINBASE_TX_SUM::request& req, COMMAND_RPC_GET_COINBASE_TX_SUM::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx = NULL);
     bool on_get_supply_info(const COMMAND_RPC_GET_SUPPLY_INFO::request& req, COMMAND_RPC_GET_SUPPLY_INFO::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx = NULL);
     bool on_get_yield_info(const COMMAND_RPC_GET_YIELD_INFO::request& req, COMMAND_RPC_GET_YIELD_INFO::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx = NULL);
+    bool on_get_tokens(const COMMAND_RPC_GET_TOKENS::request& req, COMMAND_RPC_GET_TOKENS::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx = NULL);
+    bool on_get_token_info(const COMMAND_RPC_GET_TOKEN_INFO::request& req, COMMAND_RPC_GET_TOKEN_INFO::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx = NULL);
     bool on_get_base_fee_estimate(const COMMAND_RPC_GET_BASE_FEE_ESTIMATE::request& req, COMMAND_RPC_GET_BASE_FEE_ESTIMATE::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx = NULL);
     bool on_get_alternate_chains(const COMMAND_RPC_GET_ALTERNATE_CHAINS::request& req, COMMAND_RPC_GET_ALTERNATE_CHAINS::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx = NULL);
     bool on_relay_tx(const COMMAND_RPC_RELAY_TX::request& req, COMMAND_RPC_RELAY_TX::response& res, epee::json_rpc::error& error_resp, const connection_context *ctx = NULL);
diff --git a/src/rpc/core_rpc_server_commands_defs.h b/src/rpc/core_rpc_server_commands_defs.h
index 6f119e949..eecd8efd2 100644
--- a/src/rpc/core_rpc_server_commands_defs.h
+++ b/src/rpc/core_rpc_server_commands_defs.h
@@ -1488,6 +1488,76 @@ namespace cryptonote
     typedef epee::misc_utils::struct_init<response_t> response;
   };
 
+  struct COMMAND_RPC_GET_TOKENS
+  {
+    struct request_t
+    {
+      std::string filter;
+      
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE_OPT(filter, (std::string)"")
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<request_t> request;
+    
+    struct response_t
+    {
+      std::string status;
+      std::vector<std::string> tokens;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+        KV_SERIALIZE(tokens)
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<response_t> response;
+  };
+
+  struct COMMAND_RPC_GET_TOKEN_INFO
+  {
+    struct request_t
+    {
+      std::string asset_type;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(asset_type)
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<request_t> request;
+
+    struct response_t
+    {
+      std::string status;
+      std::string asset_type;
+      uint8_t token_type;  // erc20 or sal
+      cryptonote::token_metadata_t token;
+      cryptonote::erc_token_t erc_token;
+      cryptonote::sal_token_t sal_token;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+        KV_SERIALIZE(token_type)
+        KV_SERIALIZE(token.version)
+        KV_SERIALIZE(token.asset_type)
+        if (token_type == TOKEN_TYPE_ERC20) {
+          KV_SERIALIZE(erc_token)
+          token.token = erc_token;
+        } else {
+          KV_SERIALIZE(sal_token)
+          token.token = sal_token;
+        }
+      END_KV_SERIALIZE_MAP()
+      //BEGIN_KV_SERIALIZE_MAP()
+      //KV_SERIALIZE(status)
+      //KV_SERIALIZE(token)
+      //KV_SERIALIZE(asset_type)
+      //KV_SERIALIZE(sal_token)
+      //KV_SERIALIZE(erc_token)
+      //END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<response_t> response;
+  };
+
   struct peer {
     uint64_t id;
     std::string host;
diff --git a/src/serialization/json_object.cpp b/src/serialization/json_object.cpp
index cf0c444a7..8ff5bb445 100644
--- a/src/serialization/json_object.cpp
+++ b/src/serialization/json_object.cpp
@@ -277,9 +277,8 @@ void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::t
         INSERT_INTO_JSON_OBJECT(dest, return_address_list, tx.return_address_list);
         INSERT_INTO_JSON_OBJECT(dest, return_address_change_mask, tx.return_address_change_mask);
       } else {
-        if (tx.type == cryptonote::transaction_type::STAKE &&
-              tx.version >= TRANSACTION_VERSION_CARROT)
-        {
+        if ((tx.type == cryptonote::transaction_type::STAKE || tx.type == cryptonote::transaction_type::CREATE_TOKEN) &&
+            (tx.version >= TRANSACTION_VERSION_CARROT)) {
           INSERT_INTO_JSON_OBJECT(dest, protocol_tx_data, tx.protocol_tx_data);
         } else {
           INSERT_INTO_JSON_OBJECT(dest, return_address, tx.return_address);
@@ -290,6 +289,16 @@ void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::t
       INSERT_INTO_JSON_OBJECT(dest, destination_asset_type, tx.destination_asset_type);
       INSERT_INTO_JSON_OBJECT(dest, amount_slippage_limit, tx.amount_slippage_limit);
     }
+    if (tx.version >= TRANSACTION_VERSION_ENABLE_TOKENS) {
+      if (tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+        INSERT_INTO_JSON_OBJECT(dest, token_metadata, tx.token_metadata);          
+      } else if (tx.type == cryptonote::transaction_type::TRANSFER) {
+        INSERT_INTO_JSON_OBJECT(dest, rollup_binding_tag, tx.rollup_binding_tag);          
+      } else if (tx.type == cryptonote::transaction_type::ROLLUP) {
+        INSERT_INTO_JSON_OBJECT(dest, rollup_binding_tag, tx.rollup_binding_tag);          
+        INSERT_INTO_JSON_OBJECT(dest, layer2_rollup_data, tx.layer2_rollup_data);
+      }
+    }
   }
   if (!tx.pruned)
   {
@@ -326,9 +335,8 @@ void fromJsonValue(const rapidjson::Value& val, cryptonote::transaction& tx)
         GET_FROM_JSON_OBJECT(val, tx.return_address_list, return_address_list);
         GET_FROM_JSON_OBJECT(val, tx.return_address_change_mask, return_address_change_mask);
       } else {
-        if (tx.type == cryptonote::transaction_type::STAKE &&
-              tx.version >= TRANSACTION_VERSION_CARROT)
-        {
+        if ((tx.type == cryptonote::transaction_type::STAKE || tx.type == cryptonote::transaction_type::CREATE_TOKEN) &&
+            (tx.version >= TRANSACTION_VERSION_CARROT)) {
           GET_FROM_JSON_OBJECT(val, tx.protocol_tx_data, protocol_tx_data);
         } else {
           GET_FROM_JSON_OBJECT(val, tx.return_address, return_address);
@@ -339,6 +347,16 @@ void fromJsonValue(const rapidjson::Value& val, cryptonote::transaction& tx)
       GET_FROM_JSON_OBJECT(val, tx.destination_asset_type, destination_asset_type);
       GET_FROM_JSON_OBJECT(val, tx.amount_slippage_limit, amount_slippage_limit);
     }
+    if (tx.version >= TRANSACTION_VERSION_ENABLE_TOKENS) {
+      if (tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+        GET_FROM_JSON_OBJECT(val, tx.token_metadata, token_metadata);          
+      } else if (tx.type == cryptonote::transaction_type::TRANSFER) {
+        GET_FROM_JSON_OBJECT(val, tx.rollup_binding_tag, rollup_binding_tag);          
+      } else if (tx.type == cryptonote::transaction_type::ROLLUP) {
+        GET_FROM_JSON_OBJECT(val, tx.rollup_binding_tag, rollup_binding_tag);          
+        GET_FROM_JSON_OBJECT(val, tx.layer2_rollup_data, layer2_rollup_data);
+      }
+    }
   }
   GET_FROM_JSON_OBJECT(val, tx.rct_signatures, ringct);
 
@@ -518,6 +536,141 @@ void fromJsonValue(const rapidjson::Value& val, cryptonote::txin_to_scripthash&
   }
 }
 
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::erc_token_t& erc_token)
+{
+  dest.StartObject();
+
+  INSERT_INTO_JSON_OBJECT(dest, version, erc_token.version);
+  INSERT_INTO_JSON_OBJECT(dest, contract_address, erc_token.contract_address);
+  INSERT_INTO_JSON_OBJECT(dest, lockbox_address, erc_token.lockbox_address);
+  INSERT_INTO_JSON_OBJECT(dest, ticker, erc_token.ticker);
+  INSERT_INTO_JSON_OBJECT(dest, erc20_asset_id, erc_token.erc20_asset_id);
+
+  dest.EndObject();
+}
+
+
+void fromJsonValue(const rapidjson::Value& val, cryptonote::erc_token_t& erc_token)
+{
+  if (!val.IsObject())
+  {
+    throw WRONG_TYPE("json object");
+  }
+
+  GET_FROM_JSON_OBJECT(val, erc_token.version, version);
+  GET_FROM_JSON_OBJECT(val, erc_token.contract_address, contract_address);
+  GET_FROM_JSON_OBJECT(val, erc_token.lockbox_address, lockbox_address);
+  GET_FROM_JSON_OBJECT(val, erc_token.ticker, ticker);
+  GET_FROM_JSON_OBJECT(val, erc_token.erc20_asset_id, erc20_asset_id);
+}
+
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::sal_token_t& sal_token)
+{
+  dest.StartObject();
+
+  INSERT_INTO_JSON_OBJECT(dest, version, sal_token.version);
+  INSERT_INTO_JSON_OBJECT(dest, supply, sal_token.supply);
+  INSERT_INTO_JSON_OBJECT(dest, size, sal_token.size);
+  INSERT_INTO_JSON_OBJECT(dest, name, sal_token.name);
+  INSERT_INTO_JSON_OBJECT(dest, url, sal_token.url);
+  INSERT_INTO_JSON_OBJECT(dest, signature, sal_token.signature);
+  
+  dest.EndObject();
+}
+
+
+void fromJsonValue(const rapidjson::Value& val, cryptonote::sal_token_t& sal_token)
+{
+  if (!val.IsObject())
+  {
+    throw WRONG_TYPE("json object");
+  }
+
+  GET_FROM_JSON_OBJECT(val, sal_token.version, version);
+  GET_FROM_JSON_OBJECT(val, sal_token.supply, supply);
+  GET_FROM_JSON_OBJECT(val, sal_token.size, size);
+  GET_FROM_JSON_OBJECT(val, sal_token.name, name);
+  GET_FROM_JSON_OBJECT(val, sal_token.url, url);
+  GET_FROM_JSON_OBJECT(val, sal_token.signature, signature);
+}
+
+
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::token_v& token)
+{
+  dest.StartObject();
+  struct add_token
+  {
+    using result_type = void;
+
+    rapidjson::Writer<epee::byte_stream>& dest;
+
+    void operator()(cryptonote::erc_token_t const& token) const
+    {
+      INSERT_INTO_JSON_OBJECT(dest, erc_token, token);
+    }
+    void operator()(cryptonote::sal_token_t const& token) const
+    {
+      INSERT_INTO_JSON_OBJECT(dest, sal_token, token);
+    }
+  };
+  boost::apply_visitor(add_token{dest}, token);
+  dest.EndObject();
+}
+
+
+void fromJsonValue(const rapidjson::Value& val, cryptonote::token_v& token)
+{
+  if (!val.IsObject())
+  {
+    throw WRONG_TYPE("json object");
+  }
+
+  if (val.MemberCount() != 1)
+  {
+    throw MISSING_KEY("Invalid token object");
+  }
+
+  for (auto const& elem : val.GetObject())
+  {
+    if (elem.name == "erc_token")
+    {
+      cryptonote::erc_token_t tmpVal;
+      fromJsonValue(elem.value, tmpVal);
+      token = std::move(tmpVal);
+    }
+    else if (elem.name == "sal_token")
+    {
+      cryptonote::sal_token_t tmpVal;
+      fromJsonValue(elem.value, tmpVal);
+      token = std::move(tmpVal);
+    }
+  }
+}
+
+
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::token_metadata_t& token_metadata)
+{
+  dest.StartObject();
+  
+  INSERT_INTO_JSON_OBJECT(dest, version, token_metadata.version);
+  INSERT_INTO_JSON_OBJECT(dest, asset_type, token_metadata.asset_type);
+  INSERT_INTO_JSON_OBJECT(dest, token, token_metadata.token);
+  dest.EndObject();
+}
+
+
+void fromJsonValue(const rapidjson::Value& val, cryptonote::token_metadata_t& token_metadata)
+{
+  if (!val.IsObject())
+  {
+    throw WRONG_TYPE("json object");
+  }
+
+  GET_FROM_JSON_OBJECT(val, token_metadata.version, version);
+  GET_FROM_JSON_OBJECT(val, token_metadata.asset_type, asset_type);
+  GET_FROM_JSON_OBJECT(val, token_metadata.token, token);
+}
+
 void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::protocol_tx_data_t& ptd)
 {
   dest.StartObject();
@@ -545,6 +698,50 @@ void fromJsonValue(const rapidjson::Value& val, cryptonote::protocol_tx_data_t&
   GET_FROM_JSON_OBJECT(val, ptd.return_anchor_enc, return_anchor_enc);
 }
 
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::layer2_rollup_tx_t& lrt)
+{
+  dest.StartObject();
+
+  INSERT_INTO_JSON_OBJECT(dest, tx_prefix_hash, lrt.tx_prefix_hash);
+  INSERT_INTO_JSON_OBJECT(dest, first_key_image, lrt.first_key_image);
+  INSERT_INTO_JSON_OBJECT(dest, tx_fee, lrt.tx_fee);
+
+  dest.EndObject();
+}
+
+void fromJsonValue(const rapidjson::Value& val, cryptonote::layer2_rollup_tx_t& lrt)
+{
+  if (!val.IsObject())
+  {
+    throw WRONG_TYPE("json object");
+  }
+
+  GET_FROM_JSON_OBJECT(val, lrt.tx_prefix_hash, tx_prefix_hash);
+  GET_FROM_JSON_OBJECT(val, lrt.first_key_image, first_key_image);
+  GET_FROM_JSON_OBJECT(val, lrt.tx_fee, tx_fee);
+}
+
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::layer2_rollup_data_t& lrd)
+{
+  dest.StartObject();
+
+  INSERT_INTO_JSON_OBJECT(dest, version, lrd.version);
+  INSERT_INTO_JSON_OBJECT(dest, txs, lrd.txs);
+
+  dest.EndObject();
+}
+
+void fromJsonValue(const rapidjson::Value& val, cryptonote::layer2_rollup_data_t& lrd)
+{
+  if (!val.IsObject())
+  {
+    throw WRONG_TYPE("json object");
+  }
+
+  GET_FROM_JSON_OBJECT(val, lrd.version, version);
+  GET_FROM_JSON_OBJECT(val, lrd.txs, txs);
+}
+
 void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::txin_to_key& txin)
 {
   dest.StartObject();
diff --git a/src/serialization/json_object.h b/src/serialization/json_object.h
index 680df3b82..fe351d3fe 100644
--- a/src/serialization/json_object.h
+++ b/src/serialization/json_object.h
@@ -218,9 +218,27 @@ void fromJsonValue(const rapidjson::Value& val, cryptonote::txin_to_scripthash&
 void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::txin_to_key& txin);
 void fromJsonValue(const rapidjson::Value& val, cryptonote::txin_to_key& txin);
 
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::erc_token_t& token);
+void fromJsonValue(const rapidjson::Value& val, cryptonote::erc_token_t& token);
+
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::sal_token_t& token);
+void fromJsonValue(const rapidjson::Value& val, cryptonote::sal_token_t& token);
+
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::token_v& token);
+void fromJsonValue(const rapidjson::Value& val, cryptonote::token_v& token);
+
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::token_metadata_t& token);
+void fromJsonValue(const rapidjson::Value& val, cryptonote::token_metadata_t& token);
+
 void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::protocol_tx_data_t& ptd);
 void fromJsonValue(const rapidjson::Value& val, cryptonote::protocol_tx_data_t& ptd);
 
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::layer2_rollup_tx_t& lrt);
+void fromJsonValue(const rapidjson::Value& val, cryptonote::layer2_rollup_tx_t& lrt);
+
+void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::layer2_rollup_data_t& lrd);
+void fromJsonValue(const rapidjson::Value& val, cryptonote::layer2_rollup_data_t& lrd);
+
 void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::txout_target_v& txout);
 void fromJsonValue(const rapidjson::Value& val, cryptonote::txout_target_v& txout);
 
diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 1fbc03241..c042f3bb9 100644
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -167,7 +167,8 @@ enum TransferType {
   Burn,
   Stake,
   Return,
-  Audit
+  Audit,
+  CreateToken
 };
 
 #define CHECK_IF_BACKGROUND_SYNCING(msg) \
@@ -221,17 +222,20 @@ namespace
   const char* USAGE_TRANSFER("transfer [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] (<URI> | <address> <amount> [<asset_type>]) [subtractfeefrom=<D0>[,<D1>,all,...]] [<payment_id>]");
   const char* USAGE_LOCKED_TRANSFER("locked_transfer [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] (<URI> | <addr> <amount> [<asset_type>]) <lockblocks> [<payment_id (obsolete)>]");
   const char* USAGE_LOCKED_SWEEP_ALL("locked_sweep_all [index=<N1>[,<N2>,...] | index=all] [<priority>] [<ring_size>] <address> <lockblocks> [<payment_id (obsolete)>]");
-  const char* USAGE_SWEEP_ALL("sweep_all [index=<N1>[,<N2>,...] | index=all] [<priority>] [<ring_size>] [outputs=<N>] <address> [<payment_id (obsolete)>]");
-  const char* USAGE_SWEEP_ACCOUNT("sweep_account <account> [index=<N1>[,<N2>,...] | index=all] [<priority>] [<ring_size>] [outputs=<N>] <address> [<payment_id (obsolete)>]");
-  const char* USAGE_SWEEP_BELOW("sweep_below <amount_threshold> [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] <address> [<payment_id (obsolete)>]");
-  const char* USAGE_SWEEP_SINGLE("sweep_single [<priority>] [<ring_size>] [outputs=<N>] <key_image> <address> [<payment_id (obsolete)>]");
+  const char* USAGE_SWEEP_ALL("sweep_all [index=<N1>[,<N2>,...] | index=all] [<priority>] [<ring_size>] [outputs=<N>] <address> [<asset_type>] [<payment_id (obsolete)>]");
+  const char* USAGE_SWEEP_ACCOUNT("sweep_account <account> [index=<N1>[,<N2>,...] | index=all] [<priority>] [<ring_size>] [outputs=<N>] <address> [<asset_type>] [<payment_id (obsolete)>]");
+  const char* USAGE_SWEEP_BELOW("sweep_below <amount_threshold> [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] <address> [<asset_type>] [<payment_id (obsolete)>]");
+  const char* USAGE_SWEEP_SINGLE("sweep_single [<priority>] [<ring_size>] [outputs=<N>] <key_image> <address> [<asset_type>] [<payment_id (obsolete)>]");
   const char* USAGE_RETURN_PAYMENT("return_payment <tx_hash>");
   const char* USAGE_BURN("burn <amount> <asset_type>");
   const char* USAGE_CONVERT("convert <source_amount> <source_asset> <dest_asset> [<slippage_limit>]");
   const char* USAGE_STAKE("stake <amount>");
   const char* USAGE_AUDIT("audit [index=<N1>[,<N2>,...] | index=all]");
+  const char* USAGE_CREATE_TOKEN("create_token [index=<N1>[,<N2>,...]] <ticker> <supply> [name=<name>|metadata=<metadata>|file=<metadata_file>]");
   const char* USAGE_PRICE_INFO("price_info");
   const char* USAGE_SUPPLY_INFO("supply_info");
+  const char* USAGE_GET_TOKENS("get_tokens [<asset_type_filter>]");
+  const char* USAGE_TOKEN_INFO("token_info <asset_type>");
   const char* USAGE_YIELD_INFO("yield_info");
   const char* USAGE_DONATE("donate [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] <amount> [<payment_id (obsolete)>]");
   const char* USAGE_SIGN_TRANSFER("sign_transfer [export_raw] [<filename>]");
@@ -3401,24 +3405,26 @@ bool simple_wallet::help(const std::vector<std::string> &args/* = std::vector<st
     message_writer() << tr("\"balance\" - Show balance.");
     message_writer() << tr("\"address all\" - Show all addresses.");
     message_writer() << tr("\"address new\" - Create new subaddress.");
-    message_writer() << tr("\"transfer <address> <amount> [<asset_type>]\" - Send SAL to an address.");
+    message_writer() << tr("\"transfer <address> <amount> [<asset_type>]\" - Send specified asset to an address. If no asset type is specified, it will send SAL1.");
     message_writer() << tr("\"return_payment <tx_hash>\" - Return a previously-received amount to sender.");
     message_writer() << tr("\"burn <amount> <asset_type>\" - destroy coins forever.");
     message_writer() << tr("\"convert <amount> <source_asset> <dest_asset> [<slippage_limit>]\" - convert between coin types.");
-    message_writer() << tr("\"stake <amount>\" - stake SAL for 30 days to earn yield.");
+    message_writer() << tr("\"stake <amount>\" - stake SAL1 for 30 days to earn yield.");
     message_writer() << tr("\"audit\" - audit your wallet main address (or subaddress(es) if specified).");
+    message_writer() << tr("\"create_token <ticker> <supply> [name=<name>|metadata=<metadata>|file=<metadata_file>]\" - Create new private token.");
     message_writer() << tr("\"price_info\" - Display current pricing information for supported assets.");
     message_writer() << tr("\"supply_info\" - Display circulating supply information.");
+    message_writer() << tr("\"token_info\" - Display information for specified private token.");
     message_writer() << tr("\"yield_info\" - Display current stats on Salvium staking / yield.");
     message_writer() << tr("\"show_transfers [in|out|pending|failed|pool|coinbase|burnt|staked|yield]\" - Show transactions.");
-    message_writer() << tr("\"sweep_all <address>\" - Send whole balance to another wallet.");
+    message_writer() << tr("\"sweep_all <address> [<asset_type>]\" - Send the entire balance of the selected asset to another wallet. If no asset type is specified, the entire balance of SAL1 assets will be sent.");
     message_writer() << tr("\"seed\" - Show secret 25 words that can be used to recover this wallet.");
     message_writer() << tr("\"refresh\" - Synchronize wallet with the Salvium network.");
     message_writer() << tr("\"status\" - Check current status of wallet.");
     message_writer() << tr("\"version\" - Check software version.");
     message_writer() << tr("\"exit\" - Exit wallet.");
     message_writer() << "";
-    message_writer() << tr("\"donate <amount>\" - Donate SAL to the development team.");
+    message_writer() << tr("\"donate <amount>\" - Donate SAL1 to the development team.");
     message_writer() << "";
   }
   else if ((args.size() == 1) && (args.front() == "all"))
@@ -3605,6 +3611,18 @@ simple_wallet::simple_wallet()
                            boost::bind(&simple_wallet::audit, this, _1),
                            tr(USAGE_AUDIT),
                            tr("Sends your wallet balance (or a single address or subaddress(es)) to audit (only available during AUDIT hard forks)"));
+  m_cmd_binder.set_handler("create_token",
+                           boost::bind(&simple_wallet::create_token, this, _1),
+                           tr(USAGE_CREATE_TOKEN),
+                           tr("Create a new private token with the specified parameters. The circulating supply of the newly created token is sent to your wallet address 10 blocks later."));
+  m_cmd_binder.set_handler("get_tokens",
+                           boost::bind(&simple_wallet::get_tokens, this, _1),
+                           tr(USAGE_GET_TOKENS),
+                           tr("List the tokens matching <asset_type_filter> that are already in existence."));
+  m_cmd_binder.set_handler("token_info",
+                           boost::bind(&simple_wallet::token_info, this, _1),
+                           tr(USAGE_TOKEN_INFO),
+                           tr("Displays the supply information and immutable metadata for the specified token."));
   m_cmd_binder.set_handler("price_info",
                            boost::bind(&simple_wallet::price_info, this, _1),
                            tr(USAGE_PRICE_INFO),
@@ -3805,6 +3823,7 @@ simple_wallet::simple_wallet()
                            boost::bind(&simple_wallet::on_command, this, &simple_wallet::show_transfers, _1),
                            tr(USAGE_SHOW_TRANSFERS),
                            // Seemingly broken formatting to compensate for the backslash before the quotes.
+                           // check here for create coin txs
                            tr("Show the incoming/outgoing transfers within an optional height range.\n\n"
                               "Output format:\n"
                               "In or Coinbase:    Block Number, \"block\"|\"in\",              Time, Amount, Asset Type, Transaction Hash, Payment ID, Subaddress Index,                     \"-\", Note\n"
@@ -6139,6 +6158,12 @@ void simple_wallet::on_money_received(uint64_t height, const crypto::hash &txid,
       message_writer(console_color_red) << "\r" << "*** BURN ***";
     } else if (td_origin.m_tx.type == cryptonote::transaction_type::CONVERT) {
       message_writer(console_color_red) << "\r" << "*** CONVERT ***";
+    } else if (td_origin.m_tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+      message_writer(console_color_blue, false) << "\r" <<
+        tr("Height ") << height << ", " <<
+        tr("txid ") << txid << ", " <<
+        tr("new token returned ") << print_money(amount) << " " << asset_type << ", " <<
+        tr("idx ") << subaddr_index;
     } else if (td_origin.m_tx.type == cryptonote::transaction_type::STAKE) {
       message_writer(console_color_magenta, false) << "\r" <<
         tr("Height ") << height << ", " <<
@@ -6174,6 +6199,12 @@ void simple_wallet::on_money_received(uint64_t height, const crypto::hash &txid,
         tr("txid ") << txid << ", " <<
         tr("converting ") << print_money(tx.amount_burnt) << " " << asset_type <<  ", " <<
         tr("idx ") << subaddr_index;
+    } else if (tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+      message_writer(console_color_blue, false) << "\r" <<
+        tr("Height ") << height << ", " <<
+        tr("txid ") << txid << ", " <<
+        tr("creating token by spending ") << print_money(tx.amount_burnt) << " " << asset_type <<  ", " <<
+        tr("idx ") << subaddr_index;
     } else if (tx.type == cryptonote::transaction_type::STAKE) {
       message_writer(console_color_cyan, false) << "\r" <<
         tr("Height ") << height << ", " <<
@@ -6507,7 +6538,7 @@ bool simple_wallet::show_balance_unlocked(bool detailed)
     success_msg_writer() << tr("Balance per address:");
     success_msg_writer() << boost::format("%16s  %21s %21s %7s %21s") % tr("Address") % tr("Balance") % tr("Unlocked balance") % tr("Outputs") % tr("Label");
     std::vector<tools::wallet2::transfer_details> transfers;
-    m_wallet->get_transfers(transfers);
+    m_wallet->get_transfers(transfers, asset);
     for (const auto& i : balance_per_subaddress)
     {
       carrot::subaddress_index_extended subaddr = {{m_current_subaddress_account, i.first},
@@ -7133,7 +7164,7 @@ bool simple_wallet::transfer_main(
     return false;
   }
 
-  const size_t min_args = (transfer_type == Audit) ? 0 : (transfer_type == TransferLocked) ? 2 : 1;
+  const size_t min_args = (transfer_type == Audit) ? 0 : (transfer_type == TransferLocked) ? 2 : (transfer_type == CreateToken) ? 2 : 1;
   if(local_args.size() < min_args)
   {
      fail_msg_writer() << tr("wrong number of arguments");
@@ -7355,6 +7386,10 @@ bool simple_wallet::transfer_main(
         unlock_block = CONVERT_LOCK_PERIOD;
         ptx_vector = m_wallet->create_transactions_2(dsts, source_asset, dest_asset, cryptonote::transaction_type::CONVERT, fake_outs_count, unlock_block /* unlock_time */, priority, extra, m_current_subaddress_account, subaddr_indices, subtract_fee_from_outputs);
         break;
+      case CreateToken:
+        unlock_block = 0;
+        ptx_vector = m_wallet->create_transactions_2(dsts, source_asset, dest_asset, cryptonote::transaction_type::CREATE_TOKEN, fake_outs_count, unlock_block /* unlock_time */, priority, extra, m_current_subaddress_account, subaddr_indices, subtract_fee_from_outputs);
+        break;
       case Stake:
         unlock_block = get_config(m_wallet->nettype()).STAKE_LOCK_PERIOD;
         ptx_vector = m_wallet->create_transactions_2(dsts, source_asset, dest_asset, cryptonote::transaction_type::STAKE, fake_outs_count, unlock_block, priority, extra, m_current_subaddress_account, subaddr_indices, subtract_fee_from_outputs);
@@ -7442,26 +7477,35 @@ bool simple_wallet::transfer_main(
         for (size_t n = 0; n < ptx_vector.size(); ++n)
         {
           total_fee += ptx_vector[n].fee;
-          for (auto i: ptx_vector[n].selected_transfers)
-            total_sent += m_wallet->get_transfer_details(i).amount();
-          total_sent -= ptx_vector[n].change_dts.amount + ptx_vector[n].fee;
-          change += ptx_vector[n].change_dts.amount;
+          if (ptx_vector[n].tx.type == cryptonote::transaction_type::TRANSFER) {
+            for (auto i: ptx_vector[n].selected_transfers)
+              total_sent += m_wallet->get_transfer_details(i).amount();
+            total_sent -= ptx_vector[n].change_dts.amount;
+            if (ptx_vector[n].tx.source_asset_type == "SAL1")
+              total_sent -= ptx_vector[n].fee;
+            change += ptx_vector[n].change_dts.amount;
 
-          if (ptx_vector[n].dust_added_to_fee)
-            dust_in_fee += ptx_vector[n].dust;
-          else
-            dust_not_in_fee += ptx_vector[n].dust;
+            if (ptx_vector[n].dust_added_to_fee)
+              dust_in_fee += ptx_vector[n].dust;
+            else
+              dust_not_in_fee += ptx_vector[n].dust;
+          } else if (ptx_vector[n].tx.type == cryptonote::transaction_type::AUDIT ||
+                     ptx_vector[n].tx.type == cryptonote::transaction_type::BURN ||
+                     ptx_vector[n].tx.type == cryptonote::transaction_type::CREATE_TOKEN ||
+                     ptx_vector[n].tx.type == cryptonote::transaction_type::STAKE) {
+            total_sent += ptx_vector[n].tx.amount_burnt;
+          }
         }
 
         std::stringstream prompt;
         for (size_t n = 0; n < ptx_vector.size(); ++n)
         {
-          prompt << tr("\nTransaction ") << (n + 1) << "/" << ptx_vector.size() << ":\n";
+          prompt << tr("\nTransaction ") << (n + 1) << "/" << ptx_vector.size() << (ptx_vector[n].tx.type == cryptonote::transaction_type::ROLLUP ? tr(" (rollup):\n") : tr(":\n"));
           subaddr_indices.clear();
           for (const std::size_t selected_transfer : ptx_vector.at(n).selected_transfers)
             subaddr_indices.insert(m_wallet->get_transfer_details(selected_transfer).m_subaddr_index.minor);
           for (uint32_t i : subaddr_indices)
-            prompt << boost::format(tr("Spending from address index %d\n")) % i;
+            prompt << boost::format(tr("Spending %s from address index %d\n")) % ptx_vector.at(n).tx.source_asset_type % i;
           if (subaddr_indices.size() > 1)
             prompt << tr("WARNING: Outputs of multiple addresses are being used together, which might potentially compromise your privacy.\n");
         }
@@ -7473,13 +7517,16 @@ bool simple_wallet::transfer_main(
           prompt << boost::format(tr("Staking %s %s for yield accrual.  ")) % print_money(total_sent) % source_asset;
         } else if (transfer_type == Audit) {
           prompt << boost::format(tr("Auditing %s %s.  ")) % print_money(total_sent) % source_asset;
+          //update here
+        } else if (transfer_type == CreateToken) {
+          prompt << boost::format(tr("Creating new coin: burning %s %s to create %s. ")) % print_money(total_sent) % source_asset % dest_asset;
         } else {
           prompt << boost::format(tr("Sending %s %s.  ")) % print_money(total_sent) % source_asset;
         }
         if (ptx_vector.size() > 1)
         {
           prompt << boost::format(tr("Your transaction needs to be split into %llu transactions.  "
-            "This will result in a transaction fee being applied to each transaction, for a total fee of %s")) %
+            "This will result in a transaction fee being applied to each transaction, for a total fee of %s SAL1")) %
             ((unsigned long long)ptx_vector.size()) % print_money(total_fee);
         }
         else
@@ -7512,9 +7559,9 @@ bool simple_wallet::transfer_main(
         }
         if (m_wallet->confirm_non_default_ring_size() && !default_ring_size)
         {
-          prompt << tr("WARNING: this is a non default ring size, which may harm your privacy. Default is recommended.");
+          prompt << tr("\nWARNING: this is a non default ring size, which may harm your privacy. Default is recommended.");
         }
-        prompt << ENDL << tr("Is this okay?");
+        prompt << ENDL << tr("\nIs this okay?");
         
         std::string accepted = input_line(prompt.str(), true);
         if (std::cin.eof())
@@ -7631,16 +7678,45 @@ bool simple_wallet::transfer(const std::vector<std::string> &args_)
   }
   
   // Get the source asset type
-  std::string source_asset = "SAL";
-  if (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) {
-    // Default to "SAL1" post-HF
-    source_asset = "SAL1";
+  std::string source_asset = "";
+  if (local_args.size() < 3) {
+    source_asset = "SAL";
+    if (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) {
+      // Default to "SAL1" post-HF
+      source_asset = "SAL1";
+    }
   }
-  std::string strLastArg = local_args.back();
-  std::transform(strLastArg.begin(), strLastArg.end(), strLastArg.begin(), ::toupper);
-  if (strLastArg == "SAL" or strLastArg == "SAL1") {
-    source_asset = strLastArg;
-    local_args.pop_back();  
+
+  if (source_asset.empty()) {
+    std::string strLastArg = local_args.back();
+    if (strLastArg == "SAL" or strLastArg == "SAL1") {
+      source_asset = strLastArg;
+    } else {
+      if (strLastArg.size() < 3)
+      {
+        fail_msg_writer() << tr("Unknown asset type: ") << strLastArg;
+        return true;
+      }
+      std::transform(strLastArg.begin() + 3, strLastArg.end(), strLastArg.begin() + 3, ::toupper);
+      std::vector<std::string> asset_types = m_wallet->list_asset_types();
+
+      // check if the last argument is a known asset type
+      bool found = false;
+      for (const auto& asset : asset_types) {
+        if (strLastArg == asset) {
+          source_asset = strLastArg;
+          found = true;
+          break;
+        }
+      }
+    
+      if (!found) {
+        fail_msg_writer() << tr("Unknown asset type: ") << strLastArg;
+        return true;
+      }
+    }
+
+    local_args.pop_back();
   }
   
   transfer_main(Transfer, source_asset, source_asset, local_args, false);
@@ -7670,12 +7746,45 @@ bool simple_wallet::locked_transfer(const std::vector<std::string> &args_)
   }
   
   // Get the source asset type
-  std::string source_asset = "SAL";
-  std::string strLastArg = local_args.back();
-  std::transform(strLastArg.begin(), strLastArg.end(), strLastArg.begin(), ::toupper);
-  if (strLastArg == "SAL" or strLastArg == "SAL1") {
-    source_asset = strLastArg;
-    local_args.pop_back();  
+  std::string source_asset = "";
+  if (local_args.size() < 3) {
+    source_asset = "SAL";
+    if (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) {
+      // Default to "SAL1" post-HF
+      source_asset = "SAL1";
+    }
+  }
+
+  if (source_asset.empty()) {
+    std::string strLastArg = local_args.back();
+    if (strLastArg == "SAL" or strLastArg == "SAL1") {
+      source_asset = strLastArg;
+    } else {
+      if (strLastArg.size() < 3)
+      {
+        fail_msg_writer() << tr("Unknown asset type: ") << strLastArg;
+        return true;
+      }
+      std::transform(strLastArg.begin() + 3, strLastArg.end(), strLastArg.begin() + 3, ::toupper);
+      std::vector<std::string> asset_types = m_wallet->list_asset_types();
+
+      // check if the last argument is a known asset type
+      bool found = false;
+      for (const auto& asset : asset_types) {
+        if (strLastArg == asset) {
+          source_asset = strLastArg;
+          found = true;
+          break;
+        }
+      }
+    
+      if (!found) {
+        fail_msg_writer() << tr("Unknown asset type: ") << strLastArg;
+        return true;
+      }
+    }
+
+    local_args.pop_back();
   }
   
   transfer_main(TransferLocked, source_asset, source_asset, local_args, false);
@@ -7937,8 +8046,6 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, bool locked, co
     }
   }
 
-  std::string asset_type = (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) ? "SAL1" : "SAL";
-  
   std::vector<uint8_t> extra;
   bool payment_id_seen = false;
   if (local_args.size() >= 2)
@@ -7962,6 +8069,16 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, bool locked, co
       local_args.pop_back();
   }
 
+  std::string asset_type = (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) ? "SAL1" : "SAL";
+  if (local_args.size() >= 2)
+  {
+    std::string asset_type_check = local_args.back();
+    if (cryptonote::is_valid_asset_type(asset_type_check)) {
+      asset_type = asset_type_check;
+      local_args.pop_back();
+    }
+  }
+  
   cryptonote::address_parse_info info;
   if (!cryptonote::get_account_address_from_str_or_url(info, m_wallet->nettype(), local_args[0], oa_prompter))
   {
@@ -8014,18 +8131,19 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, bool locked, co
     {
       total_fee += ptx_vector[n].fee;
       for (auto i: ptx_vector[n].selected_transfers)
-        total_sent += m_wallet->get_transfer_details(i).amount();
+        if (ptx_vector[n].tx.type == cryptonote::transaction_type::TRANSFER)
+          total_sent += m_wallet->get_transfer_details(i).amount();
     }
 
     std::ostringstream prompt;
     for (size_t n = 0; n < ptx_vector.size(); ++n)
     {
-      prompt << tr("\nTransaction ") << (n + 1) << "/" << ptx_vector.size() << ":\n";
+      prompt << tr("\nTransaction ") << (n + 1) << "/" << ptx_vector.size() << (ptx_vector[n].tx.type == cryptonote::transaction_type::ROLLUP ? tr(" (rollup):\n") : tr(":\n"));
       subaddr_indices.clear();
       for (const std::size_t selected_transfer : ptx_vector.at(n).selected_transfers)
         subaddr_indices.insert(m_wallet->get_transfer_details(selected_transfer).m_subaddr_index.minor);
       for (uint32_t i : subaddr_indices)
-        prompt << boost::format(tr("Spending from address index %d\n")) % i;
+        prompt << boost::format(tr("Spending %s from address index %d\n")) % ptx_vector.at(n).tx.source_asset_type % i;
       if (subaddr_indices.size() > 1)
         prompt << tr("WARNING: Outputs of multiple addresses are being used together, which might potentially compromise your privacy.\n");
     }
@@ -8034,8 +8152,9 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, bool locked, co
     //   return true;
 
     if (ptx_vector.size() > 1) {
-      prompt << boost::format(tr("Sweeping %s in %llu transactions for a total fee of %s.  Is this okay?")) %
+      prompt << boost::format(tr("Sweeping %s %s in %llu transactions for a total fee of %s SAL1.  Is this okay?")) %
         print_money(total_sent) %
+        asset_type %
         ((unsigned long long)ptx_vector.size()) %
         print_money(total_fee);
     }
@@ -8473,7 +8592,12 @@ bool simple_wallet::return_payment(const std::vector<std::string> &args_)
     }
 
     // Verify that the correct asset type is being returned
-    if (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) {
+    if (m_wallet->get_current_hard_fork() >= HF_VERSION_ENABLE_TOKENS) {
+      if (td.asset_type == "SAL") {
+        fail_msg_writer() << tr("SAL may not be returned for txid ") << args_[0];
+        return true;
+      }
+    } else if (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) {
       if (td.asset_type != "SAL1") {
         fail_msg_writer() << tr("Only SAL1 may be returned for txid ") << args_[0];
         return true;
@@ -8501,7 +8625,7 @@ bool simple_wallet::return_payment(const std::vector<std::string> &args_)
       fail_msg_writer() << tr("No outputs found");
       return true;
     }
-    if (ptx_vector.size() > 1)
+    if (ptx_vector.size() > 2)
     {
       fail_msg_writer() << tr("Multiple transactions are created, which is not supposed to happen");
       return true;
@@ -8513,25 +8637,29 @@ bool simple_wallet::return_payment(const std::vector<std::string> &args_)
     }
 
     // give user total and fee, and prompt to confirm
-    uint64_t total_fee = ptx_vector[0].fee;
+    uint64_t total_fee = 0;
     uint64_t total_sent = 0;
     std::string asset_type;
-    for (auto idx: ptx_vector[0].selected_transfers) {
-      const tools::wallet2::transfer_details &td = m_wallet->get_transfer_details(idx);
-      uint64_t sent = td.amount();
-      if (total_sent + sent < total_sent) {
-        fail_msg_writer() << tr("amount overflow detected");
-        return true;
+    for (size_t n = 0; n < ptx_vector.size(); ++n) {
+      total_fee += ptx_vector[n].fee;
+      if (ptx_vector[n].tx.type == cryptonote::transaction_type::TRANSFER) {
+        for (auto idx: ptx_vector[n].selected_transfers) {
+          const tools::wallet2::transfer_details &td = m_wallet->get_transfer_details(idx);
+          uint64_t sent = td.amount();
+          if (total_sent + sent < total_sent) {
+            fail_msg_writer() << tr("amount overflow detected");
+            return true;
+          }
+          total_sent += sent;
+          asset_type = td.asset_type;
+        }
       }
-      total_sent += sent;
-      asset_type = td.asset_type;
     }
     std::ostringstream prompt;
     // if (!process_ring_members(ptx_vector, prompt, m_wallet->print_ring_members()))
     //   return true;
-    prompt << boost::format(tr("Returning %s %s for a total fee of %s %s.  Is this okay?")) %
-      print_money(total_sent) % asset_type %
-      print_money(total_fee) % asset_type;
+    prompt << boost::format(tr("Returning %s %s for a total fee of %s SAL1.  Is this okay?")) %
+      print_money(total_sent) % asset_type % print_money(total_fee);
     std::string accepted = input_line(prompt.str(), true);
     if (std::cin.eof())
       return true;
@@ -8599,8 +8727,9 @@ bool simple_wallet::return_payment(const std::vector<std::string> &args_)
     }
     else
     {
-      m_wallet->commit_tx(ptx_vector[0]);
-      success_msg_writer(true) << tr("Money successfully sent, transaction: ") << get_transaction_hash(ptx_vector[0].tx);
+      commit_or_save(ptx_vector, m_do_not_relay);
+      //m_wallet->commit_tx(ptx_vector[0]);
+      //success_msg_writer(true) << tr("Money successfully sent, transaction: ") << get_transaction_hash(ptx_vector[0].tx);
     }
 
   }
@@ -8647,7 +8776,11 @@ bool simple_wallet::burn(const std::vector<std::string> &args_)
   asset_type = strLastArg;
   local_args.pop_back();
   
-  transfer_main(Burn, asset_type, "BURN", local_args, false);
+  if (m_wallet->get_current_hard_fork() >= HF_VERSION_ENABLE_TOKENS) {
+    transfer_main(Burn, asset_type, asset_type, local_args, false);
+  } else {
+    transfer_main(Burn, asset_type, "BURN", local_args, false);
+  }
   return true;  
 }
 //----------------------------------------------------------------------------------------------------
@@ -8770,6 +8903,261 @@ bool simple_wallet::audit(const std::vector<std::string> &args_)
   return true;
 }
 //----------------------------------------------------------------------------------------------------
+bool simple_wallet::create_token(const std::vector<std::string> &args_)
+{ 
+  // Disable until appropriate hard fork
+  if (m_wallet->get_current_hard_fork() < HF_VERSION_ENABLE_TOKENS) {
+    fail_msg_writer() << tr("create_token is not yet available");
+    return true;
+  }
+
+  CHECK_IF_BACKGROUND_SYNCING("cannot create tokens while background syncing");
+  if (!try_connect_to_daemon())
+    return true;
+
+  // Copy the arguments so we can modify the vector
+  std::vector<std::string> local_args = args_;
+  
+  std::set<uint32_t> subaddr_indices;
+  if (local_args.size() > 0 && local_args[0].substr(0, 6) == "index=")
+  {
+    if (local_args[0] == "index=all")
+    {
+      for (uint32_t i = 0; i < m_wallet->get_num_subaddresses(m_current_subaddress_account); ++i)
+        subaddr_indices.insert(i);
+    }
+    else if (!parse_subaddress_indices(local_args[0], subaddr_indices))
+    {
+      return true;
+    }
+    local_args.erase(local_args.begin());
+  }
+
+  // Check minimum required arguments: [index=<N1>[,<N2>,...]] <coin_symbol> <coin_supply> [name=<name>|metadata=<metadata>|file=<metadata_file>]
+  if (local_args.size() < 2)
+  {
+    PRINT_USAGE(USAGE_CREATE_TOKEN);
+    return true;
+  }
+
+  if (m_wallet->get_multisig_status().multisig_is_active)
+  {
+     fail_msg_writer() << tr("This is a multisig wallet, create_token is not currently supported");
+     return true;
+  }
+
+  // Validate token name
+  std::string token_ticker = local_args[0];
+  if (token_ticker.empty()) {
+    fail_msg_writer() << tr("Invalid ticker: Cannot be empty.");
+    return true;
+  }
+  local_args.erase(local_args.begin());
+  
+  uint64_t token_supply = 0;
+  if(!epee::string_tools::get_xtype_from_string(token_supply, local_args[0])) {
+    fail_msg_writer()<< tr("Token supply is invalid.");
+    return true;
+  }
+  local_args.erase(local_args.begin());
+
+  // Do we have name, or metadata, or a metadata file, provided?
+  std::string token_metadata_hex;
+  std::string mode, file, name, hash, size, url;
+  if (local_args.size()) {
+    uint64_t filesize = 0;
+    if (local_args[0].substr(0,5) == "file=") {
+      file = local_args[0].substr(5);
+      bool r = epee::file_io_utils::get_file_size(file, filesize);
+      if (r) {
+        // Load the file
+        if (!epee::file_io_utils::load_file_to_string(file, token_metadata_hex, filesize)) {
+          fail_msg_writer() << tr("Failed to load metadata file: ") << file;
+          return true;
+        }
+        mode = "metadata";
+        local_args.erase(local_args.begin());
+      } else {
+        fail_msg_writer() << tr("Failed to find metadata file: ") << file;
+        return true;
+      }
+    } else {
+      // Failed to load the file - must be either a name or a blob of hex on the command line
+      while (local_args.size()) {
+        if (local_args[0].substr(0,5) == "name=") {
+          mode = "name";
+          name = local_args[0].substr(5);
+        } else if (local_args[0].substr(0,5) == "hash=") {
+          mode = "hash";
+          hash = local_args[0].substr(5);
+          if (hash.size() != 64) {
+            fail_msg_writer() << tr("invalid hash parameter: ") << hash;
+            return true;
+          }
+        } else if (local_args[0].substr(0,5) == "size=") {
+          mode = "size";
+          size = local_args[0].substr(5);
+        } else if (local_args[0].substr(0,4) == "url=") {
+          mode = "url";
+          url = local_args[0].substr(4);    
+        } else if (local_args[0].substr(0,9) == "metadata=") {
+          mode = "metadata";
+          token_metadata_hex = local_args[0].substr(9);    
+        } else if (mode == "name") {
+          name.append(" ");
+          name.append(local_args[0]);
+        } else if (local_args[0].substr(0,5) == "file=") {
+          fail_msg_writer() << tr("'file' parameter cannot be used in conjunction is not valid when with other field parameters (name, size, hash, url).");
+          return true;
+        } else {
+          fail_msg_writer() << tr("unknown parameter: ") << local_args[0];
+          return true;
+        }
+        local_args.erase(local_args.begin());
+      }
+    }
+  }
+
+  if (mode != "metadata") {
+
+    // Fixup size if necessary
+    if (size == "") size = "0";
+    
+    // Build the hex metadata from the passed-in parameters
+    std::string json = (boost::format("{\"name\":\"%s\",\"size\":%s,\"hash\":\"%s\",\"url\":\"%s\"}") % name % size % hash % url).str();
+    token_metadata_hex = epee::string_tools::buff_to_hex_nodelimer(json);
+  }
+  
+  SCOPED_WALLET_UNLOCK_ON_BAD_PASSWORD(return false;);
+
+  try
+  {
+    // Call the wallet create_token() method
+    auto ptx_vector = m_wallet->create_token(token_ticker,
+                                             token_supply,
+                                             token_metadata_hex,
+                                             m_current_subaddress_account,
+                                             subaddr_indices
+                                             );
+    if (ptx_vector.empty())
+    {
+      fail_msg_writer() << tr("No outputs found");
+      return true;
+    }
+    if (ptx_vector.size() > 1)
+    {
+      fail_msg_writer() << tr("Multiple transactions are created, which is not supposed to happen");
+      return true;
+    }
+
+    // give user total and fee, and prompt to confirm
+    uint64_t total_fee = ptx_vector[0].fee + ptx_vector[0].tx.amount_burnt;
+    uint64_t total_sent = 0;
+    for (auto idx: ptx_vector[0].selected_transfers) {
+      const tools::wallet2::transfer_details &td = m_wallet->get_transfer_details(idx);
+      uint64_t sent = td.amount();
+      if (total_sent + sent < total_sent) {
+        fail_msg_writer() << tr("amount overflow detected");
+        return true;
+      }
+      total_sent += sent;
+    }
+    std::ostringstream prompt;
+    // if (!process_ring_members(ptx_vector, prompt, m_wallet->print_ring_members()))
+    //   return true;
+    prompt << boost::format(tr("Creating a token '%s'.  Total fee of %s SAL1.  Is this okay?")) %
+      token_ticker % print_money(total_fee);
+    std::string accepted = input_line(prompt.str(), true);
+    if (std::cin.eof())
+      return true;
+    if (!command_line::is_yes(accepted))
+    {
+      fail_msg_writer() << tr("transaction cancelled.");
+      return true;
+    }
+
+    m_wallet->commit_tx(ptx_vector[0]);
+    success_msg_writer(true) << tr("Money successfully sent, transaction: ") << get_transaction_hash(ptx_vector[0].tx);
+  }
+  catch (const std::exception& e)
+  {
+    handle_transfer_exception(std::current_exception(), m_wallet->is_trusted_daemon());
+  }
+  catch (...)
+  {
+    LOG_ERROR("unknown error");
+    fail_msg_writer() << tr("unknown error");
+  }
+
+  return true;
+}
+//----------------------------------------------------------------------------------------------------
+bool simple_wallet::get_tokens(const std::vector<std::string> &args_) {
+
+  // Sanity check the args
+  if (args_.size() > 1) {
+    PRINT_USAGE(USAGE_GET_TOKENS);
+    return true;
+  }
+
+  std::string filter = (args_.size() == 1) ? args_[0] : "";
+  
+  // get tokens
+  std::vector<std::string> tokens;
+  if(!m_wallet->get_tokens(filter, tokens)) {
+    fail_msg_writer() << "failed to get tokens. Make sure you are connected to a daemon.";
+    return false;
+  }
+  
+  message_writer(console_color_default, false) << boost::format(tr("TOKENS"));
+  for (auto token: tokens) {    
+    message_writer(console_color_default, false) << boost::format(tr("\t%8s")) % token;
+  }
+  return true;
+}
+//----------------------------------------------------------------------------------------------------
+bool simple_wallet::token_info(const std::vector<std::string> &args_) {
+
+  // Sanity check the args
+  if (args_.size() != 1) {
+    PRINT_USAGE(USAGE_TOKEN_INFO);
+    return true;
+  }
+
+  std::string asset_type = args_[0];
+  std::transform(asset_type.begin()+3, asset_type.end(), asset_type.begin()+3, ::toupper);
+  
+  try {
+    cryptonote::token_metadata_t token = m_wallet->get_token_info(asset_type);
+    
+    message_writer(console_color_default, false) << tr("Token Information:");
+    message_writer(console_color_default, false) << tr(" Asset Type: ") << token.asset_type;
+    message_writer(console_color_default, false) << tr(" Version: ") << (uint32_t)token.version;
+    
+    if (token.token.type() == typeid(cryptonote::sal_token_t)) {
+      const cryptonote::sal_token_t& sal_token = boost::get<cryptonote::sal_token_t>(token.token);
+      message_writer(console_color_default, false) << tr(" Token Type: ") << "SAL";
+      message_writer(console_color_default, false) << tr(" Supply: ") << sal_token.supply;
+      message_writer(console_color_default, false) << tr(" Name: ") << sal_token.name;
+      message_writer(console_color_default, false) << tr(" URL: ") << sal_token.url;
+      message_writer(console_color_default, false) << tr(" Size: ") << sal_token.size;
+      message_writer(console_color_default, false) << tr(" Hash: ") << epee::string_tools::pod_to_hex(sal_token.signature);
+    } else if (token.token.type() == typeid(cryptonote::erc_token_t)) {
+      const cryptonote::erc_token_t& erc_token = boost::get<cryptonote::erc_token_t>(token.token);
+      message_writer(console_color_default, false) << tr(" Token Type: ") << "ERC20";
+      message_writer(console_color_default, false) << tr(" Ticker: ") << erc_token.ticker;
+      message_writer(console_color_default, false) << tr(" Contract Address: ") << erc_token.contract_address;
+      message_writer(console_color_default, false) << tr(" Lockbox Address: ") << erc_token.lockbox_address;
+      message_writer(console_color_default, false) << tr(" ERC20 Asset ID: ") << erc_token.erc20_asset_id;
+    }
+  } catch (const std::exception& e) {
+    fail_msg_writer() << tr("Failed to get token info: ") << e.what();
+    return false;
+  }
+  
+  return true;
+}
+//----------------------------------------------------------------------------------------------------
 bool simple_wallet::stake(const std::vector<std::string> &args_)
 {
   // TODO: add locked versions
@@ -8784,7 +9172,7 @@ bool simple_wallet::stake(const std::vector<std::string> &args_)
      fail_msg_writer() << tr("This is a multisig wallet, staking is not currently supported");
      return true;
   }
-  
+
   std::vector<std::string> local_args;
   carrot::AddressDeriveType derive_type;
   if (m_wallet->use_fork_rules(HF_VERSION_CARROT, 0)) {
@@ -8992,6 +9380,7 @@ bool simple_wallet::donate(const std::vector<std::string> &args_)
   }
   local_args.push_back(address_str);
   local_args.push_back(amount_str);
+  // todo: Update donation message asset_type from sal to SAL1 if we're on a hard fork that has the SAL1 donation
   if (!payment_id_str.empty())
     local_args.push_back(payment_id_str);
   if (m_wallet->nettype() == cryptonote::MAINNET)
@@ -10144,7 +10533,7 @@ bool simple_wallet::show_transfers(const std::vector<std::string> &args_)
       }
     }
 
-    auto formatter = boost::format("%8.8llu %6.6s %8.8s %25.25s %20.20s %4.4s %s %s %14.14s %s %s - %s");
+    auto formatter = boost::format("%8.8llu %6.6s %8.8s %25.25s %20.20s %7.7s %s %s %14.14s %s %s - %s");
 
     message_writer(color, false) << formatter
       % transfer.block
diff --git a/src/simplewallet/simplewallet.h b/src/simplewallet/simplewallet.h
index 85348d3be..13b799111 100644
--- a/src/simplewallet/simplewallet.h
+++ b/src/simplewallet/simplewallet.h
@@ -194,6 +194,9 @@ namespace cryptonote
     bool burn(const std::vector<std::string> &args);
     bool convert(const std::vector<std::string> &args);
     bool audit(const std::vector<std::string> &args);
+    bool create_token(const std::vector<std::string> &args);
+    bool get_tokens(const std::vector<std::string> &args);
+    bool token_info(const std::vector<std::string> &args);
     bool stake(const std::vector<std::string> &args);
     bool price_info(const std::vector<std::string> &args);
     bool supply_info(const std::vector<std::string> &args);
diff --git a/src/version.cpp.in b/src/version.cpp.in
index 50311e947..89e0beddf 100644
--- a/src/version.cpp.in
+++ b/src/version.cpp.in
@@ -1,5 +1,5 @@
 #define DEF_SALVIUM_VERSION_TAG "@VERSIONTAG@"
-#define DEF_SALVIUM_VERSION "1.0.7"
+#define DEF_SALVIUM_VERSION "1.1.0-rc1"
 #define DEF_MONERO_VERSION_TAG "release"
 #define DEF_MONERO_VERSION "0.18.3.4"
 #define DEF_MONERO_RELEASE_NAME "One"
diff --git a/src/wallet/api/pending_transaction.cpp b/src/wallet/api/pending_transaction.cpp
index 4af73ef14..5104d4d77 100644
--- a/src/wallet/api/pending_transaction.cpp
+++ b/src/wallet/api/pending_transaction.cpp
@@ -168,7 +168,8 @@ uint64_t PendingTransactionImpl::amount() const
     for (const auto &ptx : m_pending_tx)   {
       if (ptx.tx.type == cryptonote::transaction_type::AUDIT ||
           ptx.tx.type == cryptonote::transaction_type::BURN ||
-          ptx.tx.type == cryptonote::transaction_type::STAKE) {
+          ptx.tx.type == cryptonote::transaction_type::STAKE ||
+          ptx.tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
         result += ptx.tx.amount_burnt;
       } else {
         for (const auto &dest : ptx.dests) {
diff --git a/src/wallet/api/subaddress_account.cpp b/src/wallet/api/subaddress_account.cpp
index b72763052..3556ba360 100644
--- a/src/wallet/api/subaddress_account.cpp
+++ b/src/wallet/api/subaddress_account.cpp
@@ -44,16 +44,16 @@ SubaddressAccountImpl::SubaddressAccountImpl(WalletImpl *wallet)
 void SubaddressAccountImpl::addRow(const std::string &label)
 {
   m_wallet->m_wallet->add_subaddress_account(label);
-  refresh();
+  refresh("SAL1");
 }
 
 void SubaddressAccountImpl::setLabel(uint32_t accountIndex, const std::string &label)
 {
   m_wallet->m_wallet->set_subaddress_label({accountIndex, 0}, label);
-  refresh();
+  refresh("SAL1");
 }
 
-void SubaddressAccountImpl::refresh() 
+void SubaddressAccountImpl::refresh(const std::string &asset_type) 
 {
   LOG_PRINT_L2("Refreshing subaddress account");
   
@@ -64,8 +64,8 @@ void SubaddressAccountImpl::refresh()
       i,
       m_wallet->m_wallet->get_subaddress_as_str({i,0}),
       m_wallet->m_wallet->get_subaddress_label({i,0}),
-      cryptonote::print_money(m_wallet->m_wallet->balance(i, "SAL", false)),
-      cryptonote::print_money(m_wallet->m_wallet->unlocked_balance(i, "SAL", false)),
+      cryptonote::print_money(m_wallet->m_wallet->balance(i, asset_type, false)),
+      cryptonote::print_money(m_wallet->m_wallet->unlocked_balance(i, asset_type, false)),
       cryptonote::print_money(m_wallet->m_wallet->balance(i, "SAL1", false)),
       cryptonote::print_money(m_wallet->m_wallet->unlocked_balance(i, "SAL1", false))
     ));
diff --git a/src/wallet/api/subaddress_account.h b/src/wallet/api/subaddress_account.h
index 94cab47fb..d7eed006c 100644
--- a/src/wallet/api/subaddress_account.h
+++ b/src/wallet/api/subaddress_account.h
@@ -40,7 +40,7 @@ public:
     ~SubaddressAccountImpl();
     
     // Fetches addresses from Wallet2
-    void refresh();
+    void refresh(const std::string &asset_type);
     std::vector<SubaddressAccountRow*> getAll() const;
     void addRow(const std::string &label);
     void setLabel(uint32_t accountIndex, const std::string &label);
diff --git a/src/wallet/api/wallet.cpp b/src/wallet/api/wallet.cpp
index 27383e8bb..ae59d3654 100644
--- a/src/wallet/api/wallet.cpp
+++ b/src/wallet/api/wallet.cpp
@@ -1643,6 +1643,107 @@ PendingTransaction *WalletImpl::createStakeTransaction(uint64_t amount, uint32_t
   return createTransactionMultDest(Monero::transaction_type::STAKE, std::vector<string> {dst_addr}, payment_id, amount ? (std::vector<uint64_t> {amount}) : (optional<std::vector<uint64_t>>()), mixin_count, asset_type, is_return, priority, subaddr_account, subaddr_indices);
 }
 
+PendingTransaction *WalletImpl::createCreateTokenTransaction(const std::string &asset_type, uint64_t supply, const std::string &metadata, const std::string &name, uint32_t size, std::string hash, std::string url, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices){
+
+    PendingTransactionImpl * transaction = new PendingTransactionImpl(*this);
+    std::string token_metadata_hex;
+    crypto::hash hash_signature{};
+    if (!hash.empty()) {
+      if (!epee::string_tools::hex_to_pod(hash, hash_signature)) {
+        if (metadata.empty()){
+            setStatusError(tr("Invalid hash format."));
+            return transaction;
+        }
+      }
+    }
+    if (metadata.empty()) {
+      std::string json = (boost::format("{\"name\":\"%s\",\"size\":%d,\"hash\":\"%s\",\"url\":\"%s\"}") % name % size % hash % url).str();
+      token_metadata_hex = epee::string_tools::buff_to_hex_nodelimer(json);
+    } else {
+      token_metadata_hex = metadata;
+    }
+
+    cryptonote::sal_token_t sal_token;
+    sal_token.version = 1;
+    sal_token.supply = supply;
+    // todo: if not provided, use token_metadata_hex
+    sal_token.size = size;
+    sal_token.name = name;
+    sal_token.url = url;
+    sal_token.signature = hash_signature;
+
+    cryptonote::token_metadata_t token_meta;
+    token_meta.version = 1;
+    token_meta.asset_type = asset_type;
+    token_meta.token = sal_token;
+
+    clearStatus();
+    try {
+        // check if token already exists before attempting to create
+        std::vector<std::string> existing_tokens;
+        if (m_wallet->get_tokens(asset_type, existing_tokens) && !existing_tokens.empty()) {
+            setStatusError(tr("Token with ticker '") + asset_type + tr("' already exists"));
+            statusWithErrorString(transaction->m_status, transaction->m_errorString);
+            return transaction;
+        }
+
+        transaction->m_pending_tx = m_wallet->create_token(asset_type, supply, token_metadata_hex, subaddr_account, subaddr_indices
+        );
+        pendingTxPostProcess(transaction);
+    } catch (const tools::error::daemon_busy&) {
+        setStatusError(tr("daemon is busy. Please try again later."));
+    } catch (const tools::error::no_connection_to_daemon&) {
+        setStatusError(tr("no connection to daemon. Please make sure daemon is running."));
+    } catch (const tools::error::wallet_rpc_error& e) {
+        setStatusError(tr("RPC error: ") +  e.to_string());
+    } catch (const tools::error::get_outs_error &e) {
+        setStatusError((boost::format(tr("failed to get outputs to mix: %s")) % e.what()).str());
+    } catch (const tools::error::not_enough_unlocked_money& e) {
+        std::ostringstream writer;
+        writer << boost::format(tr("not enough SAL1 to create token, available only %s, required %s")) %
+                print_money(e.available()) %
+                print_money(e.tx_amount());
+        setStatusError(writer.str());
+    } catch (const tools::error::not_enough_money& e) {
+        std::ostringstream writer;
+        writer << boost::format(tr("not enough SAL1 to create token, overall balance only %s, required %s")) %
+                print_money(e.available()) %
+                print_money(e.tx_amount());
+        setStatusError(writer.str());
+    } catch (const tools::error::tx_not_possible& e) {
+        std::ostringstream writer;
+        writer << boost::format(tr("not enough SAL1 to create token, available only %s, required %s = %s (locked) + %s (fee)")) %
+                print_money(e.available()) %
+                print_money(e.tx_amount() + e.fee()) %
+                print_money(e.tx_amount()) %
+                print_money(e.fee());
+        setStatusError(writer.str());
+    } catch (const tools::error::tx_not_constructed&) {
+        setStatusError(tr("transaction for token creation was not constructed"));
+    } catch (const tools::error::tx_rejected& e) {
+        std::ostringstream writer;
+        writer << (boost::format(tr("create token transaction %s was rejected by daemon with status: ")) % get_transaction_hash(e.tx())) << e.status();
+        std::string reason = e.reason();
+        if (!reason.empty())
+            writer << tr(". Reason: ") << reason;
+        setStatusError(writer.str());
+    } catch (const tools::error::tx_sum_overflow& e) {
+        setStatusError(e.what());
+    } catch (const tools::error::tx_too_big& e) {
+        setStatusError(tr("token creation transaction is too large"));
+    } catch (const tools::error::transfer_error& e) {
+        setStatusError(string(tr("token creation error: ")) + e.what());
+    } catch (const tools::error::wallet_internal_error& e) {
+        setStatusError(string(tr("internal error: ")) + e.what());
+    } catch (const std::exception& e) {
+        setStatusError(string(tr("unexpected error: ")) + e.what());
+    } catch (...) {
+        setStatusError(tr("unknown error"));
+    }
+    statusWithErrorString(transaction->m_status, transaction->m_errorString);
+    return transaction;
+}
+
 PendingTransaction *WalletImpl::createAuditTransaction(
     uint32_t mixin_count,
     PendingTransaction::Priority priority,
@@ -1783,8 +1884,8 @@ PendingTransaction *WalletImpl::createTransactionMultDest(const Monero::transact
                   const auto result = m_wallet->create_transactions_all(0,
                                                                         converted_tx_type,
                                                                         asset_type,
-                                                                        m_wallet->get_subaddress({subaddr_account, subaddr_index}),
-                                                                        (subaddr_index > 0),
+                                                                        info.address,
+                                                                        info.is_subaddress,
                                                                         1,
                                                                         fake_outs_count,
                                                                         0 /* unlock_time */,
@@ -2932,4 +3033,9 @@ YieldInfo * WalletImpl::getYieldInfo()
   return yi;
 }
 
+std::vector<std::string> WalletImpl::getAssetTypes()
+{
+  return m_wallet->list_asset_types();
+}
+
 } // namespace
diff --git a/src/wallet/api/wallet.h b/src/wallet/api/wallet.h
index 39e737675..7a8063478 100644
--- a/src/wallet/api/wallet.h
+++ b/src/wallet/api/wallet.h
@@ -163,6 +163,15 @@ public:
                                                 PendingTransaction::Priority priority = PendingTransaction::Priority_Low,
                                                 uint32_t subaddr_account = 0,
                                                 std::set<uint32_t> subaddr_indices = {}) override;
+    PendingTransaction * createCreateTokenTransaction(const std::string &asset_type,
+                                                      uint64_t supply,
+                                                      const std::string &metadata,
+                                                      const std::string &name,
+                                                      uint32_t size,
+                                                      std::string hash,
+                                                      std::string url, 
+                                                      uint32_t subaddr_account,
+                                                      std::set<uint32_t> subaddr_indices = {}) override;
     PendingTransaction * createAuditTransaction(uint32_t mixin_count,
                                                 PendingTransaction::Priority priority = PendingTransaction::Priority_Low,
                                                 uint32_t subaddr_account = 0,
@@ -252,6 +261,8 @@ public:
 
     YieldInfo * getYieldInfo() override;
 
+    virtual std::vector<std::string> getAssetTypes() override;
+
 private:
     void clearStatus() const;
     void setStatusError(const std::string& message) const;
diff --git a/src/wallet/api/wallet2_api.h b/src/wallet/api/wallet2_api.h
index c0c6792c1..954bded71 100644
--- a/src/wallet/api/wallet2_api.h
+++ b/src/wallet/api/wallet2_api.h
@@ -59,7 +59,9 @@ enum transaction_type : uint8_t {
     STAKE = 6,
     RETURN = 7,
     AUDIT = 8,
-    MAX = 8
+    CREATE_TOKEN = 9,
+    ROLLUP = 10,
+    MAX = 10
 };
   
     namespace Utils {
@@ -366,7 +368,7 @@ struct SubaddressAccount
     virtual std::vector<SubaddressAccountRow*> getAll() const = 0;
     virtual void addRow(const std::string &label) = 0;
     virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0;
-    virtual void refresh() = 0;
+    virtual void refresh(const std::string &asset_type) = 0;
 };
 
 struct MultisigState {
@@ -933,6 +935,31 @@ struct Wallet
                                                         uint32_t subaddr_account = 0,
                                                         std::set<uint32_t> subaddr_indices = {}) = 0;
 
+    /*!
+     * \brief createCreateTokenTransaction  creates token creation transaction.
+     * \param asset_type              the type of asset to create
+     * \param supply                  token supply amount
+     * \param metadata                 
+     * \param name
+     * \param size
+     * \param hash
+     * \param url                
+     * \param subaddr_account         subaddress account from which the input funds are taken
+     * \param subaddr_indices         set of subaddress indices to use for transfer or sweeping. if set empty, all are chosen when sweeping, and one or more are automatically chosen when transferring. after execution, returns the set of actually used indices
+     * \return                        PendingTransaction object. caller is responsible to check PendingTransaction::status()
+     *                                after object returned
+     */
+
+    virtual PendingTransaction * createCreateTokenTransaction(const std::string &asset_type,
+                                                              uint64_t supply,
+                                                              const std::string &metadata,
+                                                              const std::string &name,
+                                                              uint32_t size,
+                                                              const std::string hash,
+                                                              const std::string url,
+                                                              uint32_t subaddr_account = 0,
+                                                              std::set<uint32_t> subaddr_indices = {}) = 0;
+
     /*!
      * \brief createAuditTransaction  creates audit transaction.
      * \param mixin_count             mixin count. if 0 passed, wallet will use default value
@@ -1260,6 +1287,9 @@ struct Wallet
 
     //! get yield information
     virtual YieldInfo * getYieldInfo() = 0;
+
+    //! get asset types for which the wallet has/had outputs
+    virtual std::vector<std::string> getAssetTypes() = 0;
 };
 
 /**
diff --git a/src/wallet/tx_builder.cpp b/src/wallet/tx_builder.cpp
index 7ba213d95..3fb690e6f 100644
--- a/src/wallet/tx_builder.cpp
+++ b/src/wallet/tx_builder.cpp
@@ -52,6 +52,8 @@
 //third party headers
 
 //standard headers
+#include <iterator>
+#include <set>
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "wallet.tx_builder"
@@ -71,11 +73,12 @@ static constexpr T div_ceil(T dividend, T divisor)
 //-------------------------------------------------------------------------------------------------------------------
 //-------------------------------------------------------------------------------------------------------------------
 static bool is_transfer_usable_for_input_selection(const wallet2::transfer_details &td,
-    const std::uint32_t from_account,
-    const std::set<std::uint32_t> from_subaddresses,
-    const rct::xmr_amount ignore_above,
-    const rct::xmr_amount ignore_below,
-    const uint64_t top_block_index)
+                                                   const std::uint32_t from_account,
+                                                   const std::set<std::uint32_t> from_subaddresses,
+                                                   const rct::xmr_amount ignore_above,
+                                                   const rct::xmr_amount ignore_below,
+                                                   const uint64_t top_block_index,
+                                                   const std::string asset_type)
 {
     /** 
      * This additional check appears to be for fcmp++. 
@@ -97,7 +100,7 @@ static bool is_transfer_usable_for_input_selection(const wallet2::transfer_detai
         && (from_subaddresses.empty() || from_subaddresses.count(td.m_subaddr_index.minor) == 1)
         && td.amount() >= ignore_below
         && td.amount() <= ignore_above
-        && td.asset_type == "SAL1"
+        && td.asset_type == asset_type
     ;
 }
 //-------------------------------------------------------------------------------------------------------------------
@@ -118,7 +121,8 @@ static bool build_payment_proposals(std::vector<carrot::CarrotPaymentProposalV1>
             .proposal = carrot::CarrotPaymentProposalSelfSendV1{
                 .destination_address_spend_pubkey = tx_dest_entry.addr.m_spend_public_key,
                 .amount = tx_dest_entry.amount,
-                .enote_type = carrot::CarrotEnoteType::PAYMENT
+                .enote_type = carrot::CarrotEnoteType::PAYMENT,
+                .asset_type = tx_dest_entry.asset_type
             },
             .subaddr_index = {subaddr_index, carrot::AddressDeriveType::Carrot, false},
         });
@@ -261,6 +265,7 @@ carrot::select_inputs_func_t make_wallet2_single_transfer_input_selector(
     const std::uint64_t top_block_index,
     const bool allow_carrot_external_inputs_in_normal_transfers,
     const bool allow_pre_carrot_inputs_in_normal_transfers,
+    const std::string &asset_type,
     std::set<size_t> &selected_transfer_indices_out)
 {
     // Collect transfer_container into a `std::vector<carrot::InputCandidate>` for usable inputs
@@ -272,11 +277,12 @@ carrot::select_inputs_func_t make_wallet2_single_transfer_input_selector(
     {
         const wallet2::transfer_details &td = transfers.at(i);
         if (is_transfer_usable_for_input_selection(td,
-            from_account,
-            from_subaddresses,
-            ignore_above,
-            ignore_below,
-            top_block_index))
+                                                   from_account,
+                                                   from_subaddresses,
+                                                   ignore_above,
+                                                   ignore_below,
+                                                   top_block_index,
+                                                   asset_type))
         {
             input_candidates.push_back(carrot::InputCandidate{
                 .core = carrot::CarrotSelectedInput{
@@ -296,6 +302,7 @@ carrot::select_inputs_func_t make_wallet2_single_transfer_input_selector(
             input_candidates_transfer_indices = std::move(input_candidates_transfer_indices),
             allow_carrot_external_inputs_in_normal_transfers,
             allow_pre_carrot_inputs_in_normal_transfers,
+            asset_type,
             &selected_transfer_indices_out
             ](
                 const boost::multiprecision::uint128_t &nominal_output_sum,
@@ -313,6 +320,9 @@ carrot::select_inputs_func_t make_wallet2_single_transfer_input_selector(
                     flags |= carrot::InputSelectionFlags::ALLOW_EXTERNAL_INPUTS_IN_NORMAL_TRANSFERS;
                 if (allow_pre_carrot_inputs_in_normal_transfers)
                     flags |= carrot::InputSelectionFlags::ALLOW_PRE_CARROT_INPUTS_IN_NORMAL_TRANSFERS;
+                // for token transfers; fee is paid separately in SAL1 via rollup tx
+                if (cryptonote::is_asset_type_token(asset_type))
+                    flags |= carrot::InputSelectionFlags::IS_TOKEN_TRANSFER;
 
                 // Make inner input selection functor
                 std::set<size_t> selected_input_indices;
@@ -343,10 +353,24 @@ std::vector<cryptonote::tx_source_entry> get_sources(
     wallet2 &w
 ) {
     // get decoys
-    const size_t fake_outputs_count = 15;
+    size_t fake_outputs_count = (cryptonote::is_asset_type_token(source_asset)) ? 0 : 15;
+    // check here!
+    // for tokens, check if there are enough decoys in the chain - if so ring_size= 16
+    if (cryptonote::is_asset_type_token(source_asset))
+    {
+        uint64_t rct_start_height = 0;
+        std::vector<uint64_t> distribution;
+        uint64_t num_spendable_global_outs = 0;
+        if (w.get_rct_distribution(false, source_asset, rct_start_height, distribution, num_spendable_global_outs)
+            && num_spendable_global_outs > 15)
+        {
+            fake_outputs_count = 15;
+        }
+    }
+
     std::vector<std::vector<tools::wallet2::get_outs_entry>> outs;
     std::unordered_set<crypto::public_key> valid_public_keys_cache;
-    w.get_outs(outs, selected_transfers, fake_outputs_count, true, valid_public_keys_cache); // may throw
+    w.get_outs(outs, transfers, selected_transfers, fake_outputs_count, true, valid_public_keys_cache); // may throw
 
     LOG_PRINT_L2("preparing outputs");
     size_t out_index = 0;
@@ -435,6 +459,134 @@ std::vector<cryptonote::tx_source_entry> get_sources(
     return sources;
 }
 //-------------------------------------------------------------------------------------------------------------------
+std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposals_wallet2_createtoken(
+    wallet2 &w,
+    const cryptonote::token_metadata_t &token,
+    const cryptonote::tx_destination_entry &de,
+    const rct::xmr_amount fee_per_weight,
+    const rct::xmr_amount fee_quantization_mask,
+    const uint32_t subaddr_account,
+    const std::set<uint32_t> &subaddr_indices,
+    const std::uint64_t top_block_index)
+{
+    wallet2::transfer_container unused_transfers;
+    w.get_transfers(unused_transfers, "SAL1");
+
+    std::vector<carrot::CarrotTransactionProposalV1> tx_proposals;
+    tx_proposals.reserve(1 / (carrot::CARROT_MAX_TX_OUTPUTS - 1) + 1);
+
+    const crypto::public_key change_address_spend_pubkey
+      = find_change_address_spend_pubkey(w.get_account().get_subaddress_map_ref(), subaddr_account);
+
+    std::vector<cryptonote::tx_destination_entry> dsts = {de};
+    while (!dsts.empty())
+    {
+        const std::size_t num_dsts_to_complete = std::min<std::size_t>(dsts.size(), carrot::CARROT_MAX_TX_OUTPUTS - 1);
+
+        // build payment proposals and subtractable info from last `num_dsts_to_complete` dsts
+        std::vector<carrot::CarrotPaymentProposalV1> normal_payment_proposals;
+        std::vector<carrot::CarrotPaymentProposalVerifiableSelfSendV1> selfsend_payment_proposals;
+        std::set<std::size_t> subtractable_normal_payment_proposals;
+        std::set<std::size_t> subtractable_selfsend_payment_proposals;
+        for (size_t i = 0; i < num_dsts_to_complete && !dsts.empty(); ++i)
+        {
+            const cryptonote::tx_destination_entry &dst = dsts.back();
+            const bool is_selfsend = build_payment_proposals(normal_payment_proposals,
+                selfsend_payment_proposals,
+                dst,
+                w.get_account().get_subaddress_map_cn());
+            dsts.pop_back();
+        }
+
+        // make input selector
+        std::set<size_t> selected_transfer_indices;
+        carrot::select_inputs_func_t select_inputs = make_wallet2_single_transfer_input_selector(
+            unused_transfers,
+            subaddr_account,
+            subaddr_indices,
+            w.ignore_outputs_above(),
+            w.ignore_outputs_below(),
+            top_block_index,
+            true, //allow_carrot_external_inputs_in_normal_transfers
+            true, //allow_pre_carrot_inputs_in_normal_transfers
+            std::string("SAL1"),
+            selected_transfer_indices);
+
+        // make proposal
+        carrot::CarrotTransactionProposalV1 tx_proposal;
+        carrot::make_carrot_transaction_proposal_v1_transfer(
+            normal_payment_proposals,
+            selfsend_payment_proposals,
+            fee_per_weight,
+            fee_quantization_mask,
+            {},
+            cryptonote::transaction_type::CREATE_TOKEN,
+            std::move(select_inputs),
+            change_address_spend_pubkey,
+            {{subaddr_account, 0}, carrot::AddressDeriveType::Carrot, false},
+            subtractable_normal_payment_proposals,
+            subtractable_selfsend_payment_proposals,
+            "SAL1",
+            tx_proposal);
+        
+        // populate the sources
+        std::vector<size_t> selected_transfer_indices_sorted;
+        for (const auto &ki: tx_proposal.key_images_sorted) {
+          // Scan the transfer_container instead of all of the transfers in the wallet
+          selected_transfer_indices_sorted.push_back(w.get_transfer_details_from_container(ki, unused_transfers));
+        }
+        tx_proposal.sources = get_sources(unused_transfers, selected_transfer_indices_sorted, "SAL1", w);
+
+        // update `unused_transfers` for next proposal by removing selected transfers
+        tools::for_all_in_vector_erase_no_preserve_order_if(unused_transfers,
+            [&tx_proposal](const wallet2::transfer_details &td) -> bool {
+                const auto &used_kis = tx_proposal.key_images_sorted;
+                const auto ki_it = std::find(used_kis.cbegin(), used_kis.cend(), td.m_key_image);
+                return ki_it != used_kis.cend();
+            }
+        );
+
+        tx_proposal.token = token;
+        
+        tx_proposals.push_back(std::move(tx_proposal));
+    }
+    return tx_proposals;
+}
+//-------------------------------------------------------------------------------------------------------------------
+std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposals_wallet2_createtoken(
+    wallet2 &w,
+    const cryptonote::token_metadata_t &token,
+    const cryptonote::tx_destination_entry &de,
+    const std::uint32_t priority,
+    const std::uint32_t subaddr_account,
+    const std::set<uint32_t> &subaddr_indices)
+{
+    const bool use_per_byte_fee = w.use_fork_rules(HF_VERSION_PER_BYTE_FEE, 0);
+    CHECK_AND_ASSERT_THROW_MES(use_per_byte_fee,
+        "make_carrot_transaction_proposals_wallet2_createtoken: not using per-byte base fee");
+
+    const rct::xmr_amount fee_per_weight = w.get_base_fee(priority);
+    MDEBUG("fee_per_weight = " << fee_per_weight << ", from priority = " << priority);
+    
+    const rct::xmr_amount fee_quantization_mask = w.get_fee_quantization_mask();
+    MDEBUG("fee_quantization_mask = " << fee_quantization_mask << ", from priority = " << priority);
+
+    const std::uint64_t current_chain_height = w.get_blockchain_current_height();
+    CHECK_AND_ASSERT_THROW_MES(current_chain_height > 0,
+        "make_carrot_transaction_proposals_wallet2_createtoken: chain height is 0, there is no top block");
+    const std::uint64_t top_block_index = current_chain_height - 1;
+
+    return make_carrot_transaction_proposals_wallet2_createtoken(
+        w,
+        token,
+        de,
+        fee_per_weight,
+        fee_quantization_mask,
+        subaddr_account,
+        subaddr_indices,
+        top_block_index);
+}
+//-------------------------------------------------------------------------------------------------------------------
 std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposals_wallet2_transfer(
     wallet2 &w,
     std::vector<cryptonote::tx_destination_entry> dsts,
@@ -447,8 +599,16 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
     wallet2::unique_index_container subtract_fee_from_outputs,
     const std::uint64_t top_block_index)
 {
+    // Make sure all destinations have the SAME asset_type
+    std::string asset_type = dsts[0].asset_type;
+    if (dsts.size() > 1) {
+      for (size_t i=0; i<dsts.size(); ++i) {
+        CHECK_AND_ASSERT_THROW_MES(dsts[i].asset_type == asset_type, "Mixed asset_types in transaction outputs is forbidden");
+      }
+    }
+  
     wallet2::transfer_container unused_transfers;
-    w.get_transfers(unused_transfers);
+    w.get_transfers(unused_transfers, asset_type);
 
     std::vector<carrot::CarrotTransactionProposalV1> tx_proposals;
     tx_proposals.reserve(dsts.size() / (carrot::CARROT_MAX_TX_OUTPUTS - 1) + 1);
@@ -493,30 +653,33 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
             top_block_index,
             /*allow_carrot_external_inputs_in_normal_transfers=*/true,
             /*allow_pre_carrot_inputs_in_normal_transfers=*/true,
+            asset_type,
             selected_transfer_indices);
 
         // make proposal
         carrot::CarrotTransactionProposalV1 tx_proposal;
         carrot::make_carrot_transaction_proposal_v1_transfer(
-            normal_payment_proposals,
-            selfsend_payment_proposals,
-            fee_per_weight,
-            fee_quantization_mask,
-            extra,
-            tx_type,
-            std::move(select_inputs),
-            change_address_spend_pubkey,
-            {{subaddr_account, 0}, carrot::AddressDeriveType::Carrot, false},
-            subtractable_normal_payment_proposals,
-            subtractable_selfsend_payment_proposals,
-            tx_proposal);
+                                                             normal_payment_proposals,
+                                                             selfsend_payment_proposals,
+                                                             fee_per_weight,
+                                                             fee_quantization_mask,
+                                                             extra,
+                                                             tx_type,
+                                                             std::move(select_inputs),
+                                                             change_address_spend_pubkey,
+                                                             {{subaddr_account, 0}, carrot::AddressDeriveType::Carrot, false},
+                                                             subtractable_normal_payment_proposals,
+                                                             subtractable_selfsend_payment_proposals,
+                                                             asset_type,
+                                                             tx_proposal);
         
         // populate the sources
         std::vector<size_t> selected_transfer_indices_sorted;
         for (const auto &ki: tx_proposal.key_images_sorted) {
-            selected_transfer_indices_sorted.push_back(w.get_transfer_details(ki));
+          // Scan the transfer_container instead of all of the transfers in the wallet
+          selected_transfer_indices_sorted.push_back(w.get_transfer_details_from_container(ki, unused_transfers));
         }
-        tx_proposal.sources = get_sources(unused_transfers, selected_transfer_indices_sorted, "SAL1", w);
+        tx_proposal.sources = get_sources(unused_transfers, selected_transfer_indices_sorted, asset_type, w);
 
         // update `unused_transfers` for next proposal by removing selected transfers
         tools::for_all_in_vector_erase_no_preserve_order_if(unused_transfers,
@@ -547,8 +710,12 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
     CHECK_AND_ASSERT_THROW_MES(use_per_byte_fee,
         "make_carrot_transaction_proposals_wallet2_transfer: not using per-byte base fee");
 
-    const rct::xmr_amount fee_per_weight = w.get_base_fee(priority);
-    MDEBUG("fee_per_weight = " << fee_per_weight << ", from priority = " << priority);
+    // check if this is a token transfer (sal prefix) - tokens have zero fees
+    const std::string asset_type = dsts.empty() ? "SAL1" : (tx_type == cryptonote::transaction_type::BURN ? "SAL1" : dsts[0].asset_type);
+    const bool is_token = cryptonote::is_asset_type_token(asset_type);
+    
+    const rct::xmr_amount fee_per_weight = /*is_token ? 0 :*/ w.get_base_fee(priority);
+    MDEBUG("fee_per_weight = " << fee_per_weight << ", from priority = " << priority << ", is_token = " << is_token);
     
     const rct::xmr_amount fee_quantization_mask = w.get_fee_quantization_mask();
     MDEBUG("fee_quantization_mask = " << fee_quantization_mask << ", from priority = " << priority);
@@ -583,33 +750,44 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
     const cryptonote::transaction_type tx_type,
     const std::uint64_t top_block_index)
 {
-    wallet2::transfer_container transfers;
-    w.get_transfers(transfers);
-
     const size_t n_inputs = input_key_images.size();
     CARROT_CHECK_AND_THROW(n_inputs, carrot::too_few_inputs, "no key images provided");
     CARROT_CHECK_AND_THROW(n_dests_per_tx, carrot::too_few_outputs, "sweep must have at least one destination");
     CARROT_CHECK_AND_THROW(n_dests_per_tx <= carrot::CARROT_MAX_TX_OUTPUTS,
         carrot::too_many_outputs, "too many sweep destinations per transaction");
 
+    // Make sure all destinations have the SAME asset_type
+    std::string asset_type = "";
+    for (const crypto::key_image &ki : input_key_images) {
+      const wallet2::transfer_details &td = w.get_transfer_details(w.get_transfer_details(ki));
+      if (asset_type == "")
+        asset_type = td.asset_type;
+      else
+        CHECK_AND_ASSERT_THROW_MES(td.asset_type == asset_type, "Mixed asset_types in transaction inputs is forbidden");
+    }
+  
+    wallet2::transfer_container unused_transfers;
+    w.get_transfers(unused_transfers, asset_type);
+
     // Check that the key image is usable and isn't spent, collect amounts, and get subaddress account index
     std::vector<rct::xmr_amount> input_amounts;
     input_amounts.reserve(input_key_images.size());
     std::uint32_t subaddr_account = std::numeric_limits<std::uint32_t>::max();
-    const auto best_transfers_by_ki = collect_non_burned_transfers_by_key_image(transfers);
+    const auto best_transfers_by_ki = collect_non_burned_transfers_by_key_image(unused_transfers);
     for (const crypto::key_image &ki : input_key_images)
     {
         const auto ki_it = best_transfers_by_ki.find(ki);
         CHECK_AND_ASSERT_THROW_MES(ki_it != best_transfers_by_ki.cend(),
             __func__ << ": unknown key image");
-        const wallet2::transfer_details &td = transfers.at(ki_it->second);
+        const wallet2::transfer_details &td = unused_transfers.at(ki_it->second);
         CHECK_AND_ASSERT_THROW_MES(is_transfer_usable_for_input_selection(td,
-                td.m_subaddr_index.major,
-                /*from_subaddresses=*/{},
-                /*ignore_above=*/MONEY_SUPPLY,
-                /*ignore_below=*/0,
-                top_block_index),
-            __func__ << ": transfer not usable as an input");
+                                                                          td.m_subaddr_index.major,
+                                                                          /*from_subaddresses=*/{},
+                                                                          /*ignore_above=*/MONEY_SUPPLY,
+                                                                          /*ignore_below=*/0,
+                                                                          top_block_index,
+                                                                          asset_type),
+                                   __func__ << ": transfer not usable as an input");
         input_amounts.push_back(td.amount());
         subaddr_account = std::min(subaddr_account, td.m_subaddr_index.major);
     }
@@ -626,7 +804,7 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
         de.amount = 0;
         de.addr = address;
         de.is_subaddress = is_subaddress;
-        de.asset_type = "SAL1";
+        de.asset_type = asset_type;
         const bool is_selfsend_dest = build_payment_proposals(normal_payment_proposals,
             selfsend_payment_proposals,
             de,
@@ -656,22 +834,23 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
             selected_inputs.push_back({input_amounts.at(ki_idx), input_key_images.at(ki_idx)});
 
         carrot::make_carrot_transaction_proposal_v1_sweep(normal_payment_proposals,
-            selfsend_payment_proposals,
-            fee_per_weight,
-            fee_quantization_mask,
-            extra,
-            tx_type,
-            std::move(selected_inputs),
-            change_address_spend_pubkey,
-            {{subaddr_account, 0}, carrot::AddressDeriveType::Carrot},
-            tx_proposal);
+                                                          selfsend_payment_proposals,
+                                                          fee_per_weight,
+                                                          fee_quantization_mask,
+                                                          extra,
+                                                          tx_type,
+                                                          std::move(selected_inputs),
+                                                          change_address_spend_pubkey,
+                                                          {{subaddr_account, 0}, carrot::AddressDeriveType::Carrot},
+                                                          asset_type,
+                                                          tx_proposal);
     
         // populate the sources
         std::vector<size_t> selected_transfer_indices_sorted;
         for (const auto &ki: tx_proposal.key_images_sorted) {
-            selected_transfer_indices_sorted.push_back(w.get_transfer_details(ki));
+          selected_transfer_indices_sorted.push_back(w.get_transfer_details_from_container(ki, unused_transfers));
         }
-        tx_proposal.sources = get_sources(transfers, selected_transfer_indices_sorted, "SAL1", w);
+        tx_proposal.sources = get_sources(unused_transfers, selected_transfer_indices_sorted, asset_type, w);
     }
 
     CARROT_CHECK_AND_THROW(ki_idx == input_key_images.size(),
@@ -721,12 +900,13 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
     const rct::xmr_amount fee_quantization_mask,
     const std::vector<uint8_t> &extra,
     const cryptonote::transaction_type tx_type,
+    const std::string &asset_type,
     const std::uint32_t subaddr_account,
     const std::set<uint32_t> &subaddr_indices,
     const std::uint64_t top_block_index)
 {
     wallet2::transfer_container transfers;
-    w.get_transfers(transfers);
+    w.get_transfers(transfers, asset_type);
 
     const std::unordered_map<crypto::key_image, size_t> unburned_transfers_by_key_image =
         collect_non_burned_transfers_by_key_image(transfers);
@@ -738,12 +918,13 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
         const wallet2::transfer_details &td = transfers.at(transfer_idx);
 
         if (!is_transfer_usable_for_input_selection(td,
-                subaddr_account,
-                subaddr_indices,
-                only_below ? only_below : MONEY_SUPPLY,
-                1, // ignore_below
-                top_block_index))
-            continue;
+                                                    subaddr_account,
+                                                    subaddr_indices,
+                                                    only_below ? only_below : MONEY_SUPPLY,
+                                                    1, // ignore_below
+                                                    top_block_index,
+                                                    asset_type))
+          continue;
 
         const auto ki_it = unburned_transfers_by_key_image.find(td.m_key_image);
         if (ki_it == unburned_transfers_by_key_image.cend())
@@ -778,6 +959,7 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
     const std::uint32_t priority,
     const std::vector<uint8_t> &extra,
     const cryptonote::transaction_type tx_type,
+    const std::string &asset_type,
     const std::uint32_t subaddr_account,
     const std::set<uint32_t> &subaddr_indices)
 {
@@ -799,6 +981,7 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
         fee_quantization_mask,
         extra,
         tx_type,
+        asset_type,
         subaddr_account,
         subaddr_indices,
         top_block_index);
@@ -1082,15 +1265,24 @@ cryptonote::transaction finalize_all_proofs_from_transfer_details(
 
     // serialize transaction
     cryptonote::transaction tx = carrot::store_carrot_to_transaction_v1(enotes,
-        tx_proposal.key_images_sorted,
-        tx_proposal.sources,
-        tx_proposal.fee,
-        tx_proposal.tx_type,
-        tx_proposal.amount_burnt,
-        change_masks,
-        return_enote_out,
-        encrypted_payment_id);
+                                                                        tx_proposal.key_images_sorted,
+                                                                        tx_proposal.sources,
+                                                                        tx_proposal.fee,
+                                                                        tx_proposal.tx_type,
+                                                                        tx_proposal.amount_burnt,
+                                                                        change_masks,
+                                                                        tx_proposal.token,
+                                                                        return_enote_out,
+                                                                        encrypted_payment_id,
+                                                                        const_cast<wallet2&>(w).get_current_hard_fork());
 
+    // store the binding tag
+    tx.rollup_binding_tag = tx_proposal.rollup_binding_tag;
+
+    // Is this a ROLLUP TX? If so, store the rollup data
+    if (tx_proposal.tx_type == cryptonote::transaction_type::ROLLUP)
+      tx.layer2_rollup_data = tx_proposal.layer2_rollup_data;
+    
     // aliases
     hw::device &hwdev = acc_keys.get_device();
     const auto &sources = tx_proposal.sources;
@@ -1263,7 +1455,10 @@ wallet2::pending_tx make_pending_carrot_tx(const carrot::CarrotTransactionPropos
         "make_pending_carrot_tx: tx proposal has unset tx type"
     );
     CARROT_CHECK_AND_THROW(n_inputs >= 1, carrot::too_few_inputs, "carrot tx proposal missing inputs");
-    if (tx_proposal.tx_type  == cryptonote::transaction_type::STAKE || tx_proposal.tx_type == cryptonote::transaction_type::BURN) {
+    if (tx_proposal.tx_type  == cryptonote::transaction_type::STAKE ||
+        tx_proposal.tx_type == cryptonote::transaction_type::BURN ||
+        tx_proposal.tx_type == cryptonote::transaction_type::CREATE_TOKEN ||
+        tx_proposal.tx_type == cryptonote::transaction_type::ROLLUP) {
         CARROT_CHECK_AND_THROW(n_outputs == 1, carrot::too_few_outputs, "carrot tx proposal doesn't have correct number of outputs");
     } else {
         CARROT_CHECK_AND_THROW(n_outputs >= 2, carrot::too_few_outputs, "carrot tx proposal missing outputs");
diff --git a/src/wallet/tx_builder.h b/src/wallet/tx_builder.h
index 787efd00f..2fda3a7d3 100644
--- a/src/wallet/tx_builder.h
+++ b/src/wallet/tx_builder.h
@@ -55,8 +55,26 @@ carrot::select_inputs_func_t make_wallet2_single_transfer_input_selector(
     const std::uint64_t top_block_index,
     const bool allow_carrot_external_inputs_in_normal_transfers,
     const bool allow_pre_carrot_inputs_in_normal_transfers,
+    const std::string &asset_type,
     std::set<size_t> &selected_transfer_indices_out);
 
+std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposals_wallet2_createtoken(
+    wallet2 &w,
+    const cryptonote::token_metadata_t &token,
+    const cryptonote::tx_destination_entry &de,
+    const rct::xmr_amount fee_per_weight,
+    const rct::xmr_amount fee_quantization_mask,
+    const uint32_t subaddr_account,
+    const std::set<uint32_t> &subaddr_indices,
+    const std::uint64_t top_block_index);
+std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposals_wallet2_createtoken(
+    wallet2 &w,
+    const cryptonote::token_metadata_t &token,
+    const cryptonote::tx_destination_entry &de,
+    const std::uint32_t priority,
+    const std::uint32_t subaddr_account,
+    const std::set<uint32_t> &subaddr_indices);
+
 std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposals_wallet2_transfer(
     wallet2 &w,
     std::vector<cryptonote::tx_destination_entry> dsts,
@@ -109,6 +127,7 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
     const rct::xmr_amount fee_quantization_mask,
     const std::vector<uint8_t> &extra,
     const cryptonote::transaction_type tx_type,
+    const std::string &asset_type,
     const std::uint32_t subaddr_account,
     const std::set<uint32_t> &subaddr_indices,
     const std::uint64_t top_block_index);
@@ -121,6 +140,7 @@ std::vector<carrot::CarrotTransactionProposalV1> make_carrot_transaction_proposa
     const std::uint32_t priority,
     const std::vector<uint8_t> &extra,
     const cryptonote::transaction_type tx_type,
+    const std::string &asset_type,
     const std::uint32_t subaddr_account,
     const std::set<uint32_t> &subaddr_indices);
 wallet2::pending_tx make_pending_carrot_tx(const carrot::CarrotTransactionProposalV1 &tx_proposal,
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 8efdc2f3c..22632cd00 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -2157,6 +2157,22 @@ size_t wallet2::get_transfer_details(const crypto::key_image &ki) const
   CHECK_AND_ASSERT_THROW_MES(false, "Key image not found");
 }
 //----------------------------------------------------------------------------------------------------
+size_t wallet2::get_transfer_details_from_container(const crypto::key_image &ki, const transfer_container& container) const
+{
+  for (size_t idx = 0; idx < container.size(); ++idx)
+  {
+    const transfer_details &td = container[idx];
+    if (td.m_key_image == ki)
+    {
+      if (td.m_key_image_known)
+        return idx;
+      else if (td.m_key_image_partial)
+        CHECK_AND_ASSERT_THROW_MES(false, "Transfer detail lookups are not allowed for multisig partial key images");
+    }
+  }
+  CHECK_AND_ASSERT_THROW_MES(false, "Key image not found");
+}
+//----------------------------------------------------------------------------------------------------
 bool wallet2::frozen(const transfer_details &td) const
 {
   return td.m_frozen;
@@ -2230,6 +2246,41 @@ bool wallet2::get_circulating_supply(std::vector<std::pair<std::string, std::str
   }
 }
 //----------------------------------------------------------------------------------------------------
+bool wallet2::get_tokens(const std::string& filter, std::vector<std::string> &tokens)
+{
+  // Issue an RPC call to get the block header (and thus the pricing record) at the specified height
+  cryptonote::COMMAND_RPC_GET_TOKENS::request req = AUTO_VAL_INIT(req);
+  cryptonote::COMMAND_RPC_GET_TOKENS::response res = AUTO_VAL_INIT(res);
+  m_daemon_rpc_mutex.lock();
+  req.filter = filter;
+  bool r = invoke_http_json_rpc("/json_rpc", "get_tokens", req, res, rpc_timeout);
+  m_daemon_rpc_mutex.unlock();
+  if (r && res.status == CORE_RPC_STATUS_OK)
+  {
+    // Got the token data
+    tokens = res.tokens;
+    return true;
+  }
+  else
+  {
+    MERROR("Failed to retrieve tokens from daemon");
+    return false;
+  }
+}
+//----------------------------------------------------------------------------------------------------
+cryptonote::token_metadata_t wallet2::get_token_info(const std::string& asset_type)
+{
+  cryptonote::COMMAND_RPC_GET_TOKEN_INFO::request req = AUTO_VAL_INIT(req);
+  cryptonote::COMMAND_RPC_GET_TOKEN_INFO::response res = AUTO_VAL_INIT(res);
+  req.asset_type = asset_type;
+  m_daemon_rpc_mutex.lock();
+  bool r = invoke_http_json_rpc("/json_rpc", "get_token_info", req, res, rpc_timeout);
+  m_daemon_rpc_mutex.unlock();
+  THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to connect to daemon");
+  THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, res.status);
+  return res.token;
+}
+//----------------------------------------------------------------------------------------------------
 bool wallet2::get_yield_info(std::vector<cryptonote::yield_block_info>& ybi_data)
 {
   // Issue an RPC call to get the block header (and thus the pricing record) at the specified height
@@ -2657,7 +2708,8 @@ void wallet2::process_new_scanned_transaction(
     td.m_tx = tx;
     td.m_txid = txid;
     td.m_amount = enote_scan_info->amount;
-    td.asset_type = enote_scan_info->asset_type; 
+    td.asset_type = enote_scan_info->asset_type;
+    MINFO("Wallet received output: asset_type=" << enote_scan_info->asset_type << ", amount=" << enote_scan_info->amount << ", txid=" << txid); 
     td.m_pk_index = enote_scan_info->main_tx_pubkey_index;
     td.m_subaddr_index = subaddr_index_cn;
     td.m_mask = enote_scan_info->amount_blinding_factor;
@@ -2731,6 +2783,7 @@ void wallet2::process_new_scanned_transaction(
 
     // update m_transfer_indices
     m_transfers_indices[enote_scan_info->asset_type].insert(m_transfers.size()-1);
+    MINFO("Added to m_transfers_indices: asset_type=" << enote_scan_info->asset_type << ", index=" << (m_transfers.size()-1));
 
     // Check for STAKE / AUDIT TX payouts
     if (tx.type == cryptonote::transaction_type::PROTOCOL && td.m_td_origin_idx != std::numeric_limits<uint64_t>::max()) {
@@ -2740,26 +2793,35 @@ void wallet2::process_new_scanned_transaction(
                                 error::wallet_internal_error,
                                 "cannot locate return_payment TX origin in m_transfers");
       const transfer_details &td_origin = m_transfers[td.m_td_origin_idx];
-      THROW_WALLET_EXCEPTION_IF(td_origin.m_tx.type != cryptonote::transaction_type::AUDIT && td_origin.m_tx.type != cryptonote::transaction_type::STAKE,
+      THROW_WALLET_EXCEPTION_IF(td_origin.m_tx.type != cryptonote::transaction_type::AUDIT &&
+                                td_origin.m_tx.type != cryptonote::transaction_type::STAKE &&
+                                td_origin.m_tx.type != cryptonote::transaction_type::CREATE_TOKEN,
                                 error::wallet_internal_error,
                                 "incorrect TX type for protocol_tx origin in m_transfers");
-                    
-      // Get the output key for the change entry
-      crypto::public_key pk_locked_coins = crypto::null_pkey;
-      THROW_WALLET_EXCEPTION_IF(!get_output_public_key(td_origin.m_tx.vout[td_origin.m_internal_output_index], pk_locked_coins),
-                                error::wallet_internal_error,
-                                "Failed to get output public key for locked coins");
 
-      // At this point, we need to clear the "locked coins" count, because otherwise we will be counting yield stakes twice in our balance
-      if (!m_locked_coins.erase(pk_locked_coins)) {
-        LOG_ERROR("Failed to remove protocol_tx entry from m_locked_coins - possible duplicate output key detected");
+      if (td_origin.m_tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+
+        THROW_WALLET_EXCEPTION_IF(td_origin.m_tx.type != cryptonote::transaction_type::CREATE_TOKEN, error::wallet_internal_error, "can't happen");
+        
+      } else {
+        
+        // Get the output key for the change entry
+        crypto::public_key pk_locked_coins = crypto::null_pkey;
+        THROW_WALLET_EXCEPTION_IF(!get_output_public_key(td_origin.m_tx.vout[td_origin.m_internal_output_index], pk_locked_coins),
+                                  error::wallet_internal_error,
+                                  "Failed to get output public key for locked coins");
+        
+        // At this point, we need to clear the "locked coins" count, because otherwise we will be counting yield stakes twice in our balance
+        if (!m_locked_coins.erase(pk_locked_coins)) {
+          LOG_ERROR("Failed to remove protocol_tx entry from m_locked_coins - possible duplicate output key detected");
+        }
       }
     }
 
     // Check for STAKE / AUDIT TXs
     if (tx.type == cryptonote::transaction_type::AUDIT || tx.type == cryptonote::transaction_type::STAKE) {
 
-      // Add a "locked coins" entry so users don't freak out when they STAKE/AUDITOA
+      // Add a "locked coins" entry so users don't freak out when they STAKE/AUDIT
       m_locked_coins.insert({onetime_address, {0, tx.amount_burnt, tx.source_asset_type}});
     }
     
@@ -3086,6 +3148,33 @@ void wallet2::process_new_blockchain_entry(const cryptonote::block& b,
   //optimization: seeking only for blocks that are not older then the wallet creation time plus 1 day. 1 day is for possible user incorrect time setup
   if (!should_skip_block(b, height))
   {
+    TIME_MEASURE_START(create_token_txs_handle_time);
+    THROW_WALLET_EXCEPTION_IF(bche.txs.size() != b.tx_hashes.size(), error::wallet_internal_error, "Wrong amount of transactions for block");
+    THROW_WALLET_EXCEPTION_IF(bche.txs.size() != parsed_block.txes.size(), error::wallet_internal_error, "Wrong amount of transactions for block");
+    for (size_t idx = 0; idx < b.tx_hashes.size(); ++idx)
+    {
+      const cryptonote::transaction &tx = parsed_block.txes.at(idx);
+      if (tx.type != cryptonote::transaction_type::CREATE_TOKEN)
+        continue;
+      size_t n_outs_in_tx = tx.vout.size();
+      process_new_scanned_transaction(b.tx_hashes[idx],
+                                      tx,
+                                      {enote_scan_infos.data(), std::min(enote_scan_infos.size(), n_outs_in_tx)},
+                                      {output_key_images.data(), std::min(output_key_images.size(), n_outs_in_tx)},
+                                      parsed_block.o_indices.indices[idx+2].indices,
+                                      parsed_block.asset_type_output_indices.indices[idx+2].indices,
+                                      height,
+                                      b.major_version,
+                                      b.timestamp,
+                                      /*miner_tx=*/false,
+                                      /*pool=*/false,
+                                      /*double_spend_seen=*/false,
+                                      output_tracker_cache);
+      enote_scan_infos.remove_prefix(n_outs_in_tx);
+      output_key_images.remove_prefix(n_outs_in_tx);
+    }
+    TIME_MEASURE_FINISH(create_token_txs_handle_time);
+
     // Miner_tx
     size_t n_outs_in_tx = b.miner_tx.vout.size();
     TIME_MEASURE_START(miner_tx_handle_time);
@@ -3140,6 +3229,8 @@ void wallet2::process_new_blockchain_entry(const cryptonote::block& b,
     for (size_t idx = 0; idx < b.tx_hashes.size(); ++idx)
     {
       const cryptonote::transaction &tx = parsed_block.txes.at(idx);
+      if (tx.type == cryptonote::transaction_type::CREATE_TOKEN)
+        continue;
       n_outs_in_tx = tx.vout.size();
       process_new_scanned_transaction(b.tx_hashes[idx],
                                       tx,
@@ -3437,6 +3528,14 @@ void wallet2::process_parsed_blocks(const uint64_t start_height, const std::vect
       const parsed_block &par_blk = parsed_blocks.at(i+j);
       const std::uint64_t height = start_height + i + j;
       const bool skip_scan_for_this_block = should_skip_block(par_blk.block, height);
+      for (const cryptonote::transaction &tx : par_blk.txes)
+      {
+        if (tx.type == cryptonote::transaction_type::CREATE_TOKEN) {
+          if (!skip_scan_for_this_block)
+            tx_scan_job(std::cref(tx), tx_output_idx);
+          tx_output_idx += tx.vout.size();
+        }
+      }
       if (!skip_scan_for_this_block && m_refresh_type != RefreshNoCoinbase)
         tpool.submit(&scan_blocks_waiter, std::bind(tx_scan_job, std::cref(par_blk.block.miner_tx), tx_output_idx));
       tx_output_idx += par_blk.block.miner_tx.vout.size();
@@ -3445,9 +3544,11 @@ void wallet2::process_parsed_blocks(const uint64_t start_height, const std::vect
       tx_output_idx += par_blk.block.protocol_tx.vout.size();
       for (const cryptonote::transaction &tx : par_blk.txes)
       {
-        if (!skip_scan_for_this_block)
-          tpool.submit(&scan_blocks_waiter, std::bind(tx_scan_job, std::cref(tx), tx_output_idx));
-        tx_output_idx += tx.vout.size();
+        if (tx.type != cryptonote::transaction_type::CREATE_TOKEN) {
+          if (!skip_scan_for_this_block)
+            tpool.submit(&scan_blocks_waiter, std::bind(tx_scan_job, std::cref(tx), tx_output_idx));
+          tx_output_idx += tx.vout.size();
+        }
       }
     }
     if (!scan_blocks_waiter.wait())
@@ -3467,9 +3568,9 @@ void wallet2::process_parsed_blocks(const uint64_t start_height, const std::vect
     const cryptonote::block &bl = parsed_blocks[i].block;
 
     size_t n_block_outputs = bl.miner_tx.vout.size();
-    n_block_outputs += bl.protocol_tx.vout.size();
     for (const cryptonote::transaction &tx : parsed_blocks.at(i).txes)
       n_block_outputs += tx.vout.size();
+    n_block_outputs += bl.protocol_tx.vout.size();
     const epee::span<const std::optional<wallet::enote_view_incoming_scan_info_t>> enote_scan_infos_span(
       enote_scan_infos.data() + tx_output_idx, n_block_outputs);
     const epee::span<const std::optional<crypto::key_image>> output_key_images_span(
@@ -7377,9 +7478,23 @@ uint64_t wallet2::unlocked_balance_all(bool strict, const std::string& asset_typ
   return r;
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::get_transfers(wallet2::transfer_container& incoming_transfers) const
+void wallet2::get_transfers(wallet2::transfer_container& incoming_transfers, const std::string& asset_type) const
 {
-  incoming_transfers = m_transfers;
+  if (asset_type == "") {
+    incoming_transfers = m_transfers;
+  } else {
+    CHECK_AND_ASSERT_THROW_MES(m_transfers_indices.count(asset_type) == 1, "invalid asset_type specified to get_transfers");
+    incoming_transfers.clear();
+    incoming_transfers.reserve(m_transfers_indices.at(asset_type).size());
+    for (size_t i: m_transfers_indices.at(asset_type))
+      incoming_transfers.push_back(m_transfers[i]);
+  }
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::get_transfers_indices(std::set<size_t>& indices, const std::string& asset_type) const
+{
+  CHECK_AND_ASSERT_THROW_MES(m_transfers_indices.count(asset_type) == 1, "invalid asset_type specified to get_transfers_indices");
+  indices = m_transfers_indices.at(asset_type);
 }
 //----------------------------------------------------------------------------------------------------
 void wallet2::get_payments(const crypto::hash& payment_id, std::list<wallet2::payment_details>& payments, uint64_t min_height, const boost::optional<uint32_t>& subaddr_account, const std::set<uint32_t>& subaddr_indices) const
@@ -7808,9 +7923,12 @@ void wallet2::commit_tx(pending_tx& ptx)
     }
 
     // sanity checks
+    size_t max_idx = *m_transfers_indices[source_asset].rbegin();
+    THROW_WALLET_EXCEPTION_IF(max_idx >= m_transfers.size(), error::wallet_internal_error,
+                              "Bad max_idx in commit_tx: " + boost::lexical_cast<std::string>(max_idx));
     for (size_t idx: ptx.selected_transfers)
     {
-      THROW_WALLET_EXCEPTION_IF(idx >= m_transfers.size(), error::wallet_internal_error,
+      THROW_WALLET_EXCEPTION_IF(idx > max_idx, error::wallet_internal_error,
                                 "Bad output index in selected transfers: " + boost::lexical_cast<std::string>(idx));
       THROW_WALLET_EXCEPTION_IF(m_transfers[idx].asset_type != source_asset, error::wallet_internal_error,
                                 "Bad output asset_type in selected transfers: " + boost::lexical_cast<std::string>(idx));
@@ -9376,14 +9494,14 @@ std::pair<std::set<uint64_t>, size_t> outs_unique(const std::vector<std::vector<
   return std::make_pair(std::move(unique), total);
 }
 
-void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, bool rct, std::unordered_set<crypto::public_key> &valid_public_keys_cache)
+void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, const transfer_container &transfers, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, bool rct, std::unordered_set<crypto::public_key> &valid_public_keys_cache)
 {
   uint64_t num_outs_per_asset = 0;
   uint64_t num_spendable_global_outs = 0;
   std::vector<uint64_t> rct_offsets;
   for (size_t attempts = 3; attempts > 0; --attempts)
   {
-    get_outs(outs, selected_transfers, fake_outputs_count, rct_offsets, valid_public_keys_cache, num_spendable_global_outs, num_outs_per_asset);
+    get_outs(outs, transfers, selected_transfers, fake_outputs_count, rct_offsets, valid_public_keys_cache, num_spendable_global_outs, num_outs_per_asset);
 
     if (!rct)
       return;
@@ -9396,8 +9514,8 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
 
     std::vector<crypto::key_image> key_images;
     key_images.reserve(selected_transfers.size());
-    std::for_each(selected_transfers.begin(), selected_transfers.end(), [this, &key_images](size_t index) {
-      key_images.push_back(m_transfers[index].m_key_image);
+    std::for_each(selected_transfers.begin(), selected_transfers.end(), [this, &key_images, &transfers](size_t index) {
+      key_images.push_back(transfers.at(index).m_key_image);
     });
     unset_ring(key_images);
   }
@@ -9405,7 +9523,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
   THROW_WALLET_EXCEPTION(error::wallet_internal_error, tr("Transaction sanity check failed"));
 }
 
-void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, std::vector<uint64_t> &rct_offsets, std::unordered_set<crypto::public_key> &valid_public_keys_cache, uint64_t &num_spendable_global_outs, uint64_t &num_outs)
+void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, const transfer_container &transfers, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, std::vector<uint64_t> &rct_offsets, std::unordered_set<crypto::public_key> &valid_public_keys_cache, uint64_t &num_spendable_global_outs, uint64_t &num_outs)
 {
   LOG_PRINT_L2("fake_outputs_count: " << fake_outputs_count);
   outs.clear();
@@ -9428,21 +9546,21 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     bool has_rct = false;
     bool use_global_outs = false;
     uint64_t max_rct_index = 0;
-    std::string rct_asset_type = m_transfers[selected_transfers[0]].asset_type;
+    std::string rct_asset_type = transfers[selected_transfers[0]].asset_type;
     for (size_t idx: selected_transfers) {
-      THROW_WALLET_EXCEPTION_IF(m_transfers.size() < idx, error::wallet_internal_error, "requesting too high an index from m_transfers");
-      THROW_WALLET_EXCEPTION_IF(m_transfers[idx].asset_type != rct_asset_type, error::wallet_internal_error, "selected_transfer entry has wrong asset_type");
-      if (m_transfers[idx].is_rct())
+      THROW_WALLET_EXCEPTION_IF(transfers.size() < idx, error::wallet_internal_error, "requesting too high an index from transfers");
+      THROW_WALLET_EXCEPTION_IF(transfers[idx].asset_type != rct_asset_type, error::wallet_internal_error, "selected_transfer entry has wrong asset_type");
+      if (transfers[idx].is_rct())
       {
         // use_global_outs should either always be true or false, because the single rct distribution requested in get_rct_distribution below 
         // will either be the distribution of all global outputs, or the distribution of outputs by asset type. This check makes
         // sure the use_global_outs boolean will not be flipped when set in the next line.
-        //THROW_WALLET_EXCEPTION_IF(has_rct && ((use_global_outs && m_transfers[idx].m_asset_type_output_index_known) || (!use_global_outs && !m_transfers[idx].m_asset_type_output_index_known)),
+        //THROW_WALLET_EXCEPTION_IF(has_rct && ((use_global_outs && transfers[idx].m_asset_type_output_index_known) || (!use_global_outs && !transfers[idx].m_asset_type_output_index_known)),
         //  error::wallet_internal_error, "Mismatch of global outputs and asset type outputs");
 
         has_rct = true;
-        //use_global_outs = !m_transfers[idx].m_asset_type_output_index_known;
-        max_rct_index = std::max(max_rct_index, use_global_outs ? m_transfers[idx].m_global_output_index : m_transfers[idx].m_asset_type_output_index);
+        //use_global_outs = !transfers[idx].m_asset_type_output_index_known;
+        max_rct_index = std::max(max_rct_index, use_global_outs ? transfers[idx].m_global_output_index : transfers[idx].m_asset_type_output_index);
       }
     }
     
@@ -9466,8 +9584,8 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     // request histogram for all pre-rct outputs
     req_t.amounts.reserve(selected_transfers.size());
     for(size_t idx: selected_transfers)
-      if (!m_transfers[idx].is_rct())
-        req_t.amounts.push_back(m_transfers[idx].amount());
+      if (!transfers[idx].is_rct())
+        req_t.amounts.push_back(transfers[idx].amount());
     if (!req_t.amounts.empty())
     {
       std::sort(req_t.amounts.begin(), req_t.amounts.end());
@@ -9494,7 +9612,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
       cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::response resp_t = AUTO_VAL_INIT(resp_t);
       req_t.amounts.reserve(req_t.amounts.size() + selected_transfers.size());
       for(size_t idx: selected_transfers)
-        req_t.amounts.push_back(m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount());
+        req_t.amounts.push_back(transfers[idx].is_rct() ? 0 : transfers[idx].amount());
       std::sort(req_t.amounts.begin(), req_t.amounts.end());
       auto end = std::unique(req_t.amounts.begin(), req_t.amounts.end());
       req_t.amounts.resize(std::distance(req_t.amounts.begin(), end));
@@ -9518,7 +9636,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
       // check we got all data
       for(size_t idx: selected_transfers)
       {
-        const uint64_t amount = m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount();
+        const uint64_t amount = transfers[idx].is_rct() ? 0 : transfers[idx].amount();
         bool found = false;
         for (const auto &d: resp_t.distributions)
         {
@@ -9545,7 +9663,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     std::unordered_map<crypto::key_image, std::vector<uint64_t>> existing_rings;
     for(size_t idx: selected_transfers)
     {
-      const transfer_details &td = m_transfers[idx];
+      const transfer_details &td = transfers[idx];
       if (td.m_key_image_known && !td.m_key_image_partial)
         ring_key_images.push_back(td.m_key_image);
     }
@@ -9597,7 +9715,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     for(size_t idx: selected_transfers)
     {
       ++num_selected_transfers;
-      const transfer_details &td = m_transfers[idx];
+      const transfer_details &td = transfers[idx];
       const uint64_t amount = td.is_rct() ? 0 : td.amount();
       std::unordered_set<uint64_t> seen_indices;
       // request more for rct in base recent (locked) coinbases are picked, since they're locked for longer
@@ -9953,7 +10071,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     outs.reserve(num_selected_transfers);
     for(size_t idx: selected_transfers)
     {
-      const transfer_details &td = m_transfers[idx];
+      const transfer_details &td = transfers[idx];
       size_t requested_outputs_count = base_requested_outputs_count + (td.is_rct() ? CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE : 0);
       outs.push_back(std::vector<get_outs_entry>());
       outs.back().reserve(fake_outputs_count + 1);
@@ -10023,7 +10141,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
                   if (req.outputs[i].index == out /*&& req.outputs[i].is_global_out*/)
                   {
                     LOG_PRINT_L2("Index " << i << "/" << requested_outputs_count << ": idx " << req.outputs[i].index << " (real " << td.m_global_output_index << "), unlocked " << daemon_resp.outs[i].unlocked << ", key " << daemon_resp.outs[i].key << " (from existing ring)");
-                    tx_add_fake_output(outs, req.outputs[i].index, daemon_resp.outs[i].key, daemon_resp.outs[i].mask, td.m_global_output_index, daemon_resp.outs[i].unlocked, valid_public_keys_cache);
+                    tx_add_fake_output(outs, req.outputs[i].index, daemon_resp.outs[i].key, daemon_resp.outs[i].mask, use_global_outs ? td.m_global_output_index : td.m_asset_type_output_index, daemon_resp.outs[i].unlocked, valid_public_keys_cache);
                     found = true;
                     break;
                   }
@@ -10071,10 +10189,10 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
   {
     for (size_t idx: selected_transfers)
     {
-      const transfer_details &td = m_transfers[idx];
+      const transfer_details &td = transfers[idx];
       std::vector<get_outs_entry> v;
       const rct::key mask = td.is_rct() ? rct::commit(td.amount(), td.m_mask) : rct::zeroCommit(td.amount());
-      v.push_back(std::make_tuple(td.m_global_output_index, td.get_public_key(), mask));
+      v.push_back(std::make_tuple(td.m_asset_type_output_index, td.get_public_key(), mask));
       outs.push_back(v);
     }
   }
@@ -10085,8 +10203,8 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
   for (size_t i = 0; i < selected_transfers.size(); ++i)
   {
     const size_t idx = selected_transfers[i];
-    THROW_WALLET_EXCEPTION_IF(idx >= m_transfers.size(), error::wallet_internal_error, "selected_transfers entry out of range");
-    const transfer_details &td = m_transfers[idx];
+    THROW_WALLET_EXCEPTION_IF(idx >= transfers.size(), error::wallet_internal_error, "selected_transfers entry out of range");
+    const transfer_details &td = transfers[idx];
     std::vector<uint64_t> ring;
     ring.reserve(outs[i].size());
     for (const auto &e: outs[i])
@@ -10137,7 +10255,7 @@ void wallet2::transfer_selected(const std::vector<cryptonote::tx_destination_ent
     THROW_WALLET_EXCEPTION_IF(subaddr_account != m_transfers[*i].m_subaddr_index.major, error::wallet_internal_error, "the tx uses funds from multiple accounts");
 
   if (outs.empty())
-    get_outs(outs, selected_transfers, fake_outputs_count, false, valid_public_keys_cache); // may throw
+    get_outs(outs, m_transfers, selected_transfers, fake_outputs_count, false, valid_public_keys_cache); // may throw
 
   //prepare inputs
   LOG_PRINT_L2("preparing outputs");
@@ -10391,7 +10509,7 @@ void wallet2::transfer_selected_rct(std::vector<cryptonote::tx_destination_entry
     }
   }
   if (outs.empty())
-    get_outs(outs, selected_transfers, fake_outputs_count, all_rct, valid_public_keys_cache); // may throw
+    get_outs(outs, m_transfers, selected_transfers, fake_outputs_count, all_rct, valid_public_keys_cache); // may throw
 
   //prepare inputs
   LOG_PRINT_L2("preparing outputs");
@@ -10820,6 +10938,102 @@ static uint32_t get_count_above(const std::vector<wallet2::transfer_details> &tr
   return count;
 }
 
+std::vector<wallet2::pending_tx> wallet2::create_token(const std::string& token_ticker, const uint64_t token_supply, const std::string& token_metadata_hex, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices)
+{
+  // Make asset_type uppercase version of the token symbol
+  std::string asset_type = token_ticker;
+  std::transform(asset_type.begin(), asset_type.end(), asset_type.begin(), ::toupper);
+  THROW_WALLET_EXCEPTION_IF(asset_type.length() != 4, error::wallet_internal_error, tr("Invalid ticker: Must be exactly 4 characters."));
+
+  // Validate characters
+  for (char c : asset_type) {
+    THROW_WALLET_EXCEPTION_IF((!((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))), error::wallet_internal_error, tr("Invalid ticker: Only uppercase letters (A-Z) and digits (0-9) are allowed."));
+  }
+  
+  // Check if starts with "SAL"
+  THROW_WALLET_EXCEPTION_IF(asset_type.substr(0, 3) == "SAL", error::wallet_internal_error,  tr("Cannot create a private token with a name starting with 'SAL'"));
+  
+  // todo: update reserved names
+  THROW_WALLET_EXCEPTION_IF((asset_type == "SAL" || asset_type == "SAL1" || asset_type == "SAL2" || asset_type == "BURN"), error::wallet_internal_error, tr("Cannot create a private token with reserved names"));
+
+  // get tokens
+  std::vector<std::string> tokens;
+  THROW_WALLET_EXCEPTION_IF(!get_tokens(asset_type, tokens), error::wallet_internal_error, tr("failed to get tokens from network. Make sure you are connected to a daemon."));
+  THROW_WALLET_EXCEPTION_IF(!tokens.empty(), error::wallet_internal_error, (boost::format(tr("Token already exists with ticker '%s'")) % asset_type).str());
+    
+  // Verify supply amount is acceptable
+  THROW_WALLET_EXCEPTION_IF(token_supply < 1 || token_supply > (MONEY_SUPPLY / COIN), error::wallet_internal_error, (boost::format(tr("Token supply is limited to 1-%llu")) % (MONEY_SUPPLY / COIN)).str());
+
+  // Sanity check the length of the hex
+  THROW_WALLET_EXCEPTION_IF(token_metadata_hex.length() >= 2048, error::wallet_internal_error, tr("Metadata too long (max 2048 bytes permitted)"));
+
+  // Parse the metadata if provided
+  std::string name;
+  std::string url;
+  std::string hash;
+  crypto::hash signature{};
+  uint64_t size = 0;
+  if (token_metadata_hex.length()) {
+
+    // Sanity check the metadata is hex-encoded data
+    cryptonote::blobdata metadata_blob;
+    THROW_WALLET_EXCEPTION_IF(!epee::string_tools::parse_hexstr_to_binbuff(token_metadata_hex, metadata_blob), error::wallet_internal_error, tr("Failed to parse metadata hex"));
+
+    // Parse as JSON
+    rapidjson::Document json;
+    THROW_WALLET_EXCEPTION_IF(json.Parse(metadata_blob.c_str()).HasParseError(), error::wallet_internal_error, tr("Metadata is not valid JSON"));
+    if (json.HasMember("size") && json["size"].IsUint64())
+      size = json["size"].GetUint64();
+    if (json.HasMember("name") && json["name"].IsString())
+      name = json["name"].GetString();
+    if (json.HasMember("url") && json["url"].IsString())
+      url = json["url"].GetString();
+    if (json.HasMember("hash") && json["hash"].IsString()) {
+      hash = json["hash"].GetString();
+      epee::string_tools::hex_to_pod(hash, signature);
+    }
+  }
+  
+  cryptonote::sal_token_t sal_token{1, token_supply, size, name, url, signature};
+  cryptonote::token_metadata_t token{1, asset_type, sal_token};
+
+  // Call the inner function
+  return create_token(token, subaddr_account, subaddr_indices);
+}
+
+std::vector<wallet2::pending_tx> wallet2::create_token(const cryptonote::token_metadata_t& token, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices)
+{
+  //ensure device is let in NONE mode in any case
+  hw::device &hwdev = m_account.get_device();
+  boost::unique_lock<hw::device> hwdev_lock (hwdev);
+  hw::reset_mode rst(hwdev);  
+
+  // Sanity check correct CN/Carrot address is being used
+  const uint8_t hf_version = get_current_hard_fork();
+  THROW_WALLET_EXCEPTION_IF(hf_version < HF_VERSION_ENABLE_TOKENS, error::wallet_internal_error, "CREATE_TOKEN command is not available yet");
+
+  //static_assert(false, "TODO: Implement this `de` creation properly");
+  cryptonote::tx_destination_entry de;
+
+  de.addr = m_account.get_keys().m_carrot_account_address;
+  de.amount = cryptonote::get_token_creation_price(token.asset_type);
+  de.asset_type = "SAL1";
+  de.is_subaddress = false;
+  de.is_integrated = false;
+  de.is_change = false;
+  de.is_return = false;
+  
+  uint32_t priority = get_default_priority();
+  priority = adjust_priority(priority);
+
+  const auto tx_proposals = tools::wallet::make_carrot_transaction_proposals_wallet2_createtoken(*this, token, de, priority, subaddr_account, subaddr_indices);
+  std::vector<pending_tx> ptx_vector;
+  ptx_vector.reserve(tx_proposals.size());
+  for (const auto &tx_proposal : tx_proposals)
+    ptx_vector.push_back(tools::wallet::finalize_all_proofs_from_transfer_details_as_pending_tx(tx_proposal, *this));
+  return ptx_vector;
+}
+
 // Another implementation of transaction creation that is hopefully better
 // While there is anything left to pay, it goes through random outputs and tries
 // to fill the next destination/amount. If it fully fills it, it will use the
@@ -10850,11 +11064,104 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
   }
   if (hf_version >= HF_VERSION_CARROT)
   {
-    const auto tx_proposals = tools::wallet::make_carrot_transaction_proposals_wallet2_transfer(*this, dsts, priority, extra, tx_type, subaddr_account, subaddr_indices, subtract_fee_from_outputs);
+    /* 
+    switch (tx_type) {
+      case transaction_type::BURN:
+      case transaction_type::CREATE_TOKEN:
+      case transaction_type::STAKE:
+        THROW_WALLET_EXCEPTION_IF(source_asset != "SAL1", error::wallet_internal_error, "STAKE TX must specify 'SAL1' source asset type");
+      case transaction_type::TRANSFER:
+        THROW_WALLET_EXCEPTION_IF(source_asset != dest_asset, error::wallet_internal_error, "Transfer TX must specify identical source and destination asset types");
+        break;
+      case transaction_type::CONVERT:
+        THROW_WALLET_EXCEPTION_IF(source_asset == dest_asset, error::wallet_internal_error, "Conversion TX must specify different source and destination asset types");
+        // Get the pricing record
+        //b = get_pricing_record(pricing_record, current_height);
+        //THROW_WALLET_EXCEPTION_IF(!b, error::wallet_internal_error, "Failed to get pricing record");
+        // Get the circulating supply data
+        //THROW_WALLET_EXCEPTION_IF(!get_circulating_supply(circ_amounts), error::wallet_internal_error, "Failed to get circulating supply");
+        break;
+      default:
+        // THROW_WALLET_EXCEPTION(error::wallet_internal_error, "Invalid tx type specified: " + std::to_string(static_cast<uint64_t>(tx_type)));
+        break;
+    }
+    */
+
+    // Is this a BURN TX?
+    if (hf_version >= HF_VERSION_ENABLE_TOKENS && tx_type == cryptonote::transaction_type::BURN) {
+      THROW_WALLET_EXCEPTION_IF(source_asset != "SAL" && source_asset != "SAL1", error::wallet_internal_error, "Only SAL and SAL1 may be burnt");
+      THROW_WALLET_EXCEPTION_IF(dsts.size() != 1, error::wallet_internal_error, "Only 1 destination permitted for BURN");
+      dsts[0].asset_type = source_asset;
+    }
+    
+    // Create a binding tag
+    carrot::rollup_binding_tag_t rollup_binding_tag = crypto::rand<carrot::rollup_binding_tag_t>();
+    
+    uint64_t total_fee = 0;
+    auto tx_proposals = tools::wallet::make_carrot_transaction_proposals_wallet2_transfer(*this, dsts, priority, extra, tx_type, subaddr_account, subaddr_indices, subtract_fee_from_outputs);
+    if (source_asset != "SAL1")
+    {
+      // We are creating a TOKEN TRANSFER
+
+      // Iterate over the transactions
+      for (auto &tx_proposal : tx_proposals)
+      {
+        // Add the fee for this proposal to the total
+        total_fee += tx_proposal.fee;
+        //tx_proposal.fee = 0; // This is not needed - we need to keep the original fee to verify the amounts, right?
+
+        // Store the binding tag
+        tx_proposal.rollup_binding_tag = rollup_binding_tag;
+      }
+    }
+    
     std::vector<pending_tx> ptx_vector;
-    ptx_vector.reserve(tx_proposals.size());
+    ptx_vector.reserve(tx_proposals.size()+1);
     for (const auto &tx_proposal : tx_proposals)
       ptx_vector.push_back(tools::wallet::finalize_all_proofs_from_transfer_details_as_pending_tx(tx_proposal, *this));
+
+    // make the tx for the fee
+    if (total_fee > 0) {
+      // set up parameters for burn tx
+      std::vector<cryptonote::tx_destination_entry> dsts_rollup;
+      cryptonote::tx_destination_entry fee_de;
+      fee_de.amount = total_fee;
+      fee_de.addr = m_account.get_keys().m_carrot_account_address;
+      fee_de.original = get_subaddress_as_str({{subaddr_account, 0}, carrot::AddressDeriveType::Carrot, false});
+      fee_de.asset_type = "SAL1";
+      fee_de.is_subaddress = false;
+      fee_de.is_integrated = false;
+      fee_de.is_change = false;
+      fee_de.is_return = false;
+      dsts_rollup.push_back(fee_de);
+
+      priority = get_default_priority();
+      auto tx_proposals_rollup = tools::wallet::make_carrot_transaction_proposals_wallet2_transfer(*this, dsts_rollup, priority, {}, cryptonote::transaction_type::ROLLUP, subaddr_account, subaddr_indices, {});
+      THROW_WALLET_EXCEPTION_IF(tx_proposals_rollup.size() != 1, error::wallet_internal_error, "Failed to create single ROLLUP TX from TRANSFER TOKEN TXs");
+
+      // Store the binding tag
+      tx_proposals_rollup[0].rollup_binding_tag = rollup_binding_tag;
+      
+      // Populate the rollup data
+      layer2_rollup_data_t rollup_data{1,{}};
+      for (auto &ptx : ptx_vector)
+      {
+        layer2_rollup_tx_t tx_rollup;
+        tx_rollup.tx_prefix_hash = get_transaction_hash(ptx.tx);
+        tx_rollup.tx_fee = ptx.tx.rct_signatures.txnFee;
+        // THROW_WALLET_EXCEPTION_IF(ptx.tx.vin.empty(), error::wallet_internal_error, "TX has no inputs");
+        THROW_WALLET_EXCEPTION_IF(ptx.tx.vin[0].type() != typeid(cryptonote::txin_to_key), error::wallet_internal_error, "TX input is not txin_to_key");
+        tx_rollup.first_key_image = boost::get<cryptonote::txin_to_key>(ptx.tx.vin[0]).k_image;
+        rollup_data.txs.push_back(std::move(tx_rollup));
+      }
+
+      // Store the rollup data
+      tx_proposals_rollup[0].layer2_rollup_data = rollup_data;
+      
+      for (const auto &tx_proposal_rollup : tx_proposals_rollup)
+        ptx_vector.insert(ptx_vector.begin(), tools::wallet::finalize_all_proofs_from_transfer_details_as_pending_tx(tx_proposal_rollup, *this));
+    }
+
     return ptx_vector;
   }
 
@@ -11667,6 +11974,10 @@ bool wallet2::sanity_check(const std::vector<wallet2::pending_tx> &ptx_vector, c
         received += ptx.tx.amount_burnt;
       else if (ptx.tx.type == cryptonote::transaction_type::AUDIT)
         received += ptx.tx.amount_burnt;
+      else if (ptx.tx.type == cryptonote::transaction_type::CREATE_TOKEN)
+        received += ptx.tx.amount_burnt;
+      else if (ptx.tx.type == cryptonote::transaction_type::ROLLUP)
+        received += ptx.tx.amount_burnt;
       
       total_received += received;
     }
@@ -11689,11 +12000,73 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_all(uint64_t below
     // Sanity checks
     THROW_WALLET_EXCEPTION_IF(!address.m_is_carrot, error::wallet_internal_error, "CryptoNote address supplied, but Carrot is now active");
     
-    const auto tx_proposals = tools::wallet::make_carrot_transaction_proposals_wallet2_sweep_all(*this, below, address, is_subaddress, outputs, priority, extra, tx_type, subaddr_account, subaddr_indices);
+    // Create a binding tag
+    carrot::rollup_binding_tag_t rollup_binding_tag = crypto::rand<carrot::rollup_binding_tag_t>();
+    
+    uint64_t total_fee = 0;
+    auto tx_proposals = tools::wallet::make_carrot_transaction_proposals_wallet2_sweep_all(*this, below, address, is_subaddress, outputs, priority, extra, tx_type, asset_type, subaddr_account, subaddr_indices);
+    if (asset_type != "SAL1")
+    {
+      // We are creating a TOKEN TRANSFER
+
+      // Iterate over the transactions
+      for (auto &tx_proposal : tx_proposals)
+      {
+        // Add the fee for this proposal to the total
+        total_fee += tx_proposal.fee;
+        //tx_proposal.fee = 0; // This is not needed - we need to keep the original fee to verify the amounts, right?
+
+        // Store the binding tag
+        tx_proposal.rollup_binding_tag = rollup_binding_tag;
+      }
+    }
+    
     std::vector<pending_tx> ptx_vector;
-    ptx_vector.reserve(tx_proposals.size());
+    ptx_vector.reserve(tx_proposals.size()+1);
     for (const auto &tx_proposal : tx_proposals)
       ptx_vector.push_back(tools::wallet::finalize_all_proofs_from_transfer_details_as_pending_tx(tx_proposal, *this));
+
+    // make the tx for the fee
+    if (total_fee > 0) {
+      // set up parameters for burn tx
+      std::vector<cryptonote::tx_destination_entry> dsts_rollup;
+      cryptonote::tx_destination_entry fee_de;
+      fee_de.amount = total_fee;
+      fee_de.addr = m_account.get_keys().m_carrot_account_address;
+      fee_de.original = get_subaddress_as_str({{subaddr_account, 0}, carrot::AddressDeriveType::Carrot, false});
+      fee_de.asset_type = "SAL1";
+      fee_de.is_subaddress = false;
+      fee_de.is_integrated = false;
+      fee_de.is_change = false;
+      fee_de.is_return = false;
+      dsts_rollup.push_back(fee_de);
+
+      priority = get_default_priority();
+      auto tx_proposals_rollup = tools::wallet::make_carrot_transaction_proposals_wallet2_transfer(*this, dsts_rollup, priority, {}, cryptonote::transaction_type::ROLLUP, subaddr_account, subaddr_indices, {});
+      THROW_WALLET_EXCEPTION_IF(tx_proposals_rollup.size() != 1, error::wallet_internal_error, "Failed to create single ROLLUP TX from TRANSFER TOKEN TXs");
+
+      // Store the binding tag
+      tx_proposals_rollup[0].rollup_binding_tag = rollup_binding_tag;
+      
+      // Populate the rollup data
+      layer2_rollup_data_t rollup_data{1,{}};
+      for (auto &ptx : ptx_vector)
+      {
+        layer2_rollup_tx_t tx_rollup;
+        tx_rollup.tx_prefix_hash = get_transaction_hash(ptx.tx);
+        tx_rollup.tx_fee = ptx.tx.rct_signatures.txnFee;
+        THROW_WALLET_EXCEPTION_IF(ptx.tx.vin[0].type() != typeid(cryptonote::txin_to_key), error::wallet_internal_error, "TX input is not txin_to_key");
+        tx_rollup.first_key_image = boost::get<cryptonote::txin_to_key>(ptx.tx.vin[0]).k_image;
+        rollup_data.txs.push_back(std::move(tx_rollup));
+      }
+
+      // Store the rollup data
+      tx_proposals_rollup[0].layer2_rollup_data = rollup_data;
+      
+      for (const auto &tx_proposal_rollup : tx_proposals_rollup)
+        ptx_vector.insert(ptx_vector.begin(), tools::wallet::finalize_all_proofs_from_transfer_details_as_pending_tx(tx_proposal_rollup, *this));
+    }
+
     return ptx_vector;
   }
 
@@ -11946,7 +12319,82 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_return(std::vector
     address.m_view_public_key = return_pub;
     address.m_is_carrot = true;
 
-    return create_transactions_from(address, cryptonote::transaction_type::RETURN, asset_type, is_subaddress, outputs, transfers_indices, unused_dust_indices, fake_outs_count, unlock_time, priority, extra);
+    // collect key images from provided transfer indices
+    std::vector<crypto::key_image> input_key_images;
+    input_key_images.reserve(transfers_indices.size() + unused_dust_indices.size());
+    for (const size_t transfer_idx : transfers_indices)
+      input_key_images.push_back(m_transfers.at(transfer_idx).m_key_image);
+    for (const size_t transfer_idx : unused_dust_indices)
+      input_key_images.push_back(m_transfers.at(transfer_idx).m_key_image);
+
+    // Create a binding tag
+    carrot::rollup_binding_tag_t rollup_binding_tag = crypto::rand<carrot::rollup_binding_tag_t>();
+    
+    uint64_t total_fee = 0;
+    auto tx_proposals = tools::wallet::make_carrot_transaction_proposals_wallet2_sweep(*this, input_key_images, address, is_subaddress, outputs, priority, extra, cryptonote::transaction_type::RETURN);
+    if (asset_type != "SAL1")
+    {
+      // We are creating a TOKEN TRANSFER
+
+      // Iterate over the transactions
+      for (auto &tx_proposal : tx_proposals)
+      {
+        // Add the fee for this proposal to the total
+        total_fee += tx_proposal.fee;
+
+        // Store the binding tag
+        tx_proposal.rollup_binding_tag = rollup_binding_tag;
+      }
+    }
+    
+    std::vector<pending_tx> ptx_vector;
+    ptx_vector.reserve(tx_proposals.size()+1);
+    for (const auto &tx_proposal : tx_proposals)
+      ptx_vector.push_back(tools::wallet::finalize_all_proofs_from_transfer_details_as_pending_tx(tx_proposal, *this));
+
+    // make the tx for the fee
+    if (total_fee > 0) {
+      // set up parameters for burn tx
+      std::vector<cryptonote::tx_destination_entry> dsts_rollup;
+      carrot::subaddress_index_extended sie{{td_origin.m_subaddr_index.major, td_origin.m_subaddr_index.minor}, carrot::AddressDeriveType::Carrot, false};
+      cryptonote::tx_destination_entry fee_de;
+      fee_de.amount = total_fee;
+      fee_de.addr = m_account.get_keys().m_carrot_account_address;
+      fee_de.original = get_subaddress_as_str(sie);
+      fee_de.asset_type = "SAL1";
+      fee_de.is_subaddress = false;
+      fee_de.is_integrated = false;
+      fee_de.is_change = false;
+      fee_de.is_return = false;
+      dsts_rollup.push_back(fee_de);
+
+      priority = get_default_priority();
+      auto tx_proposals_rollup = tools::wallet::make_carrot_transaction_proposals_wallet2_transfer(*this, dsts_rollup, priority, {}, cryptonote::transaction_type::ROLLUP, td_origin.m_subaddr_index.major, {td_origin.m_subaddr_index.minor}, {});
+      THROW_WALLET_EXCEPTION_IF(tx_proposals_rollup.size() != 1, error::wallet_internal_error, "Failed to create single ROLLUP TX from TRANSFER TOKEN TXs");
+
+      // Store the binding tag
+      tx_proposals_rollup[0].rollup_binding_tag = rollup_binding_tag;
+      
+      // Populate the rollup data
+      layer2_rollup_data_t rollup_data{1,{}};
+      for (auto &ptx : ptx_vector)
+      {
+        layer2_rollup_tx_t tx_rollup;
+        tx_rollup.tx_prefix_hash = get_transaction_hash(ptx.tx);
+        tx_rollup.tx_fee = ptx.tx.rct_signatures.txnFee;
+        THROW_WALLET_EXCEPTION_IF(ptx.tx.vin[0].type() != typeid(cryptonote::txin_to_key), error::wallet_internal_error, "TX input is not txin_to_key");
+        tx_rollup.first_key_image = boost::get<cryptonote::txin_to_key>(ptx.tx.vin[0]).k_image;
+        rollup_data.txs.push_back(std::move(tx_rollup));
+      }
+
+      // Store the rollup data
+      tx_proposals_rollup[0].layer2_rollup_data = rollup_data;
+      
+      for (const auto &tx_proposal_rollup : tx_proposals_rollup)
+        ptx_vector.insert(ptx_vector.begin(), tools::wallet::finalize_all_proofs_from_transfer_details_as_pending_tx(tx_proposal_rollup, *this));
+    }
+
+    return ptx_vector;
   }
 
   // pre-carrot return payment construction uses subaddress true
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 523bf955f..30a2bcecb 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -1294,6 +1294,17 @@ private:
     bool parse_unsigned_tx_from_str(const std::string &unsigned_tx_st, unsigned_tx_set &exported_txs) const;
     bool load_tx(const std::string &signed_filename, std::vector<tools::wallet2::pending_tx> &ptx, std::function<bool(const signed_tx_set&)> accept_func = NULL);
     bool parse_tx_from_str(const std::string &signed_tx_st, std::vector<tools::wallet2::pending_tx> &ptx, std::function<bool(const signed_tx_set &)> accept_func);
+
+    /**
+     * Receives a hex-encoded metadata blob that contains the fields necessary to create a `sal_token_t` instance
+     */
+    std::vector<wallet2::pending_tx> create_token(const std::string& token_ticker, const uint64_t token_supply, const std::string& token_metadata_hex, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices);
+
+    /**
+     * Creates a new token using the provided `sal_token_t` struct (verifies the target first)
+     */
+    std::vector<wallet2::pending_tx> create_token(const cryptonote::token_metadata_t& token, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices);
+
     std::vector<wallet2::pending_tx> create_transactions_2(std::vector<cryptonote::tx_destination_entry> dsts, const std::string& source_asset, const std::string& dest_asset, const cryptonote::transaction_type tx_type, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t>& extra, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices, const unique_index_container& subtract_fee_from_outputs = {});     // pass subaddr_indices by value on purpose
     std::vector<wallet2::pending_tx> create_transactions_all(uint64_t below, cryptonote::transaction_type tx_type, const std::string& asset_type, const cryptonote::account_public_address &address, bool is_subaddress, const size_t outputs, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t>& extra, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices);
     std::vector<wallet2::pending_tx> create_transactions_single(const crypto::key_image &ki, const cryptonote::account_public_address &address, const cryptonote::transaction_type tx_type, bool is_subaddress, const size_t outputs, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t>& extra);
@@ -1315,7 +1326,8 @@ private:
     bool check_connection(uint32_t *version = NULL, bool *ssl = NULL, uint32_t timeout = 200000, bool *wallet_is_outdated = NULL, bool *daemon_is_outdated = NULL);
     bool check_version(uint32_t *version, bool *wallet_is_outdated, bool *daemon_is_outdated);
     bool check_hard_fork_version(cryptonote::network_type nettype, const std::vector<std::pair<uint8_t, uint64_t>> &daemon_hard_forks, const uint64_t height, const uint64_t target_height, bool *wallet_is_outdated, bool *daemon_is_outdated);
-    void get_transfers(wallet2::transfer_container& incoming_transfers) const;
+    void get_transfers(wallet2::transfer_container& incoming_transfers, const std::string& asset_type = "") const;
+    void get_transfers_indices(std::set<size_t>& indices, const std::string& asset_type = "SAL1") const;
     void get_payments(const crypto::hash& payment_id, std::list<wallet2::payment_details>& payments, uint64_t min_height = 0, const boost::optional<uint32_t>& subaddr_account = boost::none, const std::set<uint32_t>& subaddr_indices = {}) const;
     void get_payments(std::list<std::pair<crypto::hash,wallet2::payment_details>>& payments, uint64_t min_height, uint64_t max_height = (uint64_t)-1, const boost::optional<uint32_t>& subaddr_account = boost::none, const std::set<uint32_t>& subaddr_indices = {}) const;
     void get_payments_out(std::list<std::pair<crypto::hash,wallet2::confirmed_transfer_details>>& confirmed_payments,
@@ -1931,10 +1943,13 @@ private:
 
     bool get_pricing_record(oracle::pricing_record& pr, const uint64_t height);
     bool get_circulating_supply(std::vector<std::pair<std::string, std::string>> &amounts);
-    bool get_yield_info(std::vector<cryptonote::yield_block_info>& ybi_data);
 
+    bool get_tokens(const std::string& regex, std::vector<std::string>& tokens);
+    cryptonote::token_metadata_t get_token_info(const std::string& asset_type); // const;
+    
     typedef std::tuple<size_t, std::string, std::string, uint64_t, uint64_t> yield_payout_t;
     
+    bool get_yield_info(std::vector<cryptonote::yield_block_info>& ybi_data);
     bool get_yield_summary_info(uint64_t &total_burnt,
                                 uint64_t &total_supply,
                                 uint64_t &total_locked,
@@ -2083,9 +2098,11 @@ private:
     bool is_spent(const transfer_details &td, bool strict = true) const;
     bool is_spent(size_t idx, bool strict = true) const;
   public:
-    void get_outs(std::vector<std::vector<get_outs_entry>> &outs, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, bool rct, std::unordered_set<crypto::public_key> &valid_public_keys_cache);
-    void get_outs(std::vector<std::vector<get_outs_entry>> &outs, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, std::vector<uint64_t> &rct_offsets, std::unordered_set<crypto::public_key> &valid_public_keys_cache, uint64_t &num_spendable_global_outs, uint64_t &num_outs);
+    void get_outs(std::vector<std::vector<get_outs_entry>> &outs, const transfer_container &transfers, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, bool rct, std::unordered_set<crypto::public_key> &valid_public_keys_cache);
+    void get_outs(std::vector<std::vector<get_outs_entry>> &outs, const transfer_container &transfers, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, std::vector<uint64_t> &rct_offsets, std::unordered_set<crypto::public_key> &valid_public_keys_cache, uint64_t &num_spendable_global_outs, uint64_t &num_outs);
     size_t get_transfer_details(const crypto::key_image &ki) const;
+    size_t get_transfer_details_from_container(const crypto::key_image &ki, const transfer_container& container) const;
+    bool get_rct_distribution(const bool use_global_outs, const std::string &rct_asset_type, uint64_t &start_height, std::vector<uint64_t> &distribution, uint64_t &num_spendable_global_outs);
   private:
     bool tx_add_fake_output(std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, uint64_t global_index, const crypto::public_key& tx_public_key, const rct::key& mask, uint64_t real_index, bool unlocked, std::unordered_set<crypto::public_key> &valid_public_keys_cache) const;
     bool should_pick_a_second_output(bool use_rct, size_t n_transfers, const std::vector<size_t> &unused_transfers_indices, const std::vector<size_t> &unused_dust_indices) const;
@@ -2122,8 +2139,6 @@ private:
     void register_devices();
     hw::device& lookup_device(const std::string & device_descriptor);
 
-    bool get_rct_distribution(const bool use_global_outs, const std::string &rct_asset_type, uint64_t &start_height, std::vector<uint64_t> &distribution, uint64_t &num_spendable_global_outs);
-
     uint64_t get_segregation_fork_height() const;
 
     std::map<std::pair<uint64_t, uint64_t>, size_t> create_output_tracker_cache() const;
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index dff7a43c9..3b8bd7205 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -545,9 +545,22 @@ namespace tools
     bool is_carrot = m_wallet->estimate_current_hard_fork() >= HF_VERSION_CARROT;
     
     std::vector<std::string> assets_in_wallet = m_wallet->list_asset_types();
-    std::string asset_type = req.asset_type.empty() ? "SAL1" : boost::algorithm::to_upper_copy(req.asset_type);
+    std::string asset_type = req.asset_type.empty() ? "SAL1" : req.asset_type;
+    if (asset_type.length() > 4) {
+      // Assume it is a token and format accordingly
+      if (boost::algorithm::to_lower_copy(asset_type.substr(0, 3)) == "sal") {
+        asset_type = "sal" + boost::algorithm::to_upper_copy(asset_type.substr(3));
+      } else if (boost::algorithm::to_lower_copy(asset_type.substr(0, 3)) == "erc") {
+        asset_type = "erc" + boost::algorithm::to_upper_copy(asset_type.substr(3));
+      } else {
+        er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+        er.message = std::string("Invalid token asset_type '") + asset_type + "' specified"; 
+        return false;
+      }
+    }
     // verify that the asset is in the list of in-wallet assets
     if (std::find(assets_in_wallet.begin(), assets_in_wallet.end(), asset_type) == assets_in_wallet.end()) {
+      er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
       er.message = std::string("Source asset '") + asset_type + "' not found in wallet"; 
       return false;
     }
@@ -1272,6 +1285,283 @@ namespace tools
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_create_token(const wallet_rpc::COMMAND_RPC_CREATE_TOKEN::request& req, wallet_rpc::COMMAND_RPC_CREATE_TOKEN::response& res, epee::json_rpc::error& er, const connection_context *ctx)
+  {
+    if (!m_wallet) return not_open(er);
+    if (m_restricted)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Command unavailable in restricted mode.";
+      return false;
+    }
+
+    if (m_wallet->get_current_hard_fork() < HF_VERSION_ENABLE_TOKENS) {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Create_token is not available yet.";
+      return false;
+    }
+
+    if (req.coin_symbol.empty()) {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Empty asset type is not allowed.";
+      return false;
+    }
+
+    std::string asset_type = req.coin_symbol;
+    std::transform(asset_type.begin(), asset_type.end(), asset_type.begin(), ::toupper);
+    if (asset_type.length() != 4) {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Asset type must be exactly 4 characters long.";
+      return false;
+    }
+
+    // Validate characters
+    for (char c : asset_type) {
+      if (!((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))) {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Asset type can only contain uppercase letters and digits.";
+      return false;
+      }
+    }
+    
+    // Check if starts with "SAL"
+    if (asset_type.substr(0, 3) == "SAL") {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Asset type cannot start with 'SAL'.";
+      return false;
+    }
+    
+    // todo: update reserved names
+    if (asset_type == "SAL" || asset_type == "SAL1" || asset_type == "SAL2" || asset_type == "BURN") {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Asset type is reserved and cannot be used.";
+      return false;
+    }
+
+    // get tokens
+    std::vector<std::string> tokens;
+    if(!m_wallet->get_tokens(asset_type, tokens)) {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Failed to get token data.";
+      return false;
+    }
+    if (!tokens.empty()) {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Token already exists.";
+      return false;
+    }
+
+    // Verify supply amount is acceptable
+    if (req.coin_supply < 1 || req.coin_supply > MONEY_SUPPLY)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Supply amount must be between 1 and MONEY_SUPPLY.";
+      return false;
+    }
+
+    // // Verify decimals amount is acceptable
+    // if (req.coin_decimals > 8)
+    // {
+    //   er.code = WALLET_RPC_ERROR_CODE_DENIED;
+    //   er.message = "Invalid decimals amount. Maximum allowed is 8.";
+    //   return false;
+    // }
+
+    // convert req.hash to hash
+    crypto::hash hash_signature{};
+    if (!req.hash.empty()) {
+      if (!epee::string_tools::hex_to_pod(req.hash, hash_signature)) {
+        //if (metadata.empty()){
+        er.message = "Invalid hash format.";
+        return false;
+        //}
+      }
+    }
+
+    std::string token_metadata_hex;
+    if (req.token_metadata_hex.empty()) {
+      std::string json = (boost::format("{\"name\":\"%s\",\"size\":%d,\"hash\":\"%s\",\"url\":\"%s\"}") % req.name % req.size % req.hash % req.url).str();
+      token_metadata_hex = epee::string_tools::buff_to_hex_nodelimer(json);
+    } else {
+      token_metadata_hex = req.token_metadata_hex;
+    }
+
+    //cryptonote::sal_token_t sal_token{1, req.coin_supply, req.size, req.name, req.url, hash_signature};
+    //cryptonote::token_metadata_t token{1, asset_type, sal_token};
+
+    try
+    {
+      // Call the wallet create_token() method
+      auto ptx_vector = m_wallet->create_token(
+        asset_type,
+        req.coin_supply,
+        token_metadata_hex,
+        req.account_index,
+        req.subaddr_indices
+      );
+      
+      if (ptx_vector.empty())
+      {
+        er.code = WALLET_RPC_ERROR_CODE_DENIED;
+        er.message = "ptx_vector is empty after create_token.";
+        return false;
+      }
+      if (ptx_vector.size() > 1)
+      {
+        er.code = WALLET_RPC_ERROR_CODE_DENIED;
+        er.message = "ptx_vector contains more than one transaction.";
+        return false;
+      }
+
+      return fill_response(ptx_vector, req.get_tx_keys, res.tx_key_list, res.amount_list, res.amounts_by_dest_list, res.fee_list, res.weight_list, res.multisig_txset, res.unsigned_txset, req.do_not_relay,
+        res.tx_hash_list, req.get_tx_hex, res.tx_blob_list, req.get_tx_metadata, res.tx_metadata_list, res.spent_key_images_list, er);
+    }
+    catch (const std::exception& e)
+    {
+      handle_rpc_exception(std::current_exception(), er, WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR);
+      return false;
+    }
+
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_get_tokens(const wallet_rpc::COMMAND_RPC_GET_TOKENS::request& req, wallet_rpc::COMMAND_RPC_GET_TOKENS::response& res, epee::json_rpc::error& er, const connection_context *ctx)
+  {
+    LOG_PRINT_L3("on_get_tokens starts");
+    if (!m_wallet) return not_open(er);
+
+    // Get the full list of tokens from the wallet - filtered if necessary
+    if (!m_wallet->get_tokens(req.regex, res.tokens)) {
+      er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+      er.message = "Failed to get token data from wallet.";
+      return false;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_return_payment(const wallet_rpc::COMMAND_RPC_RETURN_PAYMENT::request& req, wallet_rpc::COMMAND_RPC_RETURN_PAYMENT::response& res, epee::json_rpc::error& er, const connection_context *ctx)
+  {
+    LOG_PRINT_L3("on_return_payment starts");
+    if (!m_wallet) return not_open(er);
+    if (m_restricted)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Command unavailable in restricted mode.";
+      return false;
+    }
+
+    // Get the TX hash we are interested in 
+    crypto::hash txid;
+    if (!epee::string_tools::hex_to_pod(req.txid, txid))
+    {
+      er.code = WALLET_RPC_ERROR_CODE_WRONG_TXID;
+      er.message = "TX ID has invalid format";
+      return false;
+    }
+
+    // Get the transfers from the wallet
+    tools::wallet2::transfer_container transfers;
+    m_wallet->get_transfers(transfers);
+    std::vector<size_t> transfers_indices = {};
+    for (size_t idx=0; idx < transfers.size(); ++idx) {
+      
+      // Get the TD by reference
+      tools::wallet2::transfer_details& td = transfers[idx];
+
+      // Skip entries we don't care about
+      if (td.m_txid != txid) continue;
+
+      // Found the specified entry - make sure we can return it
+      if (td.m_tx.type != cryptonote::transaction_type::TRANSFER) {
+        er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+        er.message = tr("incorrect TX type for txid");
+        return false;
+      }
+
+      if (td.m_tx.version >= TRANSACTION_VERSION_N_OUTS) {
+        if (td.m_tx.return_address_list.empty() || td.m_tx.return_address_change_mask.empty()) {
+          er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+          er.message = tr("invalid return_address_list for txid");
+          return false;
+        }
+      } else {
+        // Verify we have a valid return_address and tx_pubkey
+        if (td.m_tx.return_address == crypto::null_pkey || td.m_tx.return_pubkey != crypto::null_pkey) {
+          er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+          er.message = tr("invalid return_address/return_pubkey for txid");
+          return false;
+        }
+      }
+
+      // Check that we have the key image information, and that it is usable
+      if (!td.m_key_image_known || td.m_key_image_partial || td.m_spent || td.m_frozen) {
+        er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+        er.message = tr("key image is unavailable (partial / unknown / spent / frozen) for txid");
+        return false;
+      }
+
+      // Verify that the correct asset type is being returned
+      if (m_wallet->get_current_hard_fork() >= HF_VERSION_ENABLE_TOKENS) {
+        if (td.asset_type == "SAL") {
+          er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+          er.message = tr("SAL may not be returned for txid");
+          return false;
+        }
+      } else if (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) {
+        if (td.asset_type != "SAL1") {
+          er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+          er.message = tr("Only SAL1 may be returned for txid");
+          return false;
+        }
+      }
+    
+      // We found the one(s) we were looking for - take a copy of the key_image, etc.
+      transfers_indices.push_back(idx);
+    }
+
+    // Check we have a valid key_image
+    if (transfers_indices.empty()) {
+      er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+      er.message = tr("No matching transfers found in wallet");
+      return false;
+    }
+    
+    try
+    {
+      // Call the wallet create_transactions_return() method
+      auto ptx_vector = m_wallet->create_transactions_return(transfers_indices);
+      if (ptx_vector.empty())
+      {
+        er.code = WALLET_RPC_ERROR_CODE_TX_NOT_POSSIBLE;
+        er.message = "No transaction created";
+        return false;
+      }
+      if (ptx_vector.size() > 2)
+      {
+        er.code = WALLET_RPC_ERROR_CODE_TX_TOO_LARGE;
+        er.message = "Multiple transactions are created, which is not supposed to happen.";
+        return false;
+      }
+      if (ptx_vector[0].selected_transfers.size() != transfers_indices.size())
+      {
+        er.code = WALLET_RPC_ERROR_CODE_TX_NOT_POSSIBLE;
+        er.message = tr("The transaction uses incorrect number of inputs, which is not supposed to happen");
+        return false;
+      }
+
+      //return fill_response(ptx_vector, req.get_tx_key, res.tx_key, res.amount, res.amounts_by_dest, res.fee, res.weight, res.multisig_txset, res.unsigned_txset, req.do_not_relay,
+      //    res.tx_hash, req.get_tx_hex, res.tx_blob, req.get_tx_metadata, res.tx_metadata, res.spent_key_images, er);
+      return fill_response(ptx_vector, req.get_tx_key, res.tx_key_list, res.amount_list, res.amounts_by_dest_list, res.fee_list, res.weight_list, res.multisig_txset, res.unsigned_txset, req.do_not_relay,
+          res.tx_hash_list, req.get_tx_hex, res.tx_blob_list, req.get_tx_metadata, res.tx_metadata_list, res.spent_key_images_list, er);
+    }
+    catch (const std::exception& e)
+    {
+      handle_rpc_exception(std::current_exception(), er, WALLET_RPC_ERROR_CODE_GENERIC_TRANSFER_ERROR);
+      return false;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
   bool wallet_rpc_server::on_transfer(const wallet_rpc::COMMAND_RPC_TRANSFER::request& req, wallet_rpc::COMMAND_RPC_TRANSFER::response& res, epee::json_rpc::error& er, const connection_context *ctx)
   {
 
@@ -4980,6 +5270,32 @@ namespace tools
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_get_token_info(const wallet_rpc::COMMAND_RPC_GET_TOKEN_INFO::request& req, wallet_rpc::COMMAND_RPC_GET_TOKEN_INFO::response& res, epee::json_rpc::error& er, const connection_context *ctx)
+  {
+    // check
+    if (!m_wallet) return not_open(er);
+
+    try {
+      cryptonote::token_metadata_t token = m_wallet->get_token_info(req.asset_type);
+      res.status = CORE_RPC_STATUS_OK;
+      res.version = token.version;
+      res.asset_type = token.asset_type;
+      if (token.token.type() == typeid(cryptonote::sal_token_t)) {
+        res.token_type = TOKEN_TYPE_SAL;
+        res.sal_token = boost::get<cryptonote::sal_token_t>(token.token);
+      } else if (token.token.type() == typeid(cryptonote::erc_token_t)) {
+        res.token_type = TOKEN_TYPE_ERC20;
+        res.erc_token = boost::get<cryptonote::erc_token_t>(token.token);
+      }
+    } catch (const std::exception& e) {
+      er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+      er.message = "Failed to query daemon for token info";
+      return false;
+    }
+
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
 }
 
 class t_daemon
diff --git a/src/wallet/wallet_rpc_server.h b/src/wallet/wallet_rpc_server.h
index b35f6853a..05721a6d8 100644
--- a/src/wallet/wallet_rpc_server.h
+++ b/src/wallet/wallet_rpc_server.h
@@ -88,6 +88,9 @@ namespace tools
         MAP_JON_RPC_WE("thaw",               on_thaw,               wallet_rpc::COMMAND_RPC_THAW)
         MAP_JON_RPC_WE("frozen",             on_frozen,             wallet_rpc::COMMAND_RPC_FROZEN)
         MAP_JON_RPC_WE("audit",              on_audit,              wallet_rpc::COMMAND_RPC_AUDIT)
+        MAP_JON_RPC_WE("create_token",       on_create_token,       wallet_rpc::COMMAND_RPC_CREATE_TOKEN)
+        MAP_JON_RPC_WE("get_tokens",         on_get_tokens,         wallet_rpc::COMMAND_RPC_GET_TOKENS)
+        MAP_JON_RPC_WE("return_payment",     on_return_payment,     wallet_rpc::COMMAND_RPC_RETURN_PAYMENT)
         MAP_JON_RPC_WE("transfer",           on_transfer,           wallet_rpc::COMMAND_RPC_TRANSFER)
         MAP_JON_RPC_WE("transfer_split",     on_transfer_split,     wallet_rpc::COMMAND_RPC_TRANSFER_SPLIT)
         MAP_JON_RPC_WE("sign_transfer",      on_sign_transfer,      wallet_rpc::COMMAND_RPC_SIGN_TRANSFER)
@@ -163,6 +166,7 @@ namespace tools
         MAP_JON_RPC_WE("estimate_tx_size_and_weight", on_estimate_tx_size_and_weight, wallet_rpc::COMMAND_RPC_ESTIMATE_TX_SIZE_AND_WEIGHT)
         MAP_JON_RPC_WE("get_default_fee_priority", on_get_default_fee_priority, wallet_rpc::COMMAND_RPC_GET_DEFAULT_FEE_PRIORITY)
         MAP_JON_RPC_WE("get_version",        on_get_version,        wallet_rpc::COMMAND_RPC_GET_VERSION)
+        MAP_JON_RPC_WE("get_token_info",     on_get_token_info,     wallet_rpc::COMMAND_RPC_GET_TOKEN_INFO)
         MAP_JON_RPC_WE("setup_background_sync", on_setup_background_sync, wallet_rpc::COMMAND_RPC_SETUP_BACKGROUND_SYNC)
         MAP_JON_RPC_WE("start_background_sync", on_start_background_sync, wallet_rpc::COMMAND_RPC_START_BACKGROUND_SYNC)
         MAP_JON_RPC_WE("stop_background_sync", on_stop_background_sync, wallet_rpc::COMMAND_RPC_STOP_BACKGROUND_SYNC)
@@ -187,6 +191,9 @@ namespace tools
       bool on_thaw(const wallet_rpc::COMMAND_RPC_THAW::request& req, wallet_rpc::COMMAND_RPC_THAW::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_frozen(const wallet_rpc::COMMAND_RPC_FROZEN::request& req, wallet_rpc::COMMAND_RPC_FROZEN::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_audit(const wallet_rpc::COMMAND_RPC_AUDIT::request& req, wallet_rpc::COMMAND_RPC_AUDIT::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
+      bool on_create_token(const wallet_rpc::COMMAND_RPC_CREATE_TOKEN::request& req, wallet_rpc::COMMAND_RPC_CREATE_TOKEN::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
+      bool on_get_tokens(const wallet_rpc::COMMAND_RPC_GET_TOKENS::request& req, wallet_rpc::COMMAND_RPC_GET_TOKENS::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
+      bool on_return_payment(const wallet_rpc::COMMAND_RPC_RETURN_PAYMENT::request& req, wallet_rpc::COMMAND_RPC_RETURN_PAYMENT::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_transfer(const wallet_rpc::COMMAND_RPC_TRANSFER::request& req, wallet_rpc::COMMAND_RPC_TRANSFER::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_transfer_split(const wallet_rpc::COMMAND_RPC_TRANSFER_SPLIT::request& req, wallet_rpc::COMMAND_RPC_TRANSFER_SPLIT::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_sign_transfer(const wallet_rpc::COMMAND_RPC_SIGN_TRANSFER::request& req, wallet_rpc::COMMAND_RPC_SIGN_TRANSFER::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
@@ -260,6 +267,7 @@ namespace tools
       bool on_estimate_tx_size_and_weight(const wallet_rpc::COMMAND_RPC_ESTIMATE_TX_SIZE_AND_WEIGHT::request& req, wallet_rpc::COMMAND_RPC_ESTIMATE_TX_SIZE_AND_WEIGHT::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_get_default_fee_priority(const wallet_rpc::COMMAND_RPC_GET_DEFAULT_FEE_PRIORITY::request& req, wallet_rpc::COMMAND_RPC_GET_DEFAULT_FEE_PRIORITY::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_get_version(const wallet_rpc::COMMAND_RPC_GET_VERSION::request& req, wallet_rpc::COMMAND_RPC_GET_VERSION::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
+      bool on_get_token_info(const wallet_rpc::COMMAND_RPC_GET_TOKEN_INFO::request& req, wallet_rpc::COMMAND_RPC_GET_TOKEN_INFO::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_setup_background_sync(const wallet_rpc::COMMAND_RPC_SETUP_BACKGROUND_SYNC::request& req, wallet_rpc::COMMAND_RPC_SETUP_BACKGROUND_SYNC::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_start_background_sync(const wallet_rpc::COMMAND_RPC_START_BACKGROUND_SYNC::request& req, wallet_rpc::COMMAND_RPC_START_BACKGROUND_SYNC::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
       bool on_stop_background_sync(const wallet_rpc::COMMAND_RPC_STOP_BACKGROUND_SYNC::request& req, wallet_rpc::COMMAND_RPC_STOP_BACKGROUND_SYNC::response& res, epee::json_rpc::error& er, const connection_context *ctx = NULL);
diff --git a/src/wallet/wallet_rpc_server_commands_defs.h b/src/wallet/wallet_rpc_server_commands_defs.h
index 2d24ee3b7..3b12690c6 100644
--- a/src/wallet/wallet_rpc_server_commands_defs.h
+++ b/src/wallet/wallet_rpc_server_commands_defs.h
@@ -593,6 +593,82 @@ namespace wallet_rpc
     END_KV_SERIALIZE_MAP()
   };
 
+  struct split_transfer_response
+    {
+      std::list<std::string> tx_hash_list;
+      std::list<std::string> tx_key_list;
+      std::list<uint64_t> amount_list;
+      std::list<amounts_list> amounts_by_dest_list;
+      std::list<uint64_t> fee_list;
+      std::list<uint64_t> weight_list;
+      std::list<std::string> tx_blob_list;
+      std::list<std::string> tx_metadata_list;
+      std::string multisig_txset;
+      std::string unsigned_txset;
+      std::list<key_image_list> spent_key_images_list;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(tx_hash_list)
+        KV_SERIALIZE(tx_key_list)
+        KV_SERIALIZE(amount_list)
+        KV_SERIALIZE_OPT(amounts_by_dest_list, decltype(amounts_by_dest_list)())
+        KV_SERIALIZE(fee_list)
+        KV_SERIALIZE(weight_list)
+        KV_SERIALIZE(tx_blob_list)
+        KV_SERIALIZE(tx_metadata_list)
+        KV_SERIALIZE(multisig_txset)
+        KV_SERIALIZE(unsigned_txset)
+        KV_SERIALIZE(spent_key_images_list)
+      END_KV_SERIALIZE_MAP()
+    };
+
+
+  struct COMMAND_RPC_RETURN_PAYMENT
+  {
+    struct request_t
+    {
+      std::string txid;
+      /* std::list<transfer_destination> destinations;
+      std::string source_asset;
+      std::string dest_asset;
+      uint8_t tx_type;
+      uint32_t account_index;
+      std::set<uint32_t> subaddr_indices;
+      std::set<uint32_t> subtract_fee_from_outputs;
+      uint32_t priority;
+      uint64_t ring_size;
+      uint64_t unlock_time;
+      std::string payment_id; */
+      bool get_tx_key;
+      bool do_not_relay;
+      bool get_tx_hex;
+      bool get_tx_metadata;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(txid)
+        // KV_SERIALIZE(destinations)
+        // KV_SERIALIZE(source_asset)
+        // KV_SERIALIZE(dest_asset)
+        // KV_SERIALIZE(tx_type)
+        // KV_SERIALIZE(account_index)
+        // KV_SERIALIZE(subaddr_indices)
+        // KV_SERIALIZE_OPT(subtract_fee_from_outputs, decltype(subtract_fee_from_outputs)())
+        // KV_SERIALIZE(priority)
+        // KV_SERIALIZE_OPT(ring_size, (uint64_t)0)
+        // KV_SERIALIZE(unlock_time)
+        // KV_SERIALIZE(payment_id)
+        KV_SERIALIZE(get_tx_key)
+        KV_SERIALIZE_OPT(do_not_relay, false)
+        KV_SERIALIZE_OPT(get_tx_hex, false)
+        KV_SERIALIZE_OPT(get_tx_metadata, false)
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<request_t> request;
+
+    typedef split_transfer_response response_t;
+    typedef epee::misc_utils::struct_init<response_t> response;
+  };
+
   struct COMMAND_RPC_TRANSFER
   {
     struct request_t
@@ -637,34 +713,6 @@ namespace wallet_rpc
     typedef epee::misc_utils::struct_init<response_t> response;
   };
 
-  struct split_transfer_response
-  {
-    std::list<std::string> tx_hash_list;
-    std::list<std::string> tx_key_list;
-    std::list<uint64_t> amount_list;
-    std::list<amounts_list> amounts_by_dest_list;
-    std::list<uint64_t> fee_list;
-    std::list<uint64_t> weight_list;
-    std::list<std::string> tx_blob_list;
-    std::list<std::string> tx_metadata_list;
-    std::string multisig_txset;
-    std::string unsigned_txset;
-    std::list<key_image_list> spent_key_images_list;
-
-    BEGIN_KV_SERIALIZE_MAP()
-      KV_SERIALIZE(tx_hash_list)
-      KV_SERIALIZE(tx_key_list)
-      KV_SERIALIZE(amount_list)
-      KV_SERIALIZE_OPT(amounts_by_dest_list, decltype(amounts_by_dest_list)())
-      KV_SERIALIZE(fee_list)
-      KV_SERIALIZE(weight_list)
-      KV_SERIALIZE(tx_blob_list)
-      KV_SERIALIZE(tx_metadata_list)
-      KV_SERIALIZE(multisig_txset)
-      KV_SERIALIZE(unsigned_txset)
-      KV_SERIALIZE(spent_key_images_list)
-    END_KV_SERIALIZE_MAP()
-  };
 
   struct COMMAND_RPC_TRANSFER_SPLIT
   {
@@ -2890,5 +2938,105 @@ namespace wallet_rpc
     };
     typedef epee::misc_utils::struct_init<response_t> response;
   };
+
+  struct COMMAND_RPC_CREATE_TOKEN
+  {
+    struct request_t
+    {
+      std::string coin_symbol;
+      uint64_t coin_supply;
+      uint32_t account_index;
+      std::set<uint32_t> subaddr_indices;
+      std::string name;
+      std::string url;
+      std::string hash;
+      uint64_t size;
+      std::string token_metadata_hex;
+
+      bool get_tx_keys;
+      bool do_not_relay;
+      bool get_tx_hex;
+      bool get_tx_metadata;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(coin_symbol)
+        KV_SERIALIZE(coin_supply)
+        KV_SERIALIZE(account_index)
+        KV_SERIALIZE(subaddr_indices)
+        KV_SERIALIZE(name)
+        KV_SERIALIZE(url)
+        KV_SERIALIZE(hash)
+        KV_SERIALIZE(size)
+        KV_SERIALIZE(token_metadata_hex)
+        KV_SERIALIZE_OPT(get_tx_keys, false)
+        KV_SERIALIZE_OPT(do_not_relay, false)
+        KV_SERIALIZE_OPT(get_tx_hex, false)
+        KV_SERIALIZE_OPT(get_tx_metadata, false)
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<request_t> request;
+
+    typedef split_transfer_response response_t;
+    typedef epee::misc_utils::struct_init<response_t> response;
+  };
+
+  struct COMMAND_RPC_GET_TOKENS
+  {
+    struct request_t
+    {
+      std::string regex;
+    
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE_OPT(regex, (std::string)"")
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<request_t> request;
+
+    struct response_t
+    {
+      std::vector<std::string> tokens;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(tokens)
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<response_t> response;
+  };
+
+  struct COMMAND_RPC_GET_TOKEN_INFO
+  {
+    struct request_t
+    {
+      std::string asset_type;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(asset_type)
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<request_t> request;
+
+    struct response_t
+    {
+      std::string status;
+      uint8_t token_type;  // erc20 or sal
+      uint8_t version;
+      std::string asset_type;
+      cryptonote::sal_token_t sal_token;
+      cryptonote::erc_token_t erc_token;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+        KV_SERIALIZE(token_type)
+        KV_SERIALIZE(version)
+        KV_SERIALIZE(asset_type)
+        if (token_type == TOKEN_TYPE_ERC20) {
+          KV_SERIALIZE(erc_token)
+        } else {
+          KV_SERIALIZE(sal_token)
+        }
+      END_KV_SERIALIZE_MAP()
+    };
+    typedef epee::misc_utils::struct_init<response_t> response;
+  };
 }
 }