Improvements on TStorage and TBank

src/core/UBlockChain.pas

@@ -25,7 +25,7 @@ unit UBlockChain;
 interface
 
 uses
-  Classes, UCrypto, UAccounts, ULog, UThread, SyncObjs, UBaseTypes, SysUtils,
+  Classes,{$IFnDEF FPC}Windows,{$ENDIF}UCrypto, UAccounts, ULog, UThread, SyncObjs, UBaseTypes, SysUtils,
   {$IFNDEF FPC}System.Generics.Collections{$ELSE}Generics.Collections{$ENDIF},
   {$IFDEF USE_ABSTRACTMEM}UPCAbstractMem,{$ENDIF}
   UPCDataTypes, UChunk;
@@ -484,25 +484,20 @@ Type
 
   TStorage = Class(TComponent)
   private
-    FOrphan: TOrphan;
     FBank : TPCBank;
     FReadOnly: Boolean;
     procedure SetBank(const Value: TPCBank);
   protected
     FIsMovingBlockchain : Boolean;
-    procedure SetOrphan(const Value: TOrphan); virtual;
     procedure SetReadOnly(const Value: Boolean); virtual;
     Function DoLoadBlockChain(Operations : TPCOperationsComp; Block : Cardinal) : Boolean; virtual; abstract;
     Function DoSaveBlockChain(Operations : TPCOperationsComp) : Boolean; virtual; abstract;
     Function DoMoveBlockChain(StartBlock : Cardinal; Const DestOrphan : TOrphan; DestStorage : TStorage) : Boolean; virtual; abstract;
-    Function DoSaveBank : Boolean; virtual; abstract;
-    Function DoRestoreBank(max_block : Int64; restoreProgressNotify : TProgressNotify) : Boolean; virtual; abstract;
     Procedure DoDeleteBlockChainBlocks(StartingDeleteBlock : Cardinal); virtual; abstract;
     Function DoBlockExists(Block : Cardinal) : Boolean; virtual; abstract;
     function GetFirstBlockNumber: Int64; virtual; abstract;
     function GetLastBlockNumber: Int64; virtual; abstract;
     function DoInitialize:Boolean; virtual; abstract;
-    Function DoOpenSafeBoxCheckpoint(blockCount : Cardinal) : TCheckPointStruct; virtual; abstract;
     Procedure DoEraseStorage; virtual; abstract;
     Procedure DoSavePendingBufferOperations(OperationsHashTree : TOperationsHashTree); virtual; abstract;
     Procedure DoLoadPendingBufferOperations(OperationsHashTree : TOperationsHashTree); virtual; abstract;
@@ -511,19 +506,13 @@ Type
     Function SaveBlockChainBlock(Operations : TPCOperationsComp) : Boolean;
     Function MoveBlockChainBlocks(StartBlock : Cardinal; Const DestOrphan : TOrphan; DestStorage : TStorage) : Boolean;
     Procedure DeleteBlockChainBlocks(StartingDeleteBlock : Cardinal);
-    Function SaveBank(forceSave : Boolean) : Boolean;
-    Function RestoreBank(max_block : Int64; restoreProgressNotify : TProgressNotify = Nil) : Boolean;
     Constructor Create(AOwner : TComponent); Override;
-    Property Orphan : TOrphan read FOrphan write SetOrphan;
     Property ReadOnly : Boolean read FReadOnly write SetReadOnly;
     Property Bank : TPCBank read FBank write SetBank;
     Procedure CopyConfiguration(Const CopyFrom : TStorage); virtual;
     Property FirstBlock : Int64 read GetFirstBlockNumber;
     Property LastBlock : Int64 read GetLastBlockNumber;
     Function Initialize : Boolean;
-    Function OpenSafeBoxCheckpoint(blockCount : Cardinal) : TCheckPointStruct;
-    Function HasUpgradedToVersion2 : Boolean; virtual; abstract;
-    Procedure CleanupVersion1Data; virtual; abstract;
     Procedure EraseStorage; // Erase Blockchain storage
     Procedure SavePendingBufferOperations(OperationsHashTree : TOperationsHashTree);
     Procedure LoadPendingBufferOperations(OperationsHashTree : TOperationsHashTree);
@@ -541,13 +530,14 @@ Type
     FLastBlockCache : TPCOperationsComp;
     FLastOperationBlock: TOperationBlock;
     FIsRestoringFromFile: Boolean;
-    FUpgradingToV2: Boolean;
     FOnLog: TPCBankLog;
     FBankLock: TPCCriticalSection;
     FNotifyList : TList<TPCBankNotify>;
     FStorageClass: TStorageClass;
+    FOrphan: TOrphan;
     function GetStorage: TStorage;
     procedure SetStorageClass(const Value: TStorageClass);
+    Function DoSaveBank : Boolean;
   public
     Constructor Create(AOwner: TComponent); Override;
     Destructor Destroy; Override;
@@ -572,10 +562,18 @@ Type
     Property StorageClass : TStorageClass read FStorageClass write SetStorageClass;
     Function IsReady(Var CurrentProcess : String) : Boolean;
     Property LastBlockFound : TPCOperationsComp read FLastBlockCache;
-    Property UpgradingToV2 : Boolean read FUpgradingToV2;
+    Function OpenSafeBoxCheckpoint(ABlockCount : Cardinal) : TCheckPointStruct;
+    Class Function GetSafeboxCheckpointingFileName(Const ABaseDataFolder : String; ABlock : Cardinal) : String;
+    Class Function GetStorageFolder(Const AOrphan : String) : String;
+    Function RestoreBank(AMax_block : Int64; AOrphan : String; ARestoreProgressNotify : TProgressNotify) : Boolean;
+    Function LoadBankFileInfo(Const AFilename : String; var ASafeBoxHeader : TPCSafeBoxHeader) : Boolean;
+    Property Orphan : TOrphan read FOrphan write FOrphan;
+    Function SaveBank(forceSave : Boolean) : Boolean;
   End;
 
 Const
+  CT_Safebox_Extension = {$IFDEF USE_ABSTRACTMEM}'.am_safebox'{$ELSE}'.safebox'{$ENDIF};
+
   CT_TOperationPayload_NUL : TOperationPayload = (payload_type:0;payload_raw:Nil);
   CT_TOperationResume_NUL : TOperationResume = (valid:false;Block:0;NOpInsideBlock:-1;OpType:0;OpSubtype:0;time:0;AffectedAccount:0;SignerAccount:-1;n_operation:0;DestAccount:-1;SellerAccount:-1;newKey:(EC_OpenSSL_NID:0;x:Nil;y:Nil);OperationTxt:'';Amount:0;Fee:0;Balance:0;OriginalPayload:(payload_type:0;payload_raw:nil);PrintablePayload:'';DecodedEPasaPayload:'';OperationHash:Nil;OperationHash_OLD:Nil;errors:'';isMultiOperation:False;Senders:Nil;Receivers:Nil;changers:Nil);
   CT_TMultiOpSender_NUL : TMultiOpSender =  (Account:0;Amount:0;N_Operation:0;Payload:(payload_type:0;payload_raw:Nil);Signature:(r:Nil;s:Nil));
@@ -591,7 +589,8 @@ uses
   Variants,
   UTime, UConst, UOpTransaction, UPCOrderedLists,
   UPCOperationsSignatureValidator,
-  UPCOperationsBlockValidator;
+  UPCOperationsBlockValidator,
+  UNode;
 
 { TPCOperationsStorage }
 
@@ -899,7 +898,6 @@ begin
   FNotifyList := TList<TPCBankNotify>.Create;
   FLastBlockCache := TPCOperationsComp.Create(Nil);
   FIsRestoringFromFile:=False;
-  FUpgradingToV2:=False;
   Clear;
 end;
 
@@ -948,7 +946,6 @@ begin
   LStartProcessTC := tc;
   TPCThread.ProtectEnterCriticalSection(Self,FBankLock);
   try
-    FUpgradingToV2 := NOT Storage.HasUpgradedToVersion2;
     FIsRestoringFromFile := true;
     try
       Clear;
@@ -956,7 +953,7 @@ begin
       If (max_block<Storage.LastBlock) or (Storage.LastBlock<0) then n := max_block
       else n := Storage.LastBlock;
 
-      Storage.RestoreBank(n,restoreProgressNotify);
+      RestoreBank(n,Orphan,restoreProgressNotify);
       // Restore last blockchain
       if (BlocksCount>0) And (SafeBox.CurrentProtocol=CT_PROTOCOL_1) then begin
         if Not Storage.LoadBlockChainBlock(FLastBlockCache,BlocksCount-1) then begin
@@ -972,7 +969,7 @@ begin
         FLastOperationBlock.initial_safe_box_hash := TPCSafeBox.InitialSafeboxHash; // Genesis hash
       end;
 
-      NewLog(Nil, ltinfo,'Start restoring from disk operations (Max '+inttostr(max_block)+') BlockCount: '+inttostr(BlocksCount)+' Orphan: ' +Storage.Orphan);
+      NewLog(Nil, ltinfo,'Start restoring from disk operations (Max '+inttostr(max_block)+') BlockCount: '+inttostr(BlocksCount)+' Orphan: ' +Orphan);
       LBlocks := TList<TPCOperationsComp>.Create;
       try
         LProgressBlock := 0;
@@ -1022,7 +1019,7 @@ begin
                 // To prevent continuous saving...
                 if ((BlocksCount+(CT_BankToDiskEveryNBlocks*2)) >= Storage.LastBlock ) or
                    ((BlocksCount MOD (CT_BankToDiskEveryNBlocks*10))=0) then begin
-                  Storage.SaveBank(False);
+                  SaveBank(False);
                 end;
                 if (Assigned(restoreProgressNotify)) And (TPlatform.GetElapsedMilliseconds(tc)>1000) then begin
                   tc := TPlatform.GetTickCount;
@@ -1042,13 +1039,11 @@ begin
 
       finally
         LBlocks.Free;
-        if FUpgradingToV2 then Storage.CleanupVersion1Data;
-        NewLog(Nil, ltinfo,'End restoring from disk operations (Max '+inttostr(max_block)+') Orphan: ' + Storage.Orphan+' Restored '+Inttostr(BlocksCount)+' blocks in '+IntToStr(TPlatform.GetElapsedMilliseconds(LStartProcessTC))+' milliseconds');
+        NewLog(Nil, ltinfo,'End restoring from disk operations (Max '+inttostr(max_block)+') Orphan: ' + Orphan+' Restored '+Inttostr(BlocksCount)+' blocks in '+IntToStr(TPlatform.GetElapsedMilliseconds(LStartProcessTC))+' milliseconds');
       end;
 
     finally
       FIsRestoringFromFile := False;
-      FUpgradingToV2 := false;
       for i := 0 to FNotifyList.Count - 1 do begin
         TPCBankNotify(FNotifyList.Items[i]).NotifyNewBlock;
       end;
@@ -1061,6 +1056,60 @@ begin
   end;
 end;
 
+function TPCBank.DoSaveBank: Boolean;
+var fs: TFileStream;
+    LBankfilename,Laux_newfilename: AnsiString;
+    ms : TMemoryStream;
+  LTC : TTickCount;
+begin
+  Result := true;
+  LBankfilename := GetSafeboxCheckpointingFileName(GetStorageFolder(Orphan),BlocksCount);
+  if (LBankfilename<>'') then begin
+    LTC := TPlatform.GetTickCount;
+    {$IFDEF USE_ABSTRACTMEM}
+    SafeBox.SaveCheckpointing(LBankfilename);
+    {$ELSE}
+    fs := TFileStream.Create(bankfilename,fmCreate);
+    try
+      fs.Size := 0;
+      fs.Position:=0;
+      if LowMemoryUsage then begin
+        Bank.SafeBox.SaveSafeBoxToAStream(fs,0,Bank.SafeBox.BlocksCount-1);
+      end else begin
+        ms := TMemoryStream.Create;
+        try
+          Bank.SafeBox.SaveSafeBoxToAStream(ms,0,Bank.SafeBox.BlocksCount-1);
+          ms.Position := 0;
+          fs.CopyFrom(ms,0);
+        finally
+          ms.Free;
+        end;
+      end;
+    finally
+      fs.Free;
+    end;
+    {$ENDIF}
+    TLog.NewLog(ltInfo,ClassName,Format('Saving Safebox blocks:%d file:%s in %.2n seconds',[BlocksCount,LBankfilename,TPlatform.GetElapsedMilliseconds(LTC)/1000]));
+    // Save a copy each 10000 blocks (aprox 1 month) only when not an orphan
+    if (Orphan='') And ((BlocksCount MOD (CT_BankToDiskEveryNBlocks*100))=0) then begin
+      Laux_newfilename := GetStorageFolder('') + PathDelim+'checkpoint_'+ inttostr(BlocksCount)+CT_Safebox_Extension;
+      try
+        {$IFDEF FPC}
+        DoCopyFile(bankfilename,aux_newfilename);
+        {$ELSE}
+        CopyFile(PWideChar(LBankfilename),PWideChar(Laux_newfilename),False);
+        {$ENDIF}
+      Except
+        On E:Exception do begin
+          TLog.NewLog(lterror,ClassName,'Exception copying extra safebox file '+Laux_newfilename+' ('+E.ClassName+'):'+E.Message);
+        end;
+      end;
+    end;
+  end;
+
+
+end;
+
 procedure TPCBank.UpdateValuesFromSafebox;
 Var aux : String;
   i : Integer;
@@ -1181,6 +1230,21 @@ begin
   end;
 end;
 
+Const CT_SafeboxsToStore = 10;
+
+class function TPCBank.GetSafeboxCheckpointingFileName(
+  const ABaseDataFolder: String; ABlock: Cardinal): String;
+begin
+  Result := '';
+  If not ForceDirectories(ABaseDataFolder) then exit;
+  if TPCSafeBox.MustSafeBoxBeSaved(ABlock) then begin
+    // We will store checkpointing
+    Result := ABaseDataFolder + PathDelim+'checkpoint'+ inttostr((ABlock DIV CT_BankToDiskEveryNBlocks) MOD CT_SafeboxsToStore)+CT_Safebox_Extension;
+  end else begin
+    Result := ABaseDataFolder + PathDelim+'checkpoint_'+inttostr(ABlock)+CT_Safebox_Extension;
+  end;
+end;
+
 function TPCBank.GetStorage: TStorage;
 begin
   if Not Assigned(FStorage) then begin
@@ -1191,18 +1255,41 @@ begin
   Result := FStorage;
 end;
 
+class function TPCBank.GetStorageFolder(const AOrphan: String): String;
+var Lbase : String;
+begin
+  Lbase := TNode.GetPascalCoinDataFolder + PathDelim + 'Data';
+  if Lbase = '' then raise Exception.Create('No Database Folder');
+  if AOrphan<>'' then Result := Lbase + PathDelim+AOrphan
+  else Result := Lbase;
+  if not ForceDirectories(Result) then raise Exception.Create('Cannot create storage folder: '+Result);
+end;
+
 function TPCBank.IsReady(var CurrentProcess: String): Boolean;
 begin
   Result := false;
   CurrentProcess := '';
   if FIsRestoringFromFile then begin
-    if FUpgradingToV2 then
-      CurrentProcess := 'Migrating to version 2 format'
-    else
-      CurrentProcess := 'Restoring from file'
+    CurrentProcess := 'Restoring from file';
   end else Result := true;
 end;
 
+function TPCBank.LoadBankFileInfo(const AFilename: String;
+  var ASafeBoxHeader: TPCSafeBoxHeader): Boolean;
+var fs: TFileStream;
+begin
+  Result := false;
+  ASafeBoxHeader := CT_PCSafeBoxHeader_NUL;
+  If Not FileExists(AFilename) then exit;
+  fs := TFileStream.Create(AFilename,fmOpenRead);
+  try
+    fs.Position:=0;
+    Result := SafeBox.LoadSafeBoxStreamHeader(fs,ASafeBoxHeader);
+  finally
+    fs.Free;
+  end;
+end;
+
 function TPCBank.LoadBankFromChunks(AChunks : TPCSafeboxChunks;
   checkSafeboxHash: TRawBytes; previousCheckedSafebox: TPCSafebox;
   progressNotify: TProgressNotify; var errors: String): Boolean;
@@ -1324,6 +1411,132 @@ begin
     FOnLog(Self, Operations, Logtype, Logtxt);
 end;
 
+function TPCBank.OpenSafeBoxCheckpoint(ABlockCount: Cardinal): TCheckPointStruct;
+var fn : TFilename;
+  err : AnsiString;
+begin
+  Result := Nil;
+  fn := GetSafeboxCheckpointingFileName(GetStorageFolder(''),ABlockCount);
+  If (fn<>'') and (FileExists(fn)) then begin
+    {$IFDEF USE_ABSTRACTMEM}
+    Result := TPCAbstractMem.Create(fn,True);
+    {$ELSE}
+    Result := TFileStream.Create(fn,fmOpenRead+fmShareDenyWrite);
+    {$ENDIF}
+  end;
+  If Not Assigned(Result) then begin
+    err := 'Cannot load SafeBoxStream (block:'+IntToStr(ABlockCount)+') file:'+fn;
+    TLog.NewLog(ltError,ClassName,err);
+  end;
+end;
+
+function TPCBank.RestoreBank(AMax_block: Int64; AOrphan : String;
+  ARestoreProgressNotify: TProgressNotify): Boolean;
+var
+    sr: TSearchRec;
+    FileAttrs: Integer;
+    folder : AnsiString;
+    Lfilename,auxfn : AnsiString;
+    fs : TFileStream;
+    errors : String;
+    LBlockscount : Cardinal;
+    sbHeader, goodSbHeader : TPCSafeBoxHeader;
+    {$IFDEF USE_ABSTRACTMEM}
+    LTempBlocksCount : Integer;
+    LSafeboxFileName : String;
+    {$ELSE}
+    {$ENDIF}
+begin
+  FBankLock.Acquire;
+  Try
+    {$IFDEF USE_ABSTRACTMEM}
+    Lfilename := '';
+    LSafeboxFileName := GetStorageFolder(AOrphan)+PathDelim+'safebox'+CT_Safebox_Extension;
+    if TPCAbstractMem.AnalyzeFile(LSafeboxFileName,LTempBlocksCount) then begin
+      LBlockscount := LTempBlocksCount;
+    end else begin
+      LBlockscount := 0;
+    end;
+    //
+    FileAttrs := faArchive;
+    folder := GetStorageFolder(''); /// Without Orphan folder
+    if SysUtils.FindFirst(folder+PathDelim+'checkpoint*'+CT_Safebox_Extension, FileAttrs, sr) = 0 then begin
+      repeat
+        if (sr.Attr and FileAttrs) = FileAttrs then begin
+          auxfn := folder+PathDelim+sr.Name;
+          if TPCAbstractMem.AnalyzeFile(auxfn,LTempBlocksCount) then begin
+            if (((AMax_block<0) Or (LTempBlocksCount<=AMax_block)) AND (LTempBlocksCount>LBlockscount)) then begin
+              Lfilename := auxfn;
+              LBlockscount := LTempBlocksCount;
+            end;
+          end;
+        end;
+      until FindNext(sr) <> 0;
+      FindClose(sr);
+    end;
+    if (Lfilename='') then begin
+      SafeBox.SetSafeboxFileName(LSafeboxFileName);
+    end else begin
+      SafeBox.SetSafeboxFileName(Lfilename);
+      SafeBox.UpdateSafeboxFileName(LSafeboxFileName);
+    end;
+    {$ELSE}
+    LBlockscount := 0;
+    {$ENDIF}
+    FileAttrs := faArchive;
+    folder := GetStorageFolder(AOrphan);
+    Lfilename := '';
+    if SysUtils.FindFirst(folder+PathDelim+'*.safebox', FileAttrs, sr) = 0 then begin
+      repeat
+        if (sr.Attr and FileAttrs) = FileAttrs then begin
+          auxfn := folder+PathDelim+sr.Name;
+          If LoadBankFileInfo(auxfn,sbHeader) then begin
+            if (((AMax_block<0) Or (sbHeader.endBlock<=AMax_block)) AND (sbHeader.blocksCount>LBlockscount)) And
+              (sbHeader.startBlock=0) And (sbHeader.endBlock=sbHeader.startBlock+sbHeader.blocksCount-1) then begin
+              Lfilename := auxfn;
+              LBlockscount := sbHeader.blocksCount;
+              goodSbHeader := sbHeader;
+            end;
+          end;
+        end;
+      until FindNext(sr) <> 0;
+      FindClose(sr);
+    end;
+    if (Lfilename<>'') then begin
+      TLog.NewLog(ltinfo,Self.ClassName,'Loading SafeBox protocol:'+IntToStr(goodSbHeader.protocol)+' with '+inttostr(LBlockscount)+' blocks from file '+Lfilename);
+      fs := TFileStream.Create(Lfilename,fmOpenRead);
+      try
+        fs.Position := 0;
+        if not LoadBankFromStream(fs,False,Nil,Nil,ARestoreProgressNotify,errors) then begin
+          TLog.NewLog(lterror,ClassName,'Error reading bank from file: '+Lfilename+ ' Error: '+errors);
+        end;
+      finally
+        fs.Free;
+      end;
+    end;
+  Finally
+    FBankLock.Release;
+  End;
+end;
+
+function TPCBank.SaveBank(forceSave: Boolean): Boolean;
+begin
+  Result := true;
+  If Storage.FIsMovingBlockchain then Exit;
+  if (Not forceSave) AND (Not TPCSafeBox.MustSafeBoxBeSaved(BlocksCount)) then exit; // No save
+  Try
+    Result := DoSaveBank;
+    {$IFnDEF USE_ABSTRACTMEM}
+    SafeBox.CheckMemory;
+    {$ENDIF}
+  Except
+    On E:Exception do begin
+      TLog.NewLog(lterror,Classname,'Error saving Bank: '+E.Message);
+      Raise;
+    end;
+  End;
+end;
+
 procedure TPCBank.SetStorageClass(const Value: TStorageClass);
 begin
   if FStorageClass=Value then exit;
@@ -3004,13 +3217,11 @@ end;
 
 procedure TStorage.CopyConfiguration(const CopyFrom: TStorage);
 begin
-  Orphan := CopyFrom.Orphan;
 end;
 
 constructor TStorage.Create(AOwner: TComponent);
 begin
   inherited;
-  FOrphan := '';
   FReadOnly := false;
   FIsMovingBlockchain := False;
 end;
@@ -3026,11 +3237,6 @@ begin
   Result := DoInitialize;
 end;
 
-function TStorage.OpenSafeBoxCheckpoint(blockCount: Cardinal): TCheckPointStruct;
-begin
-  Result := DoOpenSafeBoxCheckpoint(blockCount);
-end;
-
 procedure TStorage.EraseStorage;
 begin
   TLog.NewLog(ltInfo,ClassName,'Executing EraseStorage');
@@ -3061,29 +3267,6 @@ begin
   Result := DoMoveBlockChain(StartBlock,DestOrphan,DestStorage);
 end;
 
-function TStorage.RestoreBank(max_block: Int64; restoreProgressNotify : TProgressNotify = Nil): Boolean;
-begin
-  Result := DoRestoreBank(max_block,restoreProgressNotify);
-end;
-
-function TStorage.SaveBank(forceSave : Boolean): Boolean;
-begin
-  Result := true;
-  If FIsMovingBlockchain then Exit;
-  if (Not forceSave) AND (Not TPCSafeBox.MustSafeBoxBeSaved(Bank.BlocksCount)) then exit; // No save
-  Try
-    Result := DoSaveBank;
-    {$IFnDEF USE_ABSTRACTMEM}
-    FBank.SafeBox.CheckMemory;
-    {$ENDIF}
-  Except
-    On E:Exception do begin
-      TLog.NewLog(lterror,Classname,'Error saving Bank: '+E.Message);
-      Raise;
-    end;
-  End;
-end;
-
 function TStorage.SaveBlockChainBlock(Operations: TPCOperationsComp): Boolean;
 begin
   Try
@@ -3102,11 +3285,6 @@ begin
   FBank := Value;
 end;
 
-procedure TStorage.SetOrphan(const Value: TOrphan);
-begin
-  FOrphan := Value;
-end;
-
 procedure TStorage.SetReadOnly(const Value: Boolean);
 begin
   FReadOnly := Value;

src/core/UFileStorage.pas

@@ -41,55 +41,41 @@ Type
 
   TFileStorage = Class(TStorage)
   private
-    FLowMemoryUsage: Boolean;
     FStorageLock : TPCCriticalSection;
     FBlockChainStream : TFileStream;
     FPendingBufferOperationsStream : TFileStream;
     FStreamFirstBlockNumber : Int64;
     FStreamLastBlockNumber : Int64;
     FBlockHeadersFirstBytePosition : TArrayOfInt64;
-    FDatabaseFolder: AnsiString;
     FBlockChainFileName : AnsiString;
     Function StreamReadBlockHeader(Stream: TStream; iBlockHeaders : Integer; BlockHeaderFirstBlock, Block: Cardinal; CanSearchBackward : Boolean; var BlockHeader : TBlockHeader): Boolean;
     Function StreamBlockRead(Stream : TStream; iBlockHeaders : Integer; BlockHeaderFirstBlock, Block : Cardinal; Operations : TPCOperationsComp) : Boolean;
     Function StreamBlockSave(Stream : TStream; iBlockHeaders : Integer; BlockHeaderFirstBlock : Cardinal; Operations : TPCOperationsComp) : Boolean;
-    Function GetFolder(Const AOrphan : TOrphan): AnsiString;
     Function GetBlockHeaderFirstBytePosition(Stream : TStream; Block : Cardinal; CanInitialize : Boolean; var iBlockHeaders : Integer; var BlockHeaderFirstBlock : Cardinal) : Boolean;
     Function GetBlockHeaderFixedSize : Int64;
-    procedure SetDatabaseFolder(const Value: AnsiString);
     Procedure ClearStream;
     Procedure GrowStreamUntilPos(Stream : TStream; newPos : Int64; DeleteDataStartingAtCurrentPos : Boolean);
     Function GetPendingBufferOperationsStream : TFileStream;
   protected
     procedure SetReadOnly(const Value: Boolean); override;
-    procedure SetOrphan(const Value: TOrphan); override;
     Function DoLoadBlockChain(Operations : TPCOperationsComp; Block : Cardinal) : Boolean; override;
     Function DoSaveBlockChain(Operations : TPCOperationsComp) : Boolean; override;
     Function DoMoveBlockChain(Start_Block : Cardinal; Const DestOrphan : TOrphan; DestStorage : TStorage) : Boolean; override;
-    Function DoSaveBank : Boolean; override;
-    Function DoRestoreBank(max_block : Int64; restoreProgressNotify : TProgressNotify) : Boolean; override;
     Procedure DoDeleteBlockChainBlocks(StartingDeleteBlock : Cardinal); override;
     Function DoBlockExists(Block : Cardinal) : Boolean; override;
     Function LockBlockChainStream : TFileStream;
     Procedure UnlockBlockChainStream;
-    Function LoadBankFileInfo(Const Filename : AnsiString; var safeBoxHeader : TPCSafeBoxHeader) : Boolean;
     function GetFirstBlockNumber: Int64; override;
     function GetLastBlockNumber: Int64; override;
     function DoInitialize : Boolean; override;
-    Function DoOpenSafeBoxCheckpoint(blockCount : Cardinal) : TCheckPointStruct; override;
     Procedure DoEraseStorage; override;
     Procedure DoSavePendingBufferOperations(OperationsHashTree : TOperationsHashTree); override;
     Procedure DoLoadPendingBufferOperations(OperationsHashTree : TOperationsHashTree); override;
   public
     Constructor Create(AOwner : TComponent); Override;
     Destructor Destroy; Override;
-    Class Function GetSafeboxCheckpointingFileName(Const BaseDataFolder : AnsiString; block : Cardinal) : AnsiString;
-    Property DatabaseFolder : AnsiString read FDatabaseFolder write SetDatabaseFolder;
     Procedure CopyConfiguration(Const CopyFrom : TStorage); override;
     Procedure SetBlockChainFile(BlockChainFileName : AnsiString);
-    Function HasUpgradedToVersion2 : Boolean; override;
-    Procedure CleanupVersion1Data; override;
-    property LowMemoryUsage : Boolean read FLowMemoryUsage write FLowMemoryUsage;
   End;
 
 implementation
@@ -192,7 +178,7 @@ Var fs : TFileStream;
   fm : Word;
 begin
   If Not Assigned(FPendingBufferOperationsStream) then begin
-    fn := GetFolder(Orphan)+PathDelim+'pendingbuffer.ops';
+    fn := Bank.GetStorageFolder(Bank.Orphan)+PathDelim+'pendingbuffer.ops';
     If FileExists(fn) then fm := fmOpenReadWrite+fmShareExclusive
     else fm := fmCreate+fmShareExclusive;
     Try
@@ -210,16 +196,11 @@ end;
 procedure TFileStorage.CopyConfiguration(const CopyFrom: TStorage);
 begin
   inherited;
-  if CopyFrom is TFileStorage then begin
-    DatabaseFolder := TFileStorage(CopyFrom).DatabaseFolder;
-  end;
 end;
 
 constructor TFileStorage.Create(AOwner: TComponent);
 begin
   inherited;
-  FLowMemoryUsage := False;
-  FDatabaseFolder := '';
   FBlockChainFileName := '';
   FBlockChainStream := Nil;
   SetLength(FBlockHeadersFirstBytePosition,0);
@@ -278,25 +259,6 @@ begin
   End;
 end;
 
-function TFileStorage.DoOpenSafeBoxCheckpoint(blockCount: Cardinal): TCheckPointStruct;
-var fn : TFilename;
-  err : AnsiString;
-begin
-  Result := Nil;
-  fn := GetSafeboxCheckpointingFileName(GetFolder(Orphan),blockCount);
-  If (fn<>'') and (FileExists(fn)) then begin
-    {$IFDEF USE_ABSTRACTMEM}
-    Result := TPCAbstractMem.Create(fn,True);
-    {$ELSE}
-    Result := TFileStream.Create(fn,fmOpenRead+fmShareDenyWrite);
-    {$ENDIF}
-  end;
-  If Not Assigned(Result) then begin
-    err := 'Cannot load SafeBoxStream (block:'+IntToStr(blockCount)+') file:'+fn;
-    TLog.NewLog(ltError,ClassName,err);
-  end;
-end;
-
 procedure TFileStorage.DoEraseStorage;
 Var stream : TStream;
 begin
@@ -389,12 +351,12 @@ function TFileStorage.DoMoveBlockChain(Start_Block: Cardinal; const DestOrphan:
     sourcefn,destfn : AnsiString;
   begin
     FileAttrs := faArchive;
-    folder := GetFolder(Orphan);
-    if SysUtils.FindFirst(GetFolder(Orphan)+PathDelim+'checkpoint*'+CT_Safebox_Extension, FileAttrs, sr) = 0 then begin
+    folder := Bank.GetStorageFolder(Bank.Orphan);
+    if SysUtils.FindFirst(Bank.GetStorageFolder(Bank.Orphan)+PathDelim+'checkpoint*'+CT_Safebox_Extension, FileAttrs, sr) = 0 then begin
       repeat
         if (sr.Attr and FileAttrs) = FileAttrs then begin
-          sourcefn := GetFolder(Orphan)+PathDelim+sr.Name;
-          destfn := GetFolder('')+PathDelim+sr.Name;
+          sourcefn := Bank.GetStorageFolder(Bank.Orphan)+PathDelim+sr.Name;
+          destfn := Bank.GetStorageFolder('')+PathDelim+sr.Name;
           TLog.NewLog(ltInfo,ClassName,'Copying safebox file '+sourcefn+' to '+destfn);
           Try
             DoCopyFile(sourcefn,destfn);
@@ -420,9 +382,7 @@ begin
     try
       if Not assigned(db) then begin
         db := TFileStorage.Create(Nil);
-        db.DatabaseFolder := Self.DatabaseFolder;
         db.Bank := Self.Bank;
-        db.Orphan := DestOrphan;
         db.FStreamFirstBlockNumber := Start_Block;
       end;
       if db is TFileStorage then TFileStorage(db).LockBlockChainStream;
@@ -433,15 +393,15 @@ begin
           b := Start_Block;
           while LoadBlockChainBlock(ops,b) do begin
             inc(b);
-            TLog.NewLog(ltDebug,Classname,'Moving block from "'+Orphan+'" to "'+DestOrphan+'" '+TPCOperationsComp.OperationBlockToText(ops.OperationBlock));
+            TLog.NewLog(ltDebug,Classname,'Moving block from "'+Bank.Orphan+'" to "'+DestOrphan+'" '+TPCOperationsComp.OperationBlockToText(ops.OperationBlock));
             db.SaveBlockChainBlock(ops);
           end;
-          TLog.NewLog(ltdebug,Classname,'Moved blockchain from "'+Orphan+'" to "'+DestOrphan+'" from block '+inttostr(Start_Block)+' to '+inttostr(b-1));
+          TLog.NewLog(ltdebug,Classname,'Moved blockchain from "'+Bank.Orphan+'" to "'+DestOrphan+'" from block '+inttostr(Start_Block)+' to '+inttostr(b-1));
         finally
           ops.Free;
         end;
         // If DestOrphan is empty, then copy possible updated safebox (because, perhaps current saved safebox is from invalid blockchain)
-        if (DestOrphan='') And (Orphan<>'') then begin
+        if (DestOrphan='') And (Bank.Orphan<>'') then begin
           DoCopySafebox;
         end;
       finally
@@ -459,160 +419,6 @@ begin
   End;
 end;
 
-function TFileStorage.DoRestoreBank(max_block: Int64; restoreProgressNotify : TProgressNotify): Boolean;
-var
-    sr: TSearchRec;
-    FileAttrs: Integer;
-    folder : AnsiString;
-    Lfilename,auxfn : AnsiString;
-    fs : TFileStream;
-    ms : TMemoryStream;
-    errors : String;
-    LBlockscount : Cardinal;
-    sbHeader, goodSbHeader : TPCSafeBoxHeader;
-    {$IFDEF USE_ABSTRACTMEM}
-    LTempBlocksCount : Integer;
-    LSafeboxFileName : String;
-    {$ELSE}
-    {$ENDIF}
-begin
-  LockBlockChainStream;
-  Try
-    {$IFDEF USE_ABSTRACTMEM}
-    Lfilename := '';
-    LSafeboxFileName := GetFolder(Orphan)+PathDelim+'safebox'+CT_Safebox_Extension;
-    if TPCAbstractMem.AnalyzeFile(LSafeboxFileName,LTempBlocksCount) then begin
-      LBlockscount := LTempBlocksCount;
-    end else begin
-      LBlockscount := 0;
-    end;
-    //
-    FileAttrs := faArchive;
-    folder := GetFolder(''); /// Without Orphan folder
-    if SysUtils.FindFirst(folder+PathDelim+'checkpoint*'+CT_Safebox_Extension, FileAttrs, sr) = 0 then begin
-      repeat
-        if (sr.Attr and FileAttrs) = FileAttrs then begin
-          auxfn := folder+PathDelim+sr.Name;
-          if TPCAbstractMem.AnalyzeFile(auxfn,LTempBlocksCount) then begin
-            if (((max_block<0) Or (LTempBlocksCount<=max_block)) AND (LTempBlocksCount>LBlockscount)) then begin
-              Lfilename := auxfn;
-              LBlockscount := LTempBlocksCount;
-            end;
-          end;
-        end;
-      until FindNext(sr) <> 0;
-      FindClose(sr);
-    end;
-    if (Lfilename='') then begin
-      Bank.SafeBox.SetSafeboxFileName(LSafeboxFileName);
-    end else begin
-      Bank.SafeBox.SetSafeboxFileName(Lfilename);
-      Bank.SafeBox.UpdateSafeboxFileName(LSafeboxFileName);
-    end;
-    {$ELSE}
-    LBlockscount := 0;
-    {$ENDIF}
-    FileAttrs := faArchive;
-    folder := GetFolder(Orphan);
-    Lfilename := '';
-    if SysUtils.FindFirst(folder+PathDelim+'*.safebox', FileAttrs, sr) = 0 then begin
-      repeat
-        if (sr.Attr and FileAttrs) = FileAttrs then begin
-          auxfn := folder+PathDelim+sr.Name;
-          If LoadBankFileInfo(auxfn,sbHeader) then begin
-            if (((max_block<0) Or (sbHeader.endBlock<=max_block)) AND (sbHeader.blocksCount>LBlockscount)) And
-              (sbHeader.startBlock=0) And (sbHeader.endBlock=sbHeader.startBlock+sbHeader.blocksCount-1) then begin
-              Lfilename := auxfn;
-              LBlockscount := sbHeader.blocksCount;
-              goodSbHeader := sbHeader;
-            end;
-          end;
-        end;
-      until FindNext(sr) <> 0;
-      FindClose(sr);
-    end;
-    if (Lfilename<>'') then begin
-      TLog.NewLog(ltinfo,Self.ClassName,'Loading SafeBox protocol:'+IntToStr(goodSbHeader.protocol)+' with '+inttostr(LBlockscount)+' blocks from file '+Lfilename+' LowMemoryUsage:'+LowMemoryUsage.ToString(True));
-      fs := TFileStream.Create(Lfilename,fmOpenRead);
-      try
-        fs.Position := 0;
-        if LowMemoryUsage then begin
-          if not Bank.LoadBankFromStream(fs,False,Nil,Nil,restoreProgressNotify,errors) then begin
-            TLog.NewLog(lterror,ClassName,'Error reading bank from file: '+Lfilename+ ' Error: '+errors);
-          end;
-        end else begin
-          ms := TMemoryStream.Create;
-          Try
-            ms.CopyFrom(fs,0);
-            ms.Position := 0;
-            if not Bank.LoadBankFromStream(ms,False,Nil,Nil,restoreProgressNotify,errors) then begin
-              TLog.NewLog(lterror,ClassName,'Error reading bank from file: '+Lfilename+ ' Error: '+errors);
-            end;
-          Finally
-            ms.Free;
-          End;
-        end;
-      finally
-        fs.Free;
-      end;
-    end;
-  Finally
-    UnlockBlockChainStream;
-  End;
-end;
-
-function TFileStorage.DoSaveBank: Boolean;
-var fs: TFileStream;
-    bankfilename,aux_newfilename: AnsiString;
-    ms : TMemoryStream;
-  LTC : TTickCount;
-begin
-  Result := true;
-  bankfilename := GetSafeboxCheckpointingFileName(GetFolder(Orphan),Bank.BlocksCount);
-  if (bankfilename<>'') then begin
-    LTC := TPlatform.GetTickCount;
-    {$IFDEF USE_ABSTRACTMEM}
-    Bank.SafeBox.SaveCheckpointing(bankfilename);
-    {$ELSE}
-    fs := TFileStream.Create(bankfilename,fmCreate);
-    try
-      fs.Size := 0;
-      fs.Position:=0;
-      if LowMemoryUsage then begin
-        Bank.SafeBox.SaveSafeBoxToAStream(fs,0,Bank.SafeBox.BlocksCount-1);
-      end else begin
-        ms := TMemoryStream.Create;
-        try
-          Bank.SafeBox.SaveSafeBoxToAStream(ms,0,Bank.SafeBox.BlocksCount-1);
-          ms.Position := 0;
-          fs.CopyFrom(ms,0);
-        finally
-          ms.Free;
-        end;
-      end;
-    finally
-      fs.Free;
-    end;
-    {$ENDIF}
-    TLog.NewLog(ltInfo,ClassName,Format('Saving Safebox blocks:%d file:%s in %.2n seconds',[Bank.BlocksCount,bankfilename,TPlatform.GetElapsedMilliseconds(LTC)/1000]));
-    // Save a copy each 10000 blocks (aprox 1 month) only when not an orphan
-    if (Orphan='') And ((Bank.BlocksCount MOD (CT_BankToDiskEveryNBlocks*100))=0) then begin
-      aux_newfilename := GetFolder('') + PathDelim+'checkpoint_'+ inttostr(Bank.BlocksCount)+CT_Safebox_Extension;
-      try
-        {$IFDEF FPC}
-        DoCopyFile(bankfilename,aux_newfilename);
-        {$ELSE}
-        CopyFile(PWideChar(bankfilename),PWideChar(aux_newfilename),False);
-        {$ENDIF}
-      Except
-        On E:Exception do begin
-          TLog.NewLog(lterror,ClassName,'Exception copying extra safebox file '+aux_newfilename+' ('+E.ClassName+'):'+E.Message);
-        end;
-      end;
-    end;
-  end;
-end;
-
 function TFileStorage.DoSaveBlockChain(Operations: TPCOperationsComp): Boolean;
 Var stream : TStream;
   iBlockHeaders : Integer;
@@ -634,23 +440,11 @@ begin
   Finally
     UnlockBlockChainStream;
   End;
-  if Assigned(Bank) then SaveBank(False);
+  if Assigned(Bank) then Bank.SaveBank(False);
 end;
 
 Const CT_SafeboxsToStore = 10;
 
-class function TFileStorage.GetSafeboxCheckpointingFileName(const BaseDataFolder: AnsiString; block: Cardinal): AnsiString;
-begin
-  Result := '';
-  If not ForceDirectories(BaseDataFolder) then exit;
-  if TPCSafeBox.MustSafeBoxBeSaved(block) then begin
-    // We will store checkpointing
-    Result := BaseDataFolder + PathDelim+'checkpoint'+ inttostr((block DIV CT_BankToDiskEveryNBlocks) MOD CT_SafeboxsToStore)+CT_Safebox_Extension;
-  end else begin
-    Result := BaseDataFolder + PathDelim+'checkpoint_'+inttostr(block)+CT_Safebox_Extension;
-  end;
-end;
-
 function TFileStorage.GetBlockHeaderFirstBytePosition(Stream : TStream; Block: Cardinal; CanInitialize : Boolean; var iBlockHeaders : Integer; var BlockHeaderFirstBlock: Cardinal): Boolean;
 var iPos,start, nCurrBlock : Cardinal;
   bh : TBlockHeader;
@@ -750,34 +544,11 @@ begin
   Result := FStreamFirstBlockNumber;
 end;
 
-function TFileStorage.GetFolder(const AOrphan: TOrphan): AnsiString;
-begin
-  if FDatabaseFolder = '' then raise Exception.Create('No Database Folder');
-  if AOrphan<>'' then Result := FDatabaseFolder + PathDelim+AOrphan
-  else Result := FDatabaseFolder;
-  if not ForceDirectories(Result) then raise Exception.Create('Cannot create database folder: '+Result);
-end;
-
 function TFileStorage.GetLastBlockNumber: Int64;
 begin
   Result := FStreamLastBlockNumber;
 end;
 
-function TFileStorage.LoadBankFileInfo(const Filename: AnsiString; var safeBoxHeader : TPCSafeBoxHeader) : Boolean;
-var fs: TFileStream;
-begin
-  Result := false;
-  safeBoxHeader := CT_PCSafeBoxHeader_NUL;
-  If Not FileExists(Filename) then exit;
-  fs := TFileStream.Create(Filename,fmOpenRead);
-  try
-    fs.Position:=0;
-    Result := Bank.SafeBox.LoadSafeBoxStreamHeader(fs,safeBoxHeader);
-  finally
-    fs.Free;
-  end;
-end;
-
 function TFileStorage.LockBlockChainStream: TFileStream;
   function InitStreamInfo(Stream : TStream; var errors : String) : Boolean;
   Var mem : TStream;
@@ -909,7 +680,7 @@ begin
       if FBlockChainFileName<>'' then begin
         fn := FBlockChainFileName
       end else begin
-        fn := GetFolder(Orphan)+PathDelim+'BlockChainStream.blocks';
+        fn := Bank.GetStorageFolder(Bank.Orphan)+PathDelim+'BlockChainStream.blocks';
       end;
       exists := FileExists(fn);
       if ReadOnly then begin
@@ -941,19 +712,6 @@ begin
   FBlockChainFileName := BlockChainFileName;
 end;
 
-procedure TFileStorage.SetDatabaseFolder(const Value: AnsiString);
-begin
-  if FDatabaseFolder=Value then exit;
-  FDatabaseFolder := Value;
-  ClearStream;
-end;
-
-procedure TFileStorage.SetOrphan(const Value: TOrphan);
-begin
-  inherited;
-  ClearStream;
-end;
-
 procedure TFileStorage.SetReadOnly(const Value: Boolean);
 begin
   inherited;
@@ -1135,24 +893,4 @@ begin
   FStorageLock.Release;
 end;
 
-function TFileStorage.HasUpgradedToVersion2: Boolean;
-var searchRec: TSearchRec;
-begin
-  HasUpgradedToVersion2 := SysUtils.FindFirst( GetFolder(Orphan)+PathDelim+'*'+CT_Safebox_Extension, faArchive, searchRec) = 0;
-  FindClose(searchRec);
-end;
-
-procedure TFileStorage.CleanupVersion1Data;
-var
-  folder : AnsiString;
-  searchRec : TSearchRec;
-begin
-  folder := GetFolder(Orphan);
-  if SysUtils.FindFirst( folder+PathDelim+'*.bank', faArchive, searchRec) = 0 then
-  repeat
-    SysUtils.DeleteFile(folder+PathDelim+searchRec.Name);
-  until FindNext(searchRec) <> 0;
-  FindClose(searchRec);
-end;
-
 end.

src/core/UNetProtocol.pas

@@ -1658,7 +1658,7 @@ Const CT_LogSender = 'GetNewBlockChainFromClient';
     Bank := TPCBank.Create(Nil);
     try
       Bank.StorageClass := TNode.Node.Bank.StorageClass;
-      Bank.Storage.Orphan := TNode.Node.Bank.Storage.Orphan;
+      Bank.Orphan := TNode.Node.Bank.Orphan;
       Bank.Storage.ReadOnly := true;
       Bank.Storage.CopyConfiguration(TNode.Node.Bank.Storage);
 
@@ -1670,18 +1670,18 @@ Const CT_LogSender = 'GetNewBlockChainFromClient';
           Bank.UpdateValuesFromSafebox;
           IsUsingSnapshot := True;
 
-          Bank.Storage.Orphan := FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now));
+          Bank.Orphan := FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now));
           Bank.Storage.ReadOnly := false;
 
         end else begin
           {$IFDEF USE_ABSTRACTMEM}
-          Bank.Storage.Orphan := FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now));
+          Bank.Orphan := FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now));
           Bank.Storage.ReadOnly := false;
           {$ENDIF}
 
           // Restore a part from disk
           Bank.DiskRestoreFromOperations(start_block-1);
-          Bank.Storage.SaveBank(True);
+          Bank.SaveBank(True);
           if (Bank.BlocksCount<start_block) then begin
             TLog.NewLog(lterror,CT_LogSender,Format('No blockchain found start block %d, current %d',[start_block-1,Bank.BlocksCount]));
             start_block := Bank.BlocksCount;
@@ -1695,7 +1695,7 @@ Const CT_LogSender = 'GetNewBlockChainFromClient';
       end;
       start_c := start;
       if Bank.Storage.ReadOnly then begin
-        Bank.Storage.Orphan := FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now));
+        Bank.Orphan := FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now));
         Bank.Storage.ReadOnly := false;
       end;
       // Receive new blocks:
@@ -1772,7 +1772,7 @@ Const CT_LogSender = 'GetNewBlockChainFromClient';
               end;
             end;
             TNode.Node.Bank.Storage.MoveBlockChainBlocks(start_block,Inttostr(start_block)+'_'+FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now)),Nil);
-            Bank.Storage.MoveBlockChainBlocks(start_block,TNode.Node.Bank.Storage.Orphan,TNode.Node.Bank.Storage);
+            Bank.Storage.MoveBlockChainBlocks(start_block,TNode.Node.Bank.Orphan,TNode.Node.Bank.Storage);
             //
             If IsUsingSnapshot then begin
               TLog.NewLog(ltInfo,CT_LogSender,'Commiting new chain to Safebox');
@@ -1971,7 +1971,7 @@ Const CT_LogSender = 'GetNewBlockChainFromClient';
             If Not IsMyBlockchainValid then begin
               TNode.Node.Bank.Storage.EraseStorage;
             end;
-            TNode.Node.Bank.Storage.SaveBank(False);
+            TNode.Node.Bank.SaveBank(False);
             Connection.Send_GetBlocks(TNode.Node.Bank.BlocksCount,100,request_id);
             Result := true;
           end else begin
@@ -2014,16 +2014,16 @@ Const CT_LogSender = 'GetNewBlockChainFromClient';
         newTmpBank := TPCBank.Create(Nil);
         try
           newTmpBank.StorageClass := TNode.Node.Bank.StorageClass;
-          newTmpBank.Storage.Orphan := TNode.Node.Bank.Storage.Orphan;
+          newTmpBank.Orphan := TNode.Node.Bank.Orphan;
           newTmpBank.Storage.ReadOnly := true;
           newTmpBank.Storage.CopyConfiguration(TNode.Node.Bank.Storage);
-          newTmpBank.Storage.Orphan := FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now));
+          newTmpBank.Orphan := FormatDateTime('yyyymmddhhnnss',DateTime2UnivDateTime(now));
           newTmpBank.Storage.ReadOnly := false;
           If newTmpBank.LoadBankFromChunks(LChunks,LSafeboxLastOperationBlock.initial_safe_box_hash,TNode.Node.Bank.SafeBox,OnReadingNewSafeboxProgressNotify,errors) then begin
             TNode.Node.DisableNewBlocks;
             try
               TLog.NewLog(ltInfo,ClassName,'Received new safebox!');
-              newTmpBank.Storage.SaveBank(True); // Saving bank
+              newTmpBank.SaveBank(True); // Saving bank
               // Receive at least 1 new block
               blocksList := TList<TPCOperationsComp>.Create;
               try
@@ -3182,7 +3182,7 @@ begin
   responseStream := TMemoryStream.Create;
   try
     {$IFDEF USE_ABSTRACTMEM}
-    Labstracmem := TNode.Node.Bank.Storage.OpenSafeBoxCheckpoint(_blockcount);
+    Labstracmem := TNode.Node.Bank.OpenSafeBoxCheckpoint(_blockcount);
     try
       If Not Assigned(Labstracmem) then begin
         SendError(ntp_response,HeaderData.operation,CT_NetError_SafeboxNotFound,HeaderData.request_id,Format('Safebox stream file for block %d not found',[_blockcount]));