diff --git a/src/logservice/palf/scn.h b/src/logservice/palf/scn.h
index 2e964e3eee..32482d261d 100644
--- a/src/logservice/palf/scn.h
+++ b/src/logservice/palf/scn.h
@@ -40,6 +40,7 @@ public:
   static SCN max_scn();
   static SCN min_scn();
   static SCN base_scn();
+  bool is_base_scn() const { return *this == base_scn(); }
   static SCN max(const SCN &left, const SCN &right);
   static SCN min(const SCN &left, const SCN &right);
   static SCN plus(const SCN &ref, uint64_t delta);
diff --git a/src/storage/backup/ob_backup_utils.cpp b/src/storage/backup/ob_backup_utils.cpp
index 61ef9906a4..566bfc6d4d 100644
--- a/src/storage/backup/ob_backup_utils.cpp
+++ b/src/storage/backup/ob_backup_utils.cpp
@@ -225,8 +225,8 @@ int ObBackupUtils::check_tablet_minor_sstable_validity_(const storage::ObTabletH
   ObTablet *tablet = NULL;
   ObITable *last_table_ptr = NULL;
   ObTabletID tablet_id;
-  SCN start_scn = SCN::min_scn();
-  SCN clog_checkpoint_scn = SCN::min_scn();
+  palf::SCN start_scn = SCN::min_scn();
+  palf::SCN clog_checkpoint_scn = SCN::min_scn();
   if (OB_ISNULL(tablet = tablet_handle.get_obj())) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("invalid tablet handle", K(ret), K(tablet_handle));
@@ -255,7 +255,7 @@ int ObBackupUtils::check_tablet_minor_sstable_validity_(const storage::ObTabletH
     LOG_WARN("table ptr not correct", K(ret), KPC(last_table_ptr));
   } else {
     const ObITable::TableKey &table_key = last_table_ptr->get_key();
-    if (table_key.get_end_log_ts() != clog_checkpoint_scn.get_val_for_inner_table_field()) {
+    if (table_key.get_end_scn() != clog_checkpoint_scn) {
       ret = OB_ERR_UNEXPECTED;
       LOG_ERROR("tablet meta is not valid", K(ret), K(table_key), K(clog_checkpoint_scn));
     }
diff --git a/src/storage/blocksstable/ob_sstable.h b/src/storage/blocksstable/ob_sstable.h
index 3d8e3cd26e..0a9b23df1f 100644
--- a/src/storage/blocksstable/ob_sstable.h
+++ b/src/storage/blocksstable/ob_sstable.h
@@ -121,12 +121,9 @@ public:
   {
     return meta_.basic_meta_.recycle_version_;
   }
-
   palf::SCN get_filled_tx_scn() const
   {
-    palf::SCN tmp_scn;
-    tmp_scn.convert_for_lsn_allocator(meta_.basic_meta_.filled_tx_log_ts_);
-    return tmp_scn;
+    return meta_.basic_meta_.filled_tx_scn_;
   }
 
   virtual int get_frozen_schema_version(int64_t &schema_version) const override;
diff --git a/src/storage/blocksstable/ob_sstable_meta.cpp b/src/storage/blocksstable/ob_sstable_meta.cpp
index 0a6f30ac83..4e926a3f06 100644
--- a/src/storage/blocksstable/ob_sstable_meta.cpp
+++ b/src/storage/blocksstable/ob_sstable_meta.cpp
@@ -51,7 +51,7 @@ ObSSTableBasicMeta::ObSSTableBasicMeta()
     max_merged_trans_version_(0),
     recycle_version_(0),
     ddl_log_ts_(0),
-    filled_tx_log_ts_(0),
+    filled_tx_scn_(palf::SCN::min_scn()),
     data_index_tree_height_(0),
     table_mode_(),
     status_(0),
@@ -91,7 +91,7 @@ bool ObSSTableBasicMeta::operator==(const ObSSTableBasicMeta &other) const
       && upper_trans_version_ == other.upper_trans_version_
       && max_merged_trans_version_ == other.max_merged_trans_version_
       && ddl_log_ts_ == other.ddl_log_ts_
-      && filled_tx_log_ts_ == other.filled_tx_log_ts_
+      && filled_tx_scn_ == other.filled_tx_scn_
       && data_index_tree_height_ == other.data_index_tree_height_
       && table_mode_ == other.table_mode_
       && status_ == other.status_
@@ -124,7 +124,7 @@ bool ObSSTableBasicMeta::is_valid() const
            && max_merged_trans_version_ >= 0
            && recycle_version_ >= 0
            && ddl_log_ts_ >= 0
-           && filled_tx_log_ts_ >= 0
+           // && filled_tx_scn_.is_valid() // TODO(scn), TODO(yangyi.yyy) wait TODO(danling) modify merge_scn
            && data_index_tree_height_ >= 0
            && row_store_type_ < ObRowStoreType::MAX_ROW_STORE);
   return ret;
@@ -154,7 +154,7 @@ void ObSSTableBasicMeta::reset()
   max_merged_trans_version_ = 0;
   recycle_version_ = 0;
   ddl_log_ts_ = 0;
-  filled_tx_log_ts_ = 0;
+  filled_tx_scn_.set_min();
   data_index_tree_height_ = 0;
   table_mode_.reset();
   status_ = SSTABLE_NOT_INIT;
@@ -209,7 +209,7 @@ DEFINE_SERIALIZE(ObSSTableBasicMeta)
                   max_merged_trans_version_,
                   recycle_version_,
                   ddl_log_ts_,
-                  filled_tx_log_ts_,
+                  filled_tx_scn_,
                   data_index_tree_height_,
                   table_mode_,
                   status_,
@@ -270,7 +270,7 @@ DEFINE_DESERIALIZE(ObSSTableBasicMeta)
                   max_merged_trans_version_,
                   recycle_version_,
                   ddl_log_ts_,
-                  filled_tx_log_ts_,
+                  filled_tx_scn_,
                   data_index_tree_height_,
                   table_mode_,
                   status_,
@@ -316,7 +316,7 @@ DEFINE_GET_SERIALIZE_SIZE(ObSSTableBasicMeta)
               max_merged_trans_version_,
               recycle_version_,
               ddl_log_ts_,
-              filled_tx_log_ts_,
+              filled_tx_scn_,
               data_index_tree_height_,
               table_mode_,
               status_,
@@ -458,7 +458,7 @@ int ObSSTableMeta::init_base_meta(
     basic_meta_.upper_trans_version_ = contain_uncommitted_row() ?
         INT64_MAX : basic_meta_.max_merged_trans_version_;
     basic_meta_.ddl_log_ts_ = param.ddl_log_ts_;
-    basic_meta_.filled_tx_log_ts_ = param.filled_tx_log_ts_;
+    basic_meta_.filled_tx_scn_ = param.filled_tx_scn_;
     basic_meta_.data_index_tree_height_ = param.data_index_tree_height_;
     basic_meta_.row_store_type_ = param.root_row_store_type_;
     basic_meta_.compressor_type_ = param.compressor_type_;
diff --git a/src/storage/blocksstable/ob_sstable_meta.h b/src/storage/blocksstable/ob_sstable_meta.h
index 7854969d41..f8b0c1d2d3 100644
--- a/src/storage/blocksstable/ob_sstable_meta.h
+++ b/src/storage/blocksstable/ob_sstable_meta.h
@@ -58,7 +58,7 @@ public:
   OB_INLINE int64_t get_max_merged_trans_version() const { return max_merged_trans_version_; }
   OB_INLINE int64_t get_ddl_log_ts() const { return ddl_log_ts_; }
   OB_INLINE int64_t get_create_snapshot_version() const { return create_snapshot_version_; }
-  OB_INLINE int64_t get_filled_tx_log_ts() const { return filled_tx_log_ts_; }
+  OB_INLINE palf::SCN get_filled_tx_scn() const { return filled_tx_scn_; }
   OB_INLINE int16_t get_data_index_tree_height() const { return data_index_tree_height_; }
 
   int set_upper_trans_version(const int64_t upper_trans_version);
@@ -74,7 +74,7 @@ public:
       K(create_snapshot_version_), K(progressive_merge_round_),
       K(progressive_merge_step_), K(data_index_tree_height_), K(table_mode_),
       K(upper_trans_version_), K(max_merged_trans_version_), K_(recycle_version),
-      K(ddl_log_ts_), K(filled_tx_log_ts_),
+      K(ddl_log_ts_), K(filled_tx_scn_),
       K(contain_uncommitted_row_), K(status_), K_(row_store_type), K_(compressor_type),
       K_(encrypt_id), K_(master_key_id), KPHEX_(encrypt_key, sizeof(encrypt_key_)));
 
@@ -103,7 +103,7 @@ public:
   // recycle_version only avaliable for minor sstable, recored recycled multi version start
   int64_t recycle_version_;
   int64_t ddl_log_ts_; // only used in DDL SSTable, all MB in DDL SSTable should have the same log_ts(start_log_ts)
-  int64_t filled_tx_log_ts_; // only for rebuild
+  palf::SCN filled_tx_scn_; // only for rebuild
   int16_t data_index_tree_height_;
   share::schema::ObTableMode table_mode_;
   uint8_t status_;
diff --git a/src/storage/compaction/ob_i_compaction_filter.h b/src/storage/compaction/ob_i_compaction_filter.h
index 8b1ed144be..96845bcbfc 100644
--- a/src/storage/compaction/ob_i_compaction_filter.h
+++ b/src/storage/compaction/ob_i_compaction_filter.h
@@ -15,6 +15,7 @@
 
 #include "lib/utility/ob_print_utils.h"
 #include "share/schema/ob_table_param.h"
+#include "logservice/palf/scn.h"
 namespace oceanbase
 {
 namespace blocksstable
@@ -102,8 +103,11 @@ public:
       K_(filter_col_idx), K_(max_filtered_end_scn));
 
 public:
-  int64_t get_max_filtered_end_scn() { return max_filtered_end_scn_; }
-  int64_t get_recycle_scn() { return filter_val_; }
+  // TODO(scn): change scn of int64_t type to palf::SCN
+  int64_t get_max_filtered_end_scn_v0() { return max_filtered_end_scn_; }
+  palf::SCN get_max_filtered_end_scn() { palf::SCN tmp_scn; tmp_scn.convert_for_lsn_allocator(max_filtered_end_scn_); return tmp_scn; }
+  int64_t get_recycle_scn_v0() { return filter_val_; }
+  palf::SCN get_recycle_scn() { palf::SCN tmp_scn; tmp_scn.convert_for_lsn_allocator(filter_val_); return tmp_scn; }
 
 private:
   bool is_inited_;
diff --git a/src/storage/compaction/ob_tablet_merge_ctx.cpp b/src/storage/compaction/ob_tablet_merge_ctx.cpp
index 17d22e843b..327b0e641e 100644
--- a/src/storage/compaction/ob_tablet_merge_ctx.cpp
+++ b/src/storage/compaction/ob_tablet_merge_ctx.cpp
@@ -193,7 +193,14 @@ int ObTabletMergeInfo::build_create_sstable_param(const ObTabletMergeCtx &ctx,
       table_key.scn_range_ = ctx.scn_range_;
     }
     param.table_key_ = table_key;
-    param.filled_tx_log_ts_ = ctx.merge_scn_;
+    // TODO(scn):
+    if (INT64_MAX == ctx.merge_scn_) {
+      param.filled_tx_scn_.set_max();
+    } else {
+      if (OB_FAIL(param.filled_tx_scn_.convert_for_lsn_allocator(ctx.merge_scn_))) {
+        LOG_WARN("failed to convert for gts", K(ret), K(ctx));
+      }
+    }
 
     param.table_mode_ = ctx.schema_ctx_.merge_schema_->get_table_mode_struct();
     param.index_type_ = ctx.schema_ctx_.merge_schema_->get_index_type();
@@ -234,7 +241,7 @@ int ObTabletMergeInfo::build_create_sstable_param(const ObTabletMergeCtx &ctx,
     param.other_block_ids_ = res.other_block_ids_;
     MEMCPY(param.encrypt_key_, res.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
     if (ctx.param_.is_major_merge()) {
-      if (OB_FAIL(res.fill_column_checksum(ctx.schema_ctx_.table_schema_, param.column_checksums_))) {
+      if (FAILEDx(res.fill_column_checksum(ctx.schema_ctx_.table_schema_, param.column_checksums_))) {
         LOG_WARN("fail to fill column checksum", K(ret), K(res));
       }
     }
@@ -250,7 +257,7 @@ int ObTabletMergeInfo::record_start_tx_scn_for_tx_data(const ObTabletMergeCtx &c
 {
   int ret = OB_SUCCESS;
   // set INT64_MAX for invalid check
-  param.filled_tx_log_ts_ = INT64_MAX;
+  param.filled_tx_scn_.set_max();
 
   if (ctx.param_.is_mini_merge()) {
     // when this merge is MINI_MERGE, use the start_scn of the oldest tx data memtable as start_tx_scn
@@ -262,18 +269,18 @@ int ObTabletMergeInfo::record_start_tx_scn_for_tx_data(const ObTabletMergeCtx &c
       ret = OB_ERR_UNEXPECTED;
       LOG_ERROR("table ptr is unexpected nullptr", KR(ret), K(ctx));
     } else {
-      param.filled_tx_log_ts_ = tx_data_memtable->get_start_log_ts();
+      param.filled_tx_scn_ = tx_data_memtable->get_start_scn();
     }
   } else if (ctx.param_.is_minor_merge()) {
     // when this merege is MINOR_MERGE or MINI_MINOR_MERGE, use max_filtered_end_scn in filter if filtered some tx data
     ObTransStatusFilter *compaction_filter_ = (ObTransStatusFilter*)ctx.compaction_filter_;
     if (OB_ISNULL(compaction_filter_)) {
       // This minor merge do not filter any tx data
-      param.filled_tx_log_ts_ = ctx.scn_range_.start_scn_.get_val_for_inner_table_field();
-    } else if (compaction_filter_->get_max_filtered_end_scn() > 0) {
-      param.filled_tx_log_ts_ = compaction_filter_->get_max_filtered_end_scn();
+      param.filled_tx_scn_ = ctx.scn_range_.start_scn_;
+    } else if (compaction_filter_->get_max_filtered_end_scn() > palf::SCN::min_scn()) {
+      param.filled_tx_scn_ = compaction_filter_->get_max_filtered_end_scn();
     } else {
-      param.filled_tx_log_ts_ = compaction_filter_->get_recycle_scn();
+      param.filled_tx_scn_ = compaction_filter_->get_recycle_scn();
     }
   } else {
     ret = OB_ERR_UNEXPECTED;
diff --git a/src/storage/compaction/ob_tablet_merge_ctx.h b/src/storage/compaction/ob_tablet_merge_ctx.h
index 69cda9de5d..12d0fdf1aa 100644
--- a/src/storage/compaction/ob_tablet_merge_ctx.h
+++ b/src/storage/compaction/ob_tablet_merge_ctx.h
@@ -204,7 +204,7 @@ struct ObTabletMergeCtx
   // 2. filled in ObPartitionStore::get_merge_tables
   ObVersionRange sstable_version_range_;// version range for new sstable
   share::ObScnRange scn_range_;
-  int64_t merge_scn_;
+  int64_t merge_scn_; // TODO(scn), TODO(danling): change type from int64_t to palf::SCN
   int64_t create_snapshot_version_;
 
   storage::ObTablesHandleArray tables_handle_;
diff --git a/src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp b/src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp
index a098952b9e..072e026056 100644
--- a/src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp
+++ b/src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp
@@ -335,8 +335,9 @@ int ObTabletDDLKvMgr::update_tablet(const int64_t start_log_ts, const int64_t sn
     param.keep_old_ddl_sstable_ = false;
     param.ddl_start_log_ts_ = start_log_ts;
     param.ddl_snapshot_version_ = snapshot_version;
-    param.ddl_checkpoint_ts_ = ddl_checkpoint_ts;
-    if (OB_FAIL(ls_handle.get_ls()->update_tablet_table_store(tablet_id_, param, new_tablet_handle))) {
+    if (OB_FAIL(param.ddl_checkpoint_scn_.convert_for_lsn_allocator(ddl_checkpoint_ts))) {
+      LOG_WARN("failed to convert for scn", K(ret));
+    } else if (OB_FAIL(ls_handle.get_ls()->update_tablet_table_store(tablet_id_, param, new_tablet_handle))) {
       LOG_WARN("failed to update tablet table store", K(ret), K(ls_id_), K(tablet_id_), K(param));
     } else {
       LOG_INFO("update tablet success", K(ls_id_), K(tablet_id_), K(param), K(start_log_ts), K(snapshot_version), K(ddl_checkpoint_ts));
diff --git a/src/storage/ddl/ob_tablet_ddl_kv_mgr.h b/src/storage/ddl/ob_tablet_ddl_kv_mgr.h
index 29721a9922..0d769a4ec3 100644
--- a/src/storage/ddl/ob_tablet_ddl_kv_mgr.h
+++ b/src/storage/ddl/ob_tablet_ddl_kv_mgr.h
@@ -49,6 +49,7 @@ public:
   int check_has_effective_ddl_kv(bool &has_ddl_kv); // used in ddl log handler for checkpoint
   int get_ddl_kv_min_log_ts(int64_t &min_log_ts); // for calculate rec_log_ts of ls
   int64_t get_start_log_ts() const { return start_log_ts_; }
+
   bool is_started() const { return 0 != start_log_ts_; }
   int set_commit_success();
   bool is_commit_success() const { return is_commit_success_; }
diff --git a/src/storage/high_availability/ob_ls_complete_migration.cpp b/src/storage/high_availability/ob_ls_complete_migration.cpp
index 9faa37b857..e9747fb423 100644
--- a/src/storage/high_availability/ob_ls_complete_migration.cpp
+++ b/src/storage/high_availability/ob_ls_complete_migration.cpp
@@ -798,7 +798,7 @@ ObStartCompleteMigrationTask::ObStartCompleteMigrationTask()
     is_inited_(false),
     ls_handle_(),
     ctx_(nullptr),
-    log_sync_scn_(0)
+    log_sync_scn_(palf::SCN::min_scn())
 {
 }
 
@@ -878,8 +878,8 @@ int ObStartCompleteMigrationTask::wait_log_sync_()
   bool is_log_sync = false;
   bool is_need_rebuild = false;
   bool is_cancel = false;
-  int64_t last_end_log_ts_ns = 0;
-  int64_t current_end_log_ts_ns = 0;
+  palf::SCN last_end_scn;
+  palf::SCN current_end_scn;
   const int64_t OB_CHECK_LOG_SYNC_INTERVAL = 200 * 1000; // 200ms
   const int64_t CLOG_IN_SYNC_DELAY_TIMEOUT = 30 * 60 * 1000 * 1000; // 30 min
   bool need_wait = true;
@@ -913,8 +913,8 @@ int ObStartCompleteMigrationTask::wait_log_sync_()
 
       if (OB_FAIL(ret)) {
       } else if (is_log_sync) {
-        if (OB_FAIL(ls->get_end_ts_ns(log_sync_scn_))) {
-          LOG_WARN("failed to get end ts ns", K(ret), KPC(ctx_));
+        if (OB_FAIL(ls->get_end_scn(log_sync_scn_))) {
+          LOG_WARN("failed to get end scn", K(ret), KPC(ctx_));
         } else {
           const int64_t cost_ts = ObTimeUtility::current_time() - wait_replay_start_ts;
           LOG_INFO("log is sync, stop wait_log_sync", "arg", ctx_->arg_, K(cost_ts));
@@ -923,15 +923,15 @@ int ObStartCompleteMigrationTask::wait_log_sync_()
         const int64_t cost_ts = ObTimeUtility::current_time() - wait_replay_start_ts;
         ret = OB_LOG_NOT_SYNC;
         LOG_WARN("log is not sync", K(ret), KPC(ctx_), K(cost_ts));
-      } else if (OB_FAIL(ls->get_end_ts_ns(current_end_log_ts_ns))) {
-        LOG_WARN("failed to get end ts ns", K(ret), KPC(ctx_));
+      } else if (OB_FAIL(ls->get_end_scn(current_end_scn))) {
+        LOG_WARN("failed to get end scn", K(ret), KPC(ctx_));
       } else {
         bool is_timeout = false;
         if (REACH_TENANT_TIME_INTERVAL(60 * 1000 * 1000)) {
           LOG_INFO("log is not sync, retry next loop", "arg", ctx_->arg_);
         }
 
-        if (current_end_log_ts_ns == last_end_log_ts_ns) {
+        if (current_end_scn == last_end_scn) {
           const int64_t current_ts = ObTimeUtility::current_time();
           if ((current_ts - last_wait_replay_ts) > CLOG_IN_SYNC_DELAY_TIMEOUT) {
             is_timeout = true;
@@ -944,14 +944,14 @@ int ObStartCompleteMigrationTask::wait_log_sync_()
               ret = OB_LOG_NOT_SYNC;
               STORAGE_LOG(WARN, "failed to check log replay sync. timeout, stop migration task",
                   K(ret), K(*ctx_), K(CLOG_IN_SYNC_DELAY_TIMEOUT), K(wait_replay_start_ts),
-                  K(current_ts), K(current_end_log_ts_ns));
+                  K(current_ts), K(current_end_scn));
             }
           }
-        } else if (last_end_log_ts_ns > current_end_log_ts_ns) {
+        } else if (last_end_scn > current_end_scn) {
           ret = OB_ERR_UNEXPECTED;
-          LOG_WARN("last end log ts should not smaller than current end log ts", K(ret), K(last_end_log_ts_ns), K(current_end_log_ts_ns));
+          LOG_WARN("last end log ts should not smaller than current end log ts", K(ret), K(last_end_scn), K(current_end_scn));
         } else {
-          last_end_log_ts_ns = current_end_log_ts_ns;
+          last_end_scn = current_end_scn;
           last_wait_replay_ts = ObTimeUtility::current_time();
         }
 
@@ -976,8 +976,8 @@ int ObStartCompleteMigrationTask::wait_log_replay_sync_()
   logservice::ObLogService *log_service = nullptr;
   bool wait_log_replay_success = false;
   bool is_cancel = false;
-  int64_t current_replay_log_ts_ns = 0;
-  int64_t last_replay_log_ts_ns = 0;
+  palf::SCN current_replay_scn;
+  palf::SCN last_replay_scn;
   const int64_t OB_CHECK_LOG_REPLAY_INTERVAL = 200 * 1000; // 200ms
   const int64_t CLOG_IN_REPLAY_DELAY_TIMEOUT = 30 * 60 * 1000 * 1000L; // 30 min
   bool need_wait = false;
@@ -1005,9 +1005,9 @@ int ObStartCompleteMigrationTask::wait_log_replay_sync_()
       } else if (is_cancel) {
         ret = OB_CANCELED;
         STORAGE_LOG(WARN, "task is cancelled", K(ret), K(*this));
-      } else if (OB_FAIL(ls->get_max_decided_log_ts_ns(current_replay_log_ts_ns))) {
+      } else if (OB_FAIL(ls->get_max_decided_scn(current_replay_scn))) {
         LOG_WARN("failed to get current replay log ts", K(ret), KPC(ctx_));
-      } else if (current_replay_log_ts_ns >= log_sync_scn_) {
+      } else if (current_replay_scn >= log_sync_scn_) {
         wait_log_replay_success = true;
         const int64_t cost_ts = ObTimeUtility::current_time() - wait_replay_start_ts;
         LOG_INFO("wait replay log ts ns success, stop wait", "arg", ctx_->arg_, K(cost_ts));
@@ -1016,11 +1016,11 @@ int ObStartCompleteMigrationTask::wait_log_replay_sync_()
         bool is_timeout = false;
         if (REACH_TENANT_TIME_INTERVAL(60 * 1000 * 1000)) {
           LOG_INFO("replay log is not sync, retry next loop", "arg", ctx_->arg_,
-              "current_replay_log_ts_ns", current_replay_log_ts_ns,
+              "current_replay_scn", current_replay_scn,
               "log_sync_scn", log_sync_scn_);
         }
 
-        if (current_replay_log_ts_ns == last_replay_log_ts_ns) {
+        if (current_replay_scn == last_replay_scn) {
           if (current_ts - last_replay_ts > CLOG_IN_REPLAY_DELAY_TIMEOUT) {
             is_timeout = true;
           }
@@ -1031,15 +1031,15 @@ int ObStartCompleteMigrationTask::wait_log_replay_sync_()
               ret = OB_WAIT_REPLAY_TIMEOUT;
               STORAGE_LOG(WARN, "failed to check log replay sync. timeout, stop migration task",
                   K(ret), K(*ctx_), K(CLOG_IN_REPLAY_DELAY_TIMEOUT), K(wait_replay_start_ts),
-                  K(current_ts), K(current_replay_log_ts_ns));
+                  K(current_ts), K(current_replay_scn));
             }
           }
-        } else if (last_replay_log_ts_ns > current_replay_log_ts_ns) {
+        } else if (last_replay_scn > current_replay_scn) {
           ret = OB_ERR_UNEXPECTED;
           LOG_WARN("last end log ts should not smaller than current end log ts", K(ret),
-              K(last_replay_log_ts_ns), K(current_replay_log_ts_ns));
+              K(last_replay_scn), K(current_replay_scn));
         } else {
-          last_replay_log_ts_ns = current_replay_log_ts_ns;
+          last_replay_scn = current_replay_scn;
           last_replay_ts = current_ts;
         }
 
diff --git a/src/storage/high_availability/ob_ls_complete_migration.h b/src/storage/high_availability/ob_ls_complete_migration.h
index cef40694bb..e497e1fa07 100644
--- a/src/storage/high_availability/ob_ls_complete_migration.h
+++ b/src/storage/high_availability/ob_ls_complete_migration.h
@@ -187,7 +187,7 @@ private:
   bool is_inited_;
   ObLSHandle ls_handle_;
   ObLSCompleteMigrationCtx *ctx_;
-  int64_t log_sync_scn_;
+  palf::SCN log_sync_scn_;
   DISALLOW_COPY_AND_ASSIGN(ObStartCompleteMigrationTask);
 };
 
diff --git a/src/storage/high_availability/ob_ls_prepare_migration.cpp b/src/storage/high_availability/ob_ls_prepare_migration.cpp
index 8a51c5a9f3..841fae2933 100644
--- a/src/storage/high_availability/ob_ls_prepare_migration.cpp
+++ b/src/storage/high_availability/ob_ls_prepare_migration.cpp
@@ -30,7 +30,7 @@ ObLSPrepareMigrationCtx::ObLSPrepareMigrationCtx()
     task_id_(),
     start_ts_(0),
     finish_ts_(0),
-    log_sync_scn_(0)
+    log_sync_scn_(palf::SCN::min_scn())
 {
 }
 
@@ -41,7 +41,7 @@ ObLSPrepareMigrationCtx::~ObLSPrepareMigrationCtx()
 bool ObLSPrepareMigrationCtx::is_valid() const
 {
   return arg_.is_valid() && !task_id_.is_invalid()
-      && tenant_id_ != 0 && tenant_id_ != OB_INVALID_ID && log_sync_scn_ >= 0;
+      && tenant_id_ != 0 && tenant_id_ != OB_INVALID_ID && log_sync_scn_.is_valid();
 }
 
 void ObLSPrepareMigrationCtx::reset()
@@ -51,7 +51,7 @@ void ObLSPrepareMigrationCtx::reset()
   task_id_.reset();
   start_ts_ = 0;
   finish_ts_ = 0;
-  log_sync_scn_ = 0;
+  log_sync_scn_.set_min();
   ObIHADagNetCtx::reset();
 }
 
@@ -78,7 +78,7 @@ int ObLSPrepareMigrationCtx::fill_comment(char *buf, const int64_t buf_len) cons
 void ObLSPrepareMigrationCtx::reuse()
 {
   ObIHADagNetCtx::reuse();
-  log_sync_scn_ = 0;
+  log_sync_scn_.set_min();
 }
 
 /******************ObLSPrepareMigrationDagNet*********************/
@@ -736,7 +736,7 @@ int ObStartPrepareMigrationTask::process()
     LOG_WARN("failed to wait log replay sync", K(ret), KPC(ctx_));
   } else if (OB_FAIL(remove_local_incomplete_tablets_())) {
     LOG_WARN("failed to remove local incomplete tablets", K(ret), KPC(ctx_));
-  } else if (OB_FAIL(wait_ls_checkpoint_ts_push_())) {
+  } else if (OB_FAIL(wait_ls_checkpoint_scn_push_())) {
     LOG_WARN("failed to wait ls checkpoint ts push", K(ret), KPC(ctx_));
   } else if (OB_FAIL(generate_prepare_migration_dags_())) {
     LOG_WARN("failed to generate prepare migration dags", K(ret), KPC(ctx_));
@@ -798,8 +798,8 @@ int ObStartPrepareMigrationTask::deal_with_local_ls_()
   } else if (OB_FAIL(ls->get_saved_info(saved_info))) {
     LOG_WARN("failed to get saved info", K(ret), KPC(ls));
   } else if (!saved_info.is_empty()) {
-    ctx_->log_sync_scn_ = saved_info.clog_checkpoint_scn_.get_val_for_lsn_allocator();
-  } else if (OB_FAIL(ls->get_end_ts_ns(ctx_->log_sync_scn_))) {
+    ctx_->log_sync_scn_ = saved_info.clog_checkpoint_scn_;
+  } else if (OB_FAIL(ls->get_end_scn(ctx_->log_sync_scn_))) {
     LOG_WARN("failed to get end ts ns", K(ret), KPC(ctx_));
   }
   return ret;
@@ -813,8 +813,8 @@ int ObStartPrepareMigrationTask::wait_log_replay_sync_()
   logservice::ObLogService *log_service = nullptr;
   bool wait_log_replay_success = false;
   bool is_cancel = false;
-  int64_t current_replay_log_ts_ns = 0;
-  int64_t last_replay_log_ts_ns = 0;
+  palf::SCN current_replay_scn;
+  palf::SCN last_replay_scn;
   const int64_t OB_CHECK_LOG_SYNC_INTERVAL = 200 * 1000; // 200ms
   const int64_t CLOG_IN_SYNC_DELAY_TIMEOUT = 30 * 60 * 1000 * 1000L; // 30 min
   ObLSSavedInfo saved_info;
@@ -845,9 +845,9 @@ int ObStartPrepareMigrationTask::wait_log_replay_sync_()
       } else if (is_cancel) {
         ret = OB_CANCELED;
         STORAGE_LOG(WARN, "task is cancelled", K(ret), K(*this));
-      } else if (OB_FAIL(ls->get_max_decided_log_ts_ns(current_replay_log_ts_ns))) {
-        LOG_WARN("failed to get current replay log ts", K(ret), KPC(ctx_));
-      } else if (current_replay_log_ts_ns >= ctx_->log_sync_scn_) {
+      } else if (OB_FAIL(ls->get_max_decided_scn(current_replay_scn))) {
+        LOG_WARN("failed to get current replay log scn", K(ret), KPC(ctx_));
+      } else if (current_replay_scn >= ctx_->log_sync_scn_) {
         wait_log_replay_success = true;
         const int64_t cost_ts = ObTimeUtility::current_time() - wait_replay_start_ts;
         LOG_INFO("wait replay log ts ns success, stop wait", "arg", ctx_->arg_, K(cost_ts));
@@ -856,11 +856,11 @@ int ObStartPrepareMigrationTask::wait_log_replay_sync_()
         bool is_timeout = false;
         if (REACH_TIME_INTERVAL(60 * 1000 * 1000)) {
           LOG_INFO("log is not sync, retry next loop", "arg", ctx_->arg_,
-              "current_replay_log_ts_ns", current_replay_log_ts_ns,
+              "current_replay_scn", current_replay_scn,
               "log_sync_scn", ctx_->log_sync_scn_);
         }
 
-        if (current_replay_log_ts_ns == last_replay_log_ts_ns) {
+        if (current_replay_scn == last_replay_scn) {
 
           if (current_ts - last_replay_ts > CLOG_IN_SYNC_DELAY_TIMEOUT) {
             is_timeout = true;
@@ -873,15 +873,15 @@ int ObStartPrepareMigrationTask::wait_log_replay_sync_()
               ret = OB_TIMEOUT;
               STORAGE_LOG(WARN, "failed to check log replay sync. timeout, stop migration task",
                   K(ret), K(*ctx_), K(CLOG_IN_SYNC_DELAY_TIMEOUT), K(wait_replay_start_ts),
-                  K(current_ts), K(current_replay_log_ts_ns));
+                  K(current_ts), K(current_replay_scn));
             }
           }
-        } else if (last_replay_log_ts_ns > current_replay_log_ts_ns) {
+        } else if (last_replay_scn > current_replay_scn) {
           ret = OB_ERR_UNEXPECTED;
           LOG_WARN("last end log ts should not smaller than current end log ts", K(ret),
-              K(last_replay_log_ts_ns), K(current_replay_log_ts_ns));
+              K(last_replay_scn), K(current_replay_scn));
         } else {
-          last_replay_log_ts_ns = current_replay_log_ts_ns;
+          last_replay_scn = current_replay_scn;
           last_replay_ts = current_ts;
         }
 
@@ -997,13 +997,13 @@ int ObStartPrepareMigrationTask::generate_prepare_migration_dags_()
   return ret;
 }
 
-int ObStartPrepareMigrationTask::wait_ls_checkpoint_ts_push_()
+int ObStartPrepareMigrationTask::wait_ls_checkpoint_scn_push_()
 {
   int ret = OB_SUCCESS;
   ObLSHandle ls_handle;
   ObLS *ls = nullptr;
   checkpoint::ObCheckpointExecutor *checkpoint_executor = NULL;
-  int64_t checkpoint_ts = 0;
+  palf::SCN checkpoint_scn;
   const int64_t MAX_WAIT_INTERVAL_BY_CHECKPOINT_BY_FLUSH = GCONF._advance_checkpoint_timeout;
   const int64_t MAX_SLEEP_INTERVAL_MS = 5 * 1000 * 1000; //5s
   bool is_cancel = false;
@@ -1026,8 +1026,6 @@ int ObStartPrepareMigrationTask::wait_ls_checkpoint_ts_push_()
     LOG_WARN("checkpoint executor should not be NULL", K(ret), KPC(ctx_), KP(checkpoint_executor));
   } else {
     const int64_t wait_checkpoint_push_start_ts = ObTimeUtility::current_time();
-    palf::SCN tmp;
-    tmp.convert_for_lsn_allocator(ctx_->log_sync_scn_);
     while (OB_SUCC(ret)) {
       if (ctx_->is_failed()) {
         ret = OB_CANCELED;
@@ -1038,12 +1036,12 @@ int ObStartPrepareMigrationTask::wait_ls_checkpoint_ts_push_()
       } else if (is_cancel) {
         ret = OB_CANCELED;
         STORAGE_LOG(WARN, "task is cancelled", K(ret), K(*this));
-      } else if (FALSE_IT(checkpoint_ts = ls->get_clog_checkpoint_ts())) {
-      } else if (checkpoint_ts >= ctx_->log_sync_scn_) {
+      } else if (FALSE_IT(checkpoint_scn = ls->get_clog_checkpoint_scn())) {
+      } else if (checkpoint_scn >= ctx_->log_sync_scn_) {
         const int64_t cost_ts = ObTimeUtility::current_time() - wait_checkpoint_push_start_ts;
         LOG_INFO("succeed wait clog checkpoint ts push", "cost", cost_ts, "ls_id", ctx_->arg_.ls_id_);
         break;
-      } else if (OB_FAIL(checkpoint_executor->advance_checkpoint_by_flush(tmp))) {
+      } else if (OB_FAIL(checkpoint_executor->advance_checkpoint_by_flush(ctx_->log_sync_scn_))) {
         if (OB_NO_NEED_UPDATE == ret) {
           ret = OB_SUCCESS;
         } else {
@@ -1055,10 +1053,10 @@ int ObStartPrepareMigrationTask::wait_ls_checkpoint_ts_push_()
         const int64_t current_ts = ObTimeUtility::current_time();
         if (current_ts - wait_checkpoint_push_start_ts >= MAX_WAIT_INTERVAL_BY_CHECKPOINT_BY_FLUSH) {
           ret = OB_TIMEOUT;
-          LOG_WARN("wait ls checkpoint ts push time out",
-              "ls_checkpoint_ts", checkpoint_ts, "need_checkpoint_ts", ctx_->log_sync_scn_, "ls_id", ctx_->arg_.ls_id_);
+          LOG_WARN("wait ls checkpoint scn push time out",
+              "ls_checkpoint_scn", checkpoint_scn, "need_checkpoint_ts", ctx_->log_sync_scn_, "ls_id", ctx_->arg_.ls_id_);
         } else {
-          LOG_INFO("wait ls checkpoint ts push", "ls_checkpoint_ts", checkpoint_ts,
+          LOG_INFO("wait ls checkpoint ts push", "ls_checkpoint_scn", checkpoint_scn,
               "need_checkpoint_ts", ctx_->log_sync_scn_, "ls_id", ctx_->arg_.ls_id_);
           ob_usleep(MAX_SLEEP_INTERVAL_MS);
         }
diff --git a/src/storage/high_availability/ob_ls_prepare_migration.h b/src/storage/high_availability/ob_ls_prepare_migration.h
index c05651a99c..f1225ec289 100644
--- a/src/storage/high_availability/ob_ls_prepare_migration.h
+++ b/src/storage/high_availability/ob_ls_prepare_migration.h
@@ -42,7 +42,7 @@ public:
 
   int64_t start_ts_;
   int64_t finish_ts_;
-  int64_t log_sync_scn_;
+  palf::SCN log_sync_scn_;
 
   INHERIT_TO_STRING_KV(
       "ObIHADagNetCtx", ObIHADagNetCtx,
@@ -169,7 +169,7 @@ public:
 private:
   int deal_with_local_ls_();
   int wait_log_replay_sync_();
-  int wait_ls_checkpoint_ts_push_();
+  int wait_ls_checkpoint_scn_push_();
   int generate_prepare_migration_dags_();
   int remove_local_incomplete_tablets_();
 
diff --git a/src/storage/high_availability/ob_physical_copy_task.cpp b/src/storage/high_availability/ob_physical_copy_task.cpp
index 05c636ea37..aac57ec9e6 100644
--- a/src/storage/high_availability/ob_physical_copy_task.cpp
+++ b/src/storage/high_availability/ob_physical_copy_task.cpp
@@ -963,7 +963,7 @@ int ObPhysicalCopyFinishTask::build_create_sstable_param_(
     param.original_size_ = sstable_param_->basic_meta_.original_size_;
     param.max_merged_trans_version_ = sstable_param_->basic_meta_.max_merged_trans_version_;
     param.ddl_log_ts_ = sstable_param_->basic_meta_.ddl_log_ts_;
-    param.filled_tx_log_ts_ = sstable_param_->basic_meta_.filled_tx_log_ts_;
+    param.filled_tx_scn_ = sstable_param_->basic_meta_.filled_tx_scn_;
     param.contain_uncommitted_row_ = sstable_param_->basic_meta_.contain_uncommitted_row_;
     param.compressor_type_ = sstable_param_->basic_meta_.compressor_type_;
     param.encrypt_id_ = sstable_param_->basic_meta_.encrypt_id_;
diff --git a/src/storage/high_availability/ob_storage_ha_reader.cpp b/src/storage/high_availability/ob_storage_ha_reader.cpp
index 558f271390..d9f36c6a5a 100644
--- a/src/storage/high_availability/ob_storage_ha_reader.cpp
+++ b/src/storage/high_availability/ob_storage_ha_reader.cpp
@@ -199,7 +199,7 @@ int ObCopyMacroBlockObReader::init(
         arg.ls_id_ = param.ls_id_;
         arg.table_key_ = param.table_key_;
         //TODO(yanfeng) fix backfill tx log ts and data version
-        arg.backfill_tx_log_ts_ = 0;
+        arg.backfill_tx_scn_.set_min();
         arg.data_version_ = 0;
         LOG_INFO("init arg", K(param), K(arg));
       }
@@ -555,7 +555,7 @@ int ObCopyMacroBlockObProducer::init(
     const ObITable::TableKey &table_key,
     const ObCopyMacroRangeInfo &copy_macro_range_info,
     const int64_t data_version,
-    const int64_t backfill_tx_log_ts)
+    const palf::SCN backfill_tx_scn)
 {
   int ret = OB_SUCCESS;
   ObLSHandle ls_handle;
@@ -569,10 +569,10 @@ int ObCopyMacroBlockObProducer::init(
     ret = OB_INIT_TWICE;
     LOG_WARN("cannot init twice", K(ret));
   } else if (OB_INVALID_ID == tenant_id || !ls_id.is_valid() || !table_key.is_valid()
-      || !copy_macro_range_info.is_valid() || data_version < 0 || backfill_tx_log_ts < 0) {
+      || !copy_macro_range_info.is_valid() || data_version < 0 || !backfill_tx_scn.is_valid()) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid args", K(ret), K(tenant_id), K(ls_id), K(table_key),
-        K(copy_macro_range_info), K(data_version), K(backfill_tx_log_ts));
+        K(copy_macro_range_info), K(data_version), K(backfill_tx_scn));
   } else if (OB_FAIL(guard.switch_to(tenant_id))) {
     LOG_WARN("switch tenant failed", K(ret), K(tenant_id));
   } else if (OB_ISNULL(ls_service = MTL(ObLSService *))) {
@@ -614,7 +614,7 @@ int ObCopyMacroBlockObProducer::init(
       meta_ = &sstable_->get_meta();
       is_inited_ = true;
       LOG_INFO("succeed to init macro block producer",
-          K(table_key), K(data_version), K(backfill_tx_log_ts), K(copy_macro_range_info));
+          K(table_key), K(data_version), K(backfill_tx_scn), K(copy_macro_range_info));
     }
   }
 
diff --git a/src/storage/high_availability/ob_storage_ha_reader.h b/src/storage/high_availability/ob_storage_ha_reader.h
index 76275a49b5..646c5f9290 100644
--- a/src/storage/high_availability/ob_storage_ha_reader.h
+++ b/src/storage/high_availability/ob_storage_ha_reader.h
@@ -167,7 +167,7 @@ public:
       const ObITable::TableKey &table_key,
       const ObCopyMacroRangeInfo &copy_macro_range_info,
       const int64_t data_version,
-      const int64_t backfill_tx_log_ts);
+      const palf::SCN backfill_tx_scn);
   int get_next_macro_block(
       blocksstable::ObBufferReader &data,
       ObCopyMacroBlockHeader &copy_macro_block_header);
diff --git a/src/storage/high_availability/ob_storage_ha_tablet_builder.cpp b/src/storage/high_availability/ob_storage_ha_tablet_builder.cpp
index 3c1fe616d1..2ccd37d98b 100644
--- a/src/storage/high_availability/ob_storage_ha_tablet_builder.cpp
+++ b/src/storage/high_availability/ob_storage_ha_tablet_builder.cpp
@@ -870,8 +870,8 @@ int ObStorageHATabletsBuilder::create_tablet_remote_logical_sstable_(
   int ret = OB_SUCCESS;
   ObTabletHandle tablet_handle;
   ObTablet *tablet = nullptr;
-  int64_t start_log_ts = 0;
-  int64_t end_log_ts = 0;
+  palf::SCN start_scn;
+  palf::SCN end_scn;
   ObArray<ObITable *> minor_tables;
   ObTableHandleV2 table_handle;
 
@@ -887,22 +887,22 @@ int ObStorageHATabletsBuilder::create_tablet_remote_logical_sstable_(
   } else if (OB_ISNULL(tablet = tablet_handle.get_obj())) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("tablet should not be NULL", K(ret), KP(tablet), K(tablet_id));
-  } else if (FALSE_IT(start_log_ts = tablet->get_tablet_meta().start_scn_.get_val_for_gts())) {
-  } else if (FALSE_IT(end_log_ts = tablet->get_tablet_meta().clog_checkpoint_scn_.get_val_for_gts())) {
-  } else if (start_log_ts > end_log_ts)  {
+  } else if (FALSE_IT(start_scn = tablet->get_tablet_meta().start_scn_)) {
+  } else if (FALSE_IT(end_scn = tablet->get_tablet_meta().clog_checkpoint_scn_)) {
+  } else if (start_scn > end_scn)  {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("tablet clog start ts is bigger than clog checkpoint ts, unexpected !",
-        K(ret), K(start_log_ts), K(end_log_ts), KPC(tablet));
+        K(ret), K(start_scn), K(end_scn), KPC(tablet));
   } else if (OB_FAIL(tables_handle.get_all_minor_sstables(minor_tables))) {
     LOG_WARN("failed to get all minor sstables", K(ret), K(tablet_id), K(tables_handle), KPC(tablet));
   } else {
-    start_log_ts = minor_tables.empty() ?
-        start_log_ts : minor_tables.at(minor_tables.count() - 1)->get_end_scn().get_val_for_inner_table_field();
-    if (start_log_ts >= end_log_ts || end_log_ts == ObTabletMeta::INIT_CLOG_CHECKPOINT_TS) {
+    start_scn = minor_tables.empty() ?
+        start_scn : minor_tables.at(minor_tables.count() - 1)->get_end_scn();
+    if (start_scn >= end_scn|| end_scn.is_base_scn()) {
       LOG_INFO("local tablet sstable is continue with memtable, no need create remote logical sstable",
-          K(tablet_id), K(minor_tables), K(start_log_ts), K(end_log_ts));
-    } else if (OB_FAIL(create_remote_logical_sstable_(tablet_id, start_log_ts, end_log_ts, tablet, table_handle))) {
-      LOG_WARN("failed to create remote logical sstable", K(ret), K(tablet_id), K(start_log_ts), K(end_log_ts), KPC(tablet));
+          K(tablet_id), K(minor_tables), K(start_scn), K(start_scn));
+    } else if (OB_FAIL(create_remote_logical_sstable_(tablet_id, start_scn, end_scn, tablet, table_handle))) {
+      LOG_WARN("failed to create remote logical sstable", K(ret), K(tablet_id), K(start_scn), K(end_scn), KPC(tablet));
     } else if (OB_FAIL(tables_handle.add_table(table_handle))) {
       LOG_WARN("failed to add table handle into tables handle", K(ret), K(table_handle), K(tables_handle));
     }
@@ -912,8 +912,8 @@ int ObStorageHATabletsBuilder::create_tablet_remote_logical_sstable_(
 
 int ObStorageHATabletsBuilder::create_remote_logical_sstable_(
     const common::ObTabletID &tablet_id,
-    const int64_t start_log_ts,
-    const int64_t end_log_ts,
+    const palf::SCN start_scn,
+    const palf::SCN end_scn,
     ObTablet *tablet,
     ObTableHandleV2 &table_handle)
 {
@@ -923,12 +923,12 @@ int ObStorageHATabletsBuilder::create_remote_logical_sstable_(
   if (!is_inited_) {
     ret = OB_NOT_INIT;
     LOG_WARN("storage ha tablets builder do not init", K(ret));
-  } else if (!tablet_id.is_valid() || OB_ISNULL(tablet) || start_log_ts < 0 || end_log_ts < 0 || start_log_ts == end_log_ts) {
+  } else if (!tablet_id.is_valid() || OB_ISNULL(tablet) || !start_scn.is_valid() || !end_scn.is_valid() || start_scn == end_scn) {
     ret = OB_INVALID_ARGUMENT;
-    LOG_WARN("create remote logical sstable get invalid argument", K(ret), KPC(tablet), K(start_log_ts), K(end_log_ts));
-  } else if (OB_FAIL(build_remote_logical_sstable_param_(start_log_ts, end_log_ts, tablet->get_storage_schema(),
+    LOG_WARN("create remote logical sstable get invalid argument", K(ret), KPC(tablet), K(start_scn), K(end_scn));
+  } else if (OB_FAIL(build_remote_logical_sstable_param_(start_scn, end_scn, tablet->get_storage_schema(),
       tablet_id, create_sstable_param))) {
-    LOG_WARN("failed to build remote logical sstable param", K(ret), K(tablet_id), K(start_log_ts), K(end_log_ts));
+    LOG_WARN("failed to build remote logical sstable param", K(ret), K(tablet_id), K(start_scn), K(end_scn));
   } else if (OB_FAIL(ObTabletCreateDeleteHelper::create_sstable(create_sstable_param, table_handle))) {
     LOG_WARN("failed to create sstable", K(ret), K(create_sstable_param), K(tablet_id));
   } else {
@@ -938,8 +938,8 @@ int ObStorageHATabletsBuilder::create_remote_logical_sstable_(
 }
 
 int ObStorageHATabletsBuilder::build_remote_logical_sstable_param_(
-    const int64_t start_log_ts,
-    const int64_t end_log_ts,
+    const palf::SCN start_scn,
+    const palf::SCN end_scn,
     const ObStorageSchema &table_schema,
     const common::ObTabletID &tablet_id,
     ObTabletCreateSSTableParam &param)
@@ -948,7 +948,7 @@ int ObStorageHATabletsBuilder::build_remote_logical_sstable_param_(
   if (!is_inited_) {
     ret = OB_NOT_INIT;
     LOG_WARN("storage ha tablets builder do not init", K(ret));
-  } else if (start_log_ts < 0 || end_log_ts < 0 || start_log_ts == end_log_ts
+  } else if (!start_scn.is_valid() || !end_scn.is_valid() || start_scn == end_scn
       || !table_schema.is_valid() || !tablet_id.is_valid()) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("build remote logical sstable param get invalid argument", K(ret), K(table_schema), K(tablet_id));
@@ -960,8 +960,8 @@ int ObStorageHATabletsBuilder::build_remote_logical_sstable_param_(
     const int64_t multi_version_col_cnt = ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
     param.table_key_.table_type_ = ObITable::TableType::REMOTE_LOGICAL_MINOR_SSTABLE;
     param.table_key_.tablet_id_ = tablet_id;
-    param.table_key_.scn_range_.start_scn_.convert_for_gts(start_log_ts); //TODO(SCN) fix log_ts with SCN
-    param.table_key_.scn_range_.end_scn_.convert_for_gts(end_log_ts);
+    param.table_key_.scn_range_.start_scn_ = start_scn;
+    param.table_key_.scn_range_.end_scn_ = end_scn;
     param.max_merged_trans_version_ = INT64_MAX; //Set max merged trans version avoild sstable recycle;
 
     param.schema_version_ = table_schema.get_schema_version();
@@ -985,7 +985,7 @@ int ObStorageHATabletsBuilder::build_remote_logical_sstable_param_(
     param.data_checksum_ = 0;
     param.occupy_size_ = 0;
     param.ddl_log_ts_ = 0;
-    param.filled_tx_log_ts_ = 0;
+    param.filled_tx_scn_.set_min();
     param.original_size_ = 0;
     param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
   }
@@ -1063,7 +1063,7 @@ int ObStorageHATabletsBuilder::update_local_tablet_(
   } else if (FALSE_IT(param.storage_schema_ = &tablet->get_storage_schema())) {
   } else if (FALSE_IT(param.rebuild_seq_ = ls->get_rebuild_seq())) {
   } else if (FALSE_IT(param.update_logical_minor_sstable_ = true)) {
-  } else if (FALSE_IT(param.start_scn_ = tablet_info.param_.start_scn_.get_val_for_gts())) {
+  } else if (FALSE_IT(param.start_scn_ = tablet_info.param_.start_scn_)) {
   } else if (OB_FAIL(ls->build_ha_tablet_new_table_store(tablet_info.tablet_id_, param))) {
     LOG_WARN("failed to build ha tablet new table store", K(ret), K(param), K(tablet_info));
   } else {
diff --git a/src/storage/high_availability/ob_storage_ha_tablet_builder.h b/src/storage/high_availability/ob_storage_ha_tablet_builder.h
index 1db5aa47d9..71cc9621c1 100644
--- a/src/storage/high_availability/ob_storage_ha_tablet_builder.h
+++ b/src/storage/high_availability/ob_storage_ha_tablet_builder.h
@@ -113,13 +113,13 @@ private:
       ObTablesHandleArray &tables_handle);
   int create_remote_logical_sstable_(
       const common::ObTabletID &tablet_id,
-      const int64_t start_log_ts,
-      const int64_t end_log_ts,
+      const palf::SCN start_scn,
+      const palf::SCN end_scn,
       ObTablet *tablet,
       ObTableHandleV2 &table_handle);
   int build_remote_logical_sstable_param_(
-      const int64_t start_log_ts,
-      const int64_t end_log_ts,
+      const palf::SCN start_scn,
+      const palf::SCN end_scn,
       const ObStorageSchema &table_schema,
       const common::ObTabletID &tablet_id,
       ObTabletCreateSSTableParam &param);
diff --git a/src/storage/high_availability/ob_tablet_backfill_tx.cpp b/src/storage/high_availability/ob_tablet_backfill_tx.cpp
index ed6b7756a7..daffd5b8fa 100644
--- a/src/storage/high_availability/ob_tablet_backfill_tx.cpp
+++ b/src/storage/high_availability/ob_tablet_backfill_tx.cpp
@@ -26,7 +26,7 @@ namespace storage
 ObBackfillTXCtx::ObBackfillTXCtx()
   : task_id_(),
     ls_id_(),
-    log_sync_scn_(0),
+    log_sync_scn_(palf::SCN::min_scn()),
     lock_(),
     tablet_id_index_(0),
     tablet_id_array_()
@@ -85,7 +85,7 @@ int ObBackfillTXCtx::get_tablet_id(ObTabletID &tablet_id)
 int ObBackfillTXCtx::build_backfill_tx_ctx(
     const share::ObTaskId &task_id,
     const share::ObLSID &ls_id,
-    const int64_t log_sync_scn,
+    const palf::SCN log_sync_scn,
     const common::ObIArray<common::ObTabletID> &tablet_id_array)
 {
   int ret = OB_SUCCESS;
@@ -93,7 +93,7 @@ int ObBackfillTXCtx::build_backfill_tx_ctx(
   if (!tablet_id_array_.empty()) {
     ret = OB_INIT_TWICE;
     LOG_WARN("backfill tx ctx init twice", K(ret), KPC(this));
-  } else if (task_id.is_invalid() || !ls_id.is_valid() || log_sync_scn < 0) {
+  } else if (task_id.is_invalid() || !ls_id.is_valid() || !log_sync_scn.is_valid()) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("build backfill tx ctx get invalid argument", K(ret), K(task_id), K(ls_id),
         K(log_sync_scn), K(tablet_id_array));
@@ -527,7 +527,7 @@ int ObTabletBackfillTXTask::generate_table_backfill_tx_task_(
         LOG_WARN("table should not be NULL or table type is unexpected", K(ret), KPC(table));
       } else if (FALSE_IT(sstable = static_cast<ObSSTable *>(table))) {
       } else if (!sstable->get_meta().get_basic_meta().contain_uncommitted_row_
-          || sstable->get_meta().get_basic_meta().filled_tx_log_ts_ >= backfill_tx_ctx_->log_sync_scn_) {
+          || sstable->get_meta().get_basic_meta().filled_tx_scn_ >= backfill_tx_ctx_->log_sync_scn_) {
         FLOG_INFO("sstable do not contain uncommitted row, no need backfill tx", KPC(sstable),
             "log sync scn", backfill_tx_ctx_->log_sync_scn_);
       } else if (OB_FAIL(tablet_backfill_tx_dag->alloc_task(table_backfill_tx_task))) {
@@ -656,7 +656,7 @@ int ObTabletTableBackfillTXTask::prepare_merge_ctx_()
     tablet_merge_ctx_.sstable_version_range_.multi_version_start_ = tablet_handle_.get_obj()->get_multi_version_start();
     tablet_merge_ctx_.sstable_version_range_.snapshot_version_ = tablet_handle_.get_obj()->get_snapshot_version();
     tablet_merge_ctx_.scn_range_ = table_handle_.get_table()->get_key().scn_range_;
-    tablet_merge_ctx_.merge_scn_ = backfill_tx_ctx_->log_sync_scn_;
+    tablet_merge_ctx_.merge_scn_ = backfill_tx_ctx_->log_sync_scn_.get_val_for_lsn_allocator();
     tablet_merge_ctx_.create_snapshot_version_ = 0;
 
     if (OB_FAIL(tablet_merge_ctx_.tables_handle_.add_table(table_handle_))) {
@@ -945,7 +945,7 @@ int64_t ObFinishBackfillTXDag::hash() const
 int ObFinishBackfillTXDag::init(
     const share::ObTaskId &task_id,
     const share::ObLSID &ls_id,
-    const int64_t log_sync_scn,
+    const palf::SCN log_sync_scn,
     ObIHADagNetCtx *ha_dag_net_ctx)
 {
   int ret = OB_SUCCESS;
@@ -953,7 +953,7 @@ int ObFinishBackfillTXDag::init(
   if (is_inited_) {
     ret = OB_INIT_TWICE;
     LOG_WARN("finish backfill tx dag init twice", K(ret));
-  } else if (task_id.is_invalid() || !ls_id.is_valid() || log_sync_scn < 0|| OB_ISNULL(ha_dag_net_ctx)) {
+  } else if (task_id.is_invalid() || !ls_id.is_valid() || !log_sync_scn.is_valid() || OB_ISNULL(ha_dag_net_ctx)) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("init finish backfill tx dag get invalid argument", K(ret), K(task_id), K(ls_id), K(log_sync_scn) ,KP(ha_dag_net_ctx));
   } else if (OB_FAIL(prepare_backfill_tx_ctx_(task_id, ls_id, log_sync_scn))) {
@@ -968,7 +968,7 @@ int ObFinishBackfillTXDag::init(
 int ObFinishBackfillTXDag::prepare_backfill_tx_ctx_(
     const share::ObTaskId &task_id,
     const share::ObLSID &ls_id,
-    const int64_t log_sync_scn)
+    const palf::SCN log_sync_scn)
 {
   int ret = OB_SUCCESS;
   ObLS *ls = nullptr;
diff --git a/src/storage/high_availability/ob_tablet_backfill_tx.h b/src/storage/high_availability/ob_tablet_backfill_tx.h
index 7b7d110c2a..d3c79bdd58 100644
--- a/src/storage/high_availability/ob_tablet_backfill_tx.h
+++ b/src/storage/high_availability/ob_tablet_backfill_tx.h
@@ -36,7 +36,7 @@ public:
   int build_backfill_tx_ctx(
       const share::ObTaskId &task_id,
       const share::ObLSID &ls_id,
-      const int64_t log_sync_scn,
+      const palf::SCN log_sync_scn,
       const common::ObIArray<common::ObTabletID> &tablet_id_array);
   bool is_empty() const;
   int check_is_same(
@@ -54,7 +54,7 @@ public:
 public:
   share::ObTaskId task_id_;
   share::ObLSID ls_id_;
-  int64_t log_sync_scn_;
+  palf::SCN log_sync_scn_;
 private:
   bool inner_is_valid_() const;
 private:
@@ -189,7 +189,7 @@ public:
   int init(
       const share::ObTaskId &task_id,
       const share::ObLSID &ls_id,
-      const int64_t log_sync_scn,
+      const palf::SCN log_sync_scn,
       ObIHADagNetCtx *ha_dag_net_ctx);
   ObBackfillTXCtx *get_backfill_tx_ctx() { return &backfill_tx_ctx_; }
   INHERIT_TO_STRING_KV("ObStorageHADag", ObStorageHADag, KP(this));
@@ -197,7 +197,7 @@ protected:
   int prepare_backfill_tx_ctx_(
       const share::ObTaskId &task_id,
       const share::ObLSID &ls_id,
-      const int64_t log_sync_scn);
+      const palf::SCN log_sync_scn);
 
 protected:
   bool is_inited_;
diff --git a/src/storage/ls/ob_ls.h b/src/storage/ls/ob_ls.h
index 0eadc1c4ea..634baa0d4f 100644
--- a/src/storage/ls/ob_ls.h
+++ b/src/storage/ls/ob_ls.h
@@ -523,6 +523,7 @@ public:
   DELEGATE_WITH_RET(log_handler_, replace_member, int);
   DELEGATE_WITH_RET(log_handler_, is_in_sync, int);
   DELEGATE_WITH_RET(log_handler_, get_end_ts_ns, int);
+  DELEGATE_WITH_RET(log_handler_, get_end_scn, int);
   DELEGATE_WITH_RET(log_handler_, disable_sync, int);
   DELEGATE_WITH_RET(log_handler_, change_replica_num, int);
   DELEGATE_WITH_RET(log_handler_, get_end_lsn, int);
diff --git a/src/storage/ls/ob_ls_tablet_service.cpp b/src/storage/ls/ob_ls_tablet_service.cpp
index f6dbe8a5db..f2360b0070 100644
--- a/src/storage/ls/ob_ls_tablet_service.cpp
+++ b/src/storage/ls/ob_ls_tablet_service.cpp
@@ -1857,7 +1857,7 @@ int ObLSTabletService::build_create_sstable_param_for_migration(
     param.original_size_                 = mig_param.basic_meta_.original_size_;
     param.max_merged_trans_version_      = mig_param.basic_meta_.max_merged_trans_version_;
     param.ddl_log_ts_                    = mig_param.basic_meta_.ddl_log_ts_;
-    param.filled_tx_log_ts_              = mig_param.basic_meta_.filled_tx_log_ts_;
+    param.filled_tx_scn_              = mig_param.basic_meta_.filled_tx_scn_;
     param.contain_uncommitted_row_       = mig_param.basic_meta_.contain_uncommitted_row_;
     param.compressor_type_               = mig_param.basic_meta_.compressor_type_;
     param.encrypt_id_                    = mig_param.basic_meta_.encrypt_id_;
diff --git a/src/storage/ob_storage_rpc.cpp b/src/storage/ob_storage_rpc.cpp
index 72e9cf3782..b9664110b8 100644
--- a/src/storage/ob_storage_rpc.cpp
+++ b/src/storage/ob_storage_rpc.cpp
@@ -115,7 +115,7 @@ ObCopyMacroBlockRangeArg::ObCopyMacroBlockRangeArg()
     ls_id_(),
     table_key_(),
     data_version_(0),
-    backfill_tx_log_ts_(0),
+    backfill_tx_scn_(palf::SCN::min_scn()),
     copy_macro_range_info_()
 {
 }
@@ -126,7 +126,7 @@ void ObCopyMacroBlockRangeArg::reset()
   ls_id_.reset();
   table_key_.reset();
   data_version_ = 0;
-  backfill_tx_log_ts_ = 0;
+  backfill_tx_scn_.set_min();
   copy_macro_range_info_.reset();
 }
 
@@ -136,7 +136,7 @@ bool ObCopyMacroBlockRangeArg::is_valid() const
       && ls_id_.is_valid()
       && table_key_.is_valid()
       && data_version_ >= 0
-      && backfill_tx_log_ts_ >= 0
+      && backfill_tx_scn_ >= palf::SCN::min_scn()
       && copy_macro_range_info_.is_valid();
 }
 
@@ -153,13 +153,13 @@ int ObCopyMacroBlockRangeArg::assign(const ObCopyMacroBlockRangeArg &arg)
     ls_id_ = arg.ls_id_;
     table_key_ = arg.table_key_;
     data_version_ = arg.data_version_;
-    backfill_tx_log_ts_ = arg.backfill_tx_log_ts_;
+    backfill_tx_scn_ = arg.backfill_tx_scn_;
   }
   return ret;
 }
 
 OB_SERIALIZE_MEMBER(ObCopyMacroBlockRangeArg, tenant_id_, ls_id_, table_key_, data_version_,
-    backfill_tx_log_ts_, copy_macro_range_info_);
+    backfill_tx_scn_, copy_macro_range_info_);
 
 ObCopyMacroBlockHeader::ObCopyMacroBlockHeader()
   : is_reuse_macro_block_(false),
@@ -269,7 +269,7 @@ void ObCopyTabletSSTableInfoArg::reset()
 {
   tablet_id_.reset();
   max_major_sstable_snapshot_ = 0;
-  minor_sstable_scn_range_ .reset();
+  minor_sstable_scn_range_.reset();
   ddl_sstable_scn_range_.reset();
 }
 
@@ -892,7 +892,7 @@ int ObHAFetchMacroBlockP::process()
 
       SMART_VAR(storage::ObCopyMacroBlockObProducer, producer) {
         if (OB_FAIL(producer.init(arg_.tenant_id_, arg_.ls_id_, arg_.table_key_, arg_.copy_macro_range_info_,
-            arg_.data_version_, arg_.backfill_tx_log_ts_))) {
+            arg_.data_version_, arg_.backfill_tx_scn_))) {
           LOG_WARN("failed to init macro block producer", K(ret), K(arg_));
         } else {
 
diff --git a/src/storage/ob_storage_rpc.h b/src/storage/ob_storage_rpc.h
index baa6a39999..7b17caaf68 100644
--- a/src/storage/ob_storage_rpc.h
+++ b/src/storage/ob_storage_rpc.h
@@ -88,12 +88,12 @@ public:
   bool is_valid() const;
   int assign(const ObCopyMacroBlockRangeArg &arg);
 
-  TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(table_key), K_(data_version), K_(backfill_tx_log_ts), K_(copy_macro_range_info));
+  TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(table_key), K_(data_version), K_(backfill_tx_scn), K_(copy_macro_range_info));
   uint64_t tenant_id_;
   share::ObLSID ls_id_;
   storage::ObITable::TableKey table_key_;
   int64_t data_version_;
-  int64_t backfill_tx_log_ts_;
+  palf::SCN backfill_tx_scn_;
   storage::ObCopyMacroRangeInfo copy_macro_range_info_;
   DISALLOW_COPY_AND_ASSIGN(ObCopyMacroBlockRangeArg);
 };
diff --git a/src/storage/ob_storage_struct.cpp b/src/storage/ob_storage_struct.cpp
index 18a8532f79..468bd3c15d 100644
--- a/src/storage/ob_storage_struct.cpp
+++ b/src/storage/ob_storage_struct.cpp
@@ -219,7 +219,7 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
     rebuild_seq_(rebuild_seq),
     update_with_major_flag_(false),
     need_check_sstable_(false),
-    ddl_checkpoint_ts_(0),
+    ddl_checkpoint_scn_(palf::SCN::min_scn()),
     ddl_start_log_ts_(0),
     ddl_snapshot_version_(0)
 {
@@ -244,7 +244,7 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
     rebuild_seq_(rebuild_seq),
     update_with_major_flag_(false),
     need_check_sstable_(need_check_sstable),
-    ddl_checkpoint_ts_(0),
+    ddl_checkpoint_scn_(palf::SCN::min_scn()),
     ddl_start_log_ts_(0),
     ddl_snapshot_version_(0)
 {
@@ -268,7 +268,7 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
     rebuild_seq_(rebuild_seq),
     update_with_major_flag_(update_with_major_flag),
     need_check_sstable_(false),
-    ddl_checkpoint_ts_(0),
+    ddl_checkpoint_scn_(palf::SCN::min_scn()),
     ddl_start_log_ts_(0),
     ddl_snapshot_version_(0)
 {
@@ -293,7 +293,7 @@ ObBatchUpdateTableStoreParam::ObBatchUpdateTableStoreParam()
     need_report_(false),
     rebuild_seq_(OB_INVALID_VERSION),
     update_logical_minor_sstable_(false),
-    start_scn_(0)
+    start_scn_(palf::SCN::min_scn())
 {
 }
 
@@ -305,7 +305,7 @@ void ObBatchUpdateTableStoreParam::reset()
   need_report_ = false;
   rebuild_seq_ = OB_INVALID_VERSION;
   update_logical_minor_sstable_ = false;
-  start_scn_ = 0;
+  start_scn_.set_min();
 }
 
 bool ObBatchUpdateTableStoreParam::is_valid() const
@@ -314,7 +314,7 @@ bool ObBatchUpdateTableStoreParam::is_valid() const
       && multi_version_start_ >= 0
       && OB_NOT_NULL(storage_schema_)
       && rebuild_seq_ > OB_INVALID_VERSION
-      && (!update_logical_minor_sstable_ || (update_logical_minor_sstable_ && start_scn_ > 0));
+      && (!update_logical_minor_sstable_ || (update_logical_minor_sstable_ && start_scn_ > palf::SCN::min_scn()));
 }
 
 int ObBatchUpdateTableStoreParam::assign(
diff --git a/src/storage/ob_storage_struct.h b/src/storage/ob_storage_struct.h
index 4bd5e8a249..b22cd819bf 100644
--- a/src/storage/ob_storage_struct.h
+++ b/src/storage/ob_storage_struct.h
@@ -314,7 +314,7 @@ struct ObUpdateTableStoreParam
   bool is_valid() const;
   TO_STRING_KV(K_(table_handle), K_(snapshot_version), K_(clog_checkpoint_ts), K_(multi_version_start),
                K_(keep_old_ddl_sstable), K_(need_report), KPC_(storage_schema), K_(rebuild_seq), K_(update_with_major_flag),
-               K_(need_check_sstable), K_(ddl_checkpoint_ts), K_(ddl_start_log_ts), K_(ddl_snapshot_version));
+               K_(need_check_sstable), K_(ddl_checkpoint_scn), K_(ddl_start_log_ts), K_(ddl_snapshot_version));
 
   ObTableHandleV2 table_handle_;
   int64_t snapshot_version_;
@@ -326,7 +326,7 @@ struct ObUpdateTableStoreParam
   int64_t rebuild_seq_;
   bool update_with_major_flag_;
   bool need_check_sstable_;
-  int64_t ddl_checkpoint_ts_;
+  palf::SCN ddl_checkpoint_scn_;
   int64_t ddl_start_log_ts_;
   int64_t ddl_snapshot_version_;
 };
@@ -350,7 +350,7 @@ struct ObBatchUpdateTableStoreParam final
   bool need_report_;
   int64_t rebuild_seq_;
   bool update_logical_minor_sstable_;
-  int64_t start_scn_;
+  palf::SCN start_scn_;
 
   DISALLOW_COPY_AND_ASSIGN(ObBatchUpdateTableStoreParam);
 };
diff --git a/src/storage/tablet/ob_tablet.cpp b/src/storage/tablet/ob_tablet.cpp
index 9ccd26140d..5e2a207d1c 100644
--- a/src/storage/tablet/ob_tablet.cpp
+++ b/src/storage/tablet/ob_tablet.cpp
@@ -238,7 +238,7 @@ int ObTablet::init(
       param.multi_version_start_, tx_data, ddl_data, autoinc_seq,
       // use min schema version to avoid lose storage_schema in replay/reboot
       MIN(MAX(param.storage_schema_->schema_version_, old_tablet.storage_schema_.schema_version_), max_sync_schema_version),
-      param.clog_checkpoint_ts_, param.ddl_checkpoint_ts_, param.ddl_start_log_ts_, param.ddl_snapshot_version_))) {
+      param.clog_checkpoint_ts_, param.ddl_checkpoint_scn_.get_val_for_lsn_allocator(), param.ddl_start_log_ts_, param.ddl_snapshot_version_))) {
     LOG_WARN("failed to init tablet meta", K(ret), K(old_tablet), K(param), K(tx_data), K(ddl_data));
   } else if (OB_FAIL(table_store_.init(*allocator_, this, param, old_tablet.table_store_))) {
     LOG_WARN("failed to init table store", K(ret), K(old_tablet));
@@ -1846,12 +1846,12 @@ int ObTablet::try_update_start_scn()
 {
   int ret = OB_SUCCESS;
   ObSSTable *first_minor = static_cast<ObSSTable *>(table_store_.get_minor_sstables().get_boundary_table(false /*first*/));
-  const int64_t start_scn = OB_NOT_NULL(first_minor) ? first_minor->get_start_log_ts() : tablet_meta_.clog_checkpoint_scn_.get_val_for_gts();
-  if (OB_UNLIKELY(start_scn < tablet_meta_.start_scn_.get_val_for_gts())) {
+  const palf::SCN &start_scn = OB_NOT_NULL(first_minor) ? first_minor->get_start_scn() : tablet_meta_.clog_checkpoint_scn_;
+  if (OB_UNLIKELY(start_scn < tablet_meta_.start_scn_)) {
     // ignore ret on purpose
     LOG_WARN("tablet start scn can not fallback", K(start_scn), K(tablet_meta_));
   } else {
-    tablet_meta_.start_scn_.convert_tmp(start_scn);
+    tablet_meta_.start_scn_ = start_scn;
   }
   return ret;
 }
diff --git a/src/storage/tablet/ob_tablet_create_delete_helper.cpp b/src/storage/tablet/ob_tablet_create_delete_helper.cpp
index edc6d8c310..d8e40c23a4 100644
--- a/src/storage/tablet/ob_tablet_create_delete_helper.cpp
+++ b/src/storage/tablet/ob_tablet_create_delete_helper.cpp
@@ -2407,7 +2407,7 @@ int ObTabletCreateDeleteHelper::build_create_sstable_param(
     param.data_checksum_ = 0;
     param.occupy_size_ = 0;
     param.ddl_log_ts_ = 0;
-    param.filled_tx_log_ts_ = 0;
+    param.filled_tx_scn_.set_min();
     param.original_size_ = 0;
     param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
     if (OB_FAIL(ObSSTableMergeRes::fill_column_checksum_for_empty_major(param.column_cnt_,
@@ -2465,7 +2465,7 @@ int ObTabletCreateDeleteHelper::build_create_sstable_param(
     param.data_checksum_ = 0;
     param.occupy_size_ = 0;
     param.ddl_log_ts_ = 0;
-    param.filled_tx_log_ts_ = 0;
+    param.filled_tx_scn_.set_min();
     param.original_size_ = 0;
     param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
     if (OB_FAIL(ObSSTableMergeRes::fill_column_checksum_for_empty_major(param.column_cnt_,
diff --git a/src/storage/tablet/ob_tablet_create_sstable_param.cpp b/src/storage/tablet/ob_tablet_create_sstable_param.cpp
index 7f05f1ef82..9442b14daa 100644
--- a/src/storage/tablet/ob_tablet_create_sstable_param.cpp
+++ b/src/storage/tablet/ob_tablet_create_sstable_param.cpp
@@ -51,7 +51,7 @@ ObTabletCreateSSTableParam::ObTabletCreateSSTableParam()
     original_size_(0),
     max_merged_trans_version_(0),
     ddl_log_ts_(0),
-    filled_tx_log_ts_(0),
+    filled_tx_scn_(palf::SCN::min_scn()),
     contain_uncommitted_row_(false),
     compressor_type_(ObCompressorType::INVALID_COMPRESSOR),
     encrypt_id_(0),
@@ -85,14 +85,14 @@ bool ObTabletCreateSSTableParam::is_valid() const
                && column_cnt_ >= 0
                && occupy_size_ >= 0
                && ddl_log_ts_ > OB_INVALID_TIMESTAMP
-               && filled_tx_log_ts_ > OB_INVALID_TIMESTAMP
+               && filled_tx_scn_.is_valid()
                && original_size_ >= 0)) {
     ret = false;
     LOG_WARN("invalid basic params", K(schema_version_), K(create_snapshot_version_), K(index_type_),
              K(root_row_store_type_), K(data_index_tree_height_), K(index_blocks_cnt_),
              K(data_blocks_cnt_), K(micro_block_cnt_), K(use_old_macro_block_count_),
              K(row_count_), K(rowkey_column_cnt_), K(column_cnt_), K(occupy_size_),
-             K(original_size_), K(ddl_log_ts_), K(filled_tx_log_ts_));
+             K(original_size_), K(ddl_log_ts_), K(filled_tx_scn_));
   } else if (ObITable::is_ddl_sstable(table_key_.table_type_)) {
     // ddl sstable can have invalid meta addr, so skip following ifs
   } else if (!is_block_meta_valid(root_block_addr_, root_block_data_)) {
diff --git a/src/storage/tablet/ob_tablet_create_sstable_param.h b/src/storage/tablet/ob_tablet_create_sstable_param.h
index 7f2c2aa6db..68519e19c4 100644
--- a/src/storage/tablet/ob_tablet_create_sstable_param.h
+++ b/src/storage/tablet/ob_tablet_create_sstable_param.h
@@ -97,7 +97,7 @@ public:
   int64_t original_size_;
   int64_t max_merged_trans_version_;
   int64_t ddl_log_ts_;
-  int64_t filled_tx_log_ts_;
+  palf::SCN filled_tx_scn_;
   bool contain_uncommitted_row_;
   common::ObCompressorType compressor_type_;
   int64_t encrypt_id_;
diff --git a/src/storage/tablet/ob_tablet_meta.cpp b/src/storage/tablet/ob_tablet_meta.cpp
index fee8edd894..da55b107d2 100644
--- a/src/storage/tablet/ob_tablet_meta.cpp
+++ b/src/storage/tablet/ob_tablet_meta.cpp
@@ -17,6 +17,7 @@
 #include "lib/ob_define.h"
 #include "lib/utility/serialization.h"
 #include "share/schema/ob_table_schema.h"
+#include "logservice/palf/scn.h"
 
 namespace oceanbase
 {
diff --git a/src/storage/tablet/ob_tablet_table_store.cpp b/src/storage/tablet/ob_tablet_table_store.cpp
index 055737419a..9bee02c731 100644
--- a/src/storage/tablet/ob_tablet_table_store.cpp
+++ b/src/storage/tablet/ob_tablet_table_store.cpp
@@ -1564,7 +1564,7 @@ int ObTabletTableStore::update_ha_minor_sstables_(
   ObArray<ObITable *> new_minor_tables;
   const ObSSTableArray &old_minor_tables = old_store.get_minor_sstables();
 
-  if (param.start_scn_ >= tablet_ptr_->get_clog_checkpoint_ts()) {
+  if (param.start_scn_ >= tablet_ptr_->get_clog_checkpoint_scn()) {
     //no need keep local minor sstable
     LOG_INFO("start scn is bigger than clog checkpoint ts, no need keep local minor sstable", K(old_store));
   } else {
@@ -1572,7 +1572,7 @@ int ObTabletTableStore::update_ha_minor_sstables_(
     bool found = false;
     for (int64_t i = 0; i < old_minor_tables.count_; ++i) {
       const ObITable *table = old_minor_tables[i];
-      if (table->get_start_log_ts() <= param.start_scn_ && table->get_end_log_ts() > param.start_scn_) {
+      if (table->get_start_scn() <= param.start_scn_ && table->get_end_scn() > param.start_scn_) {
         index = i;
         found = true;
         break;
@@ -1593,7 +1593,7 @@ int ObTabletTableStore::update_ha_minor_sstables_(
         ObSSTable *sstable = static_cast<ObSSTable *>(table);
         share::ObScnRange new_scn_range;
         share::ObScnRange original_scn_range = sstable->get_scn_range();
-        new_scn_range.start_scn_.convert_for_gts(param.start_scn_); //TODO(SCN) fix start_scn with SCN
+        new_scn_range.start_scn_ = param.start_scn_;
         new_scn_range.end_scn_ = table->get_end_scn();
         sstable->set_scn_range(new_scn_range);
         LOG_INFO("cut ha remote logical sstable log ts range", KPC(sstable), K(new_scn_range), K(original_scn_range));
diff --git a/unittest/storage/blocksstable/test_sstable_meta.cpp b/unittest/storage/blocksstable/test_sstable_meta.cpp
index ead6889e67..706174ffdc 100644
--- a/unittest/storage/blocksstable/test_sstable_meta.cpp
+++ b/unittest/storage/blocksstable/test_sstable_meta.cpp
@@ -256,7 +256,7 @@ void TestSSTableMeta::prepare_create_sstable_param()
   param_.data_checksum_ = 0;
   param_.occupy_size_ = 0;
   param_.ddl_log_ts_ = 0;
-  param_.filled_tx_log_ts_ = 0;
+  param_.filled_tx_scn_.set_min();
   param_.original_size_ = 0;
   param_.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
   param_.encrypt_id_ = 0;
@@ -558,7 +558,7 @@ TEST_F(TestMigrationSSTableParam, test_migrate_sstable)
   src_sstable_param.data_checksum_ = 0;
   src_sstable_param.occupy_size_ = 0;
   src_sstable_param.ddl_log_ts_ = 0;
-  src_sstable_param.filled_tx_log_ts_ = 0;
+  src_sstable_param.filled_tx_scn_.set_min();
   src_sstable_param.original_size_ = 0;
   src_sstable_param.compressor_type_ = ObCompressorType::NONE_COMPRESSOR;
   src_sstable_param.encrypt_id_ = 1234;