mining procedures -> TRawBytes

src/core/UGPUMining.pas

@@ -318,14 +318,13 @@ procedure TGPUDeviceThread.UpdateBuffers;
 Var stateforlastchunk : TSHA256HASH;
   bufferForLastChunk : TChunk;
   i : Integer;
-  canWork : Boolean;
-  s,s2 : AnsiString;
+  digest,raw : TBytes;
   b : Byte;
   c1,c2 : Cardinal;
 begin
   FLock.Acquire;
   try
-    FReadyToGPU := (MinerValuesForWork.part1<>'') And (Assigned(FDCLKernel));
+    FReadyToGPU := (Length(MinerValuesForWork.part1)>0) And (Assigned(FDCLKernel));
     if (FReadyToGPU) And (TPoolMinerThread.UseRandomHash(MinerValuesForWork.version)) then begin
       // V4 RandomHash not available on GPU mining
       FReadyToGPU:=False;
@@ -335,14 +334,10 @@ begin
       IsMining := false;
       exit;
     end;
-    Repeat
-      i := Length(MinerValuesForWork.part1)+Length(MinerValuesForWork.payload_start)+Length(MinerValuesForWork.part3)+8;
-      canWork := CanBeModifiedOnLastChunk(i,FChangeTimestampAndNOnceBytePos);
-      If Not canWork then FMinerValuesForWork.payload_start:=MinerValuesForWork.payload_start+'.';
-    until (canWork);
+    UpdateMinerValuesForWorkLength(FMinerValuesForWork,FChangeTimestampAndNOnceBytePos);
     FillChar(FKernelArg1[0],29*4,#0);
-    s := MinerValuesForWork.part1+MinerValuesForWork.payload_start+MinerValuesForWork.part3+'00000000';
-    PascalCoinPrepareLastChunk(s,stateforlastchunk,bufferForLastChunk);
+    CreateDigest(MinerValuesForWork,0,0,digest);
+    PascalCoinPrepareLastChunk(digest,stateforlastchunk,bufferForLastChunk);
     // FKernelArg1[0..15] = data for last chunk
     move(bufferForLastChunk[0],FKernelArg1[0],16*4);
     For i:=0 to 15 do begin
@@ -354,15 +349,14 @@ begin
     // FKernelArg1[25] = high-order 12 bits for nOnce (see .cl file to know)
     // FKernelArg1[26..28] = Mask (obtained  from target_pow)
     FillChar(FKernelArg1[26],4*3,#0);
-    s := MinerValuesForWork.target_pow;
-    i := 1;
-    while (length(s)>=i) And (i<=4*3) do begin
-      b := Byte(s[i]);
+    i := 0;
+    while (High(MinerValuesForWork.target_pow)>=i) And (i<4*3) do begin
+      b := MinerValuesForWork.target_pow[i];
       b := b XOR $FF;
-      c1 := FKernelArg1[26+((i-1) DIV 4)]; // Last value
-      c2 := b SHL (((4-i) MOD 4)*8);
+      c1 := FKernelArg1[26+(i DIV 4)]; // Last value
+      c2 := b SHL ((3-(i MOD 4))*8);
       c2 := c1 OR c2;
-      FKernelArg1[26+((i-1) DIV 4)] := c2;
+      FKernelArg1[26+(i DIV 4)] := c2;
       if (b<>$FF) then break; // Found first 1 bit
       inc(i);
     end;

src/core/UPoolMinerThreads.pas

@@ -107,6 +107,8 @@ Type
     Procedure UpdateState; virtual;
     Procedure UpdateDeviceStats(Stats : TMinerStats); virtual;
     Procedure FoundNOnce(const usedMinerValuesForWork : TMinerValuesForWork; Timestamp,nOnce : Cardinal);
+    procedure CreateDigest(const AMinerValuesForWork : TMinerValuesForWork; Timestamp,nOnce : Cardinal; var ODigest : TRawBytes); overload;
+    procedure UpdateMinerValuesForWorkLength(var OMinerValuesForWork : TMinerValuesForWork; out OChangeTimestampAndNOnceBytePos: Integer);
   public
     Constructor Create(APoolMinerThread : TPoolMinerThread; InitialMinerValuesForWork : TMinerValuesForWork); virtual;
     Destructor Destroy; override;
@@ -349,7 +351,7 @@ procedure TPoolMinerThread.OnMinerNewBlockFound(sender : TCustomMinerDeviceThrea
 begin
   FDevicesList.LockList;
   try
-    TLog.NewLog(ltinfo,ClassName,'FOUND VALID NONCE!!! Block:'+IntToStr(usedMinerValuesForWork.block)+' Timestamp:'+Inttostr(Timestamp)+ ' Nonce:'+Inttostr(NOnce)+' Payload:'+usedMinerValuesForWork.payload_start);
+    TLog.NewLog(ltinfo,ClassName,'FOUND VALID NONCE!!! Block:'+IntToStr(usedMinerValuesForWork.block)+' Timestamp:'+Inttostr(Timestamp)+ ' Nonce:'+Inttostr(NOnce)+' Payload:'+usedMinerValuesForWork.payload_start.ToString);
     FPoolMinerClient.SubmitBlockFound(usedMinerValuesForWork,usedMinerValuesForWork.payload_start,Timestamp,NOnce);
   finally
     FDevicesList.UnlockList;
@@ -375,25 +377,33 @@ end;
 procedure TPoolMinerThread.OnPoolMinerMustChangeValues(Sender: TObject);
 Var l : TList;
   i,j : Integer;
-  digest : TRawBytes;
+  digest_length : Integer;
   ok : Boolean;
   minervfw : TMinerValuesForWork;
   auxminervfw : TMinerValuesForWork;
+  auxRaw : TRawBytes;
 begin
   FGlobalMinerValuesForWork := FPoolMinerClient.MinerValuesForWork;
   TLog.NewLog(ltupdate,ClassName,Format('New miner values. Block %d Target %s Payload %s',[FPoolMinerClient.MinerValuesForWork.block,
-    IntToHex(FPoolMinerClient.MinerValuesForWork.target,8), FPoolMinerClient.MinerValuesForWork.payload_start]));
+    IntToHex(FPoolMinerClient.MinerValuesForWork.target,8), FPoolMinerClient.MinerValuesForWork.payload_start.ToPrintable]));
   l := FDevicesList.LockList;
   Try
     for i := 0 to l.Count - 1 do begin
       minervfw := FGlobalMinerValuesForWork;
-      minervfw.payload_start:=minervfw.payload_start+FMinerAddName;
-      if (l.count>1) then minervfw.payload_start:=minervfw.payload_start+inttostr(i);
+      auxRaw.FromString(FMinerAddName);
+      TBaseType.Concat(minervfw.payload_start,auxRaw,minervfw.payload_start);
+      if (l.count>1) then begin
+        auxRaw.FromString(inttostr(i));
+        TBaseType.Concat(minervfw.payload_start,auxRaw,minervfw.payload_start);
+      end;
       if Not TPoolMinerThread.UseRandomHash(minervfw.version) then begin
         repeat // Prepare payload_start with SHA256 compatible last chunk size
-          digest := minervfw.part1 + minervfw.payload_start + minervfw.part3 + '00000000';
-          ok := CanBeModifiedOnLastChunk(length(digest),j);
-          if (not ok) then minervfw.payload_start:=minervfw.payload_start+'-';
+          digest_length := Length(minervfw.part1) + Length(minervfw.payload_start) + Length(minervfw.part3) + 8; // 8 bytes for Timestamp(4) and Nonce(4)
+          ok := CanBeModifiedOnLastChunk(digest_length,j);
+          if (not ok) then begin
+            SetLength(minervfw.payload_start,Length(minervfw.payload_start)+1);
+            minervfw.payload_start[High(minervfw.payload_start)] := Byte('-');
+          end;
         until (Ok);
       end;
       If FTestingPoWLeftBits>0 then begin
@@ -432,7 +442,7 @@ begin
   FOnStateChanged:=Nil;
   FPaused:=true;
   FLastActiveTC := 0;
-  FLastDigest:='';
+  FLastDigest := Nil;
   SetMinerValuesForWork(InitialMinerValuesForWork);
   PoolMinerThread.FDevicesList.Add(Self);
   inherited Create(false);
@@ -479,19 +489,15 @@ var
   LUseRandomHash : Boolean;
 begin
   // Validation
-  digest := usedMinerValuesForWork.part1+usedMinerValuesForWork.payload_start+usedMinerValuesForWork.part3+'00000000';
-  if length(digest)<8 then exit;
-  if TBaseType.BinStrComp(digest,FLastDigest)=0 then Exit;
+  CreateDigest(usedMinerValuesForWork,Timestamp,nOnce,digest);
+  if TBaseType.Equals(digest,FLastDigest) then Exit;
   FLastDigest := digest;
   LUseRandomHash := TPoolMinerThread.UseRandomHash(usedMinerValuesForWork.version);
-  // Add timestamp and nonce
-  move(Timestamp,digest[length(digest)-7],4);
-  move(nOnce,digest[length(digest)-3],4);
   if LUseRandomHash then
     LHash := TCrypto.DoRandomHash(digest)
   else
     LHash := TCrypto.DoSha256(TCrypto.DoSha256(digest));
-  if (LHash <= usedMinerValuesForWork.target_pow) then begin
+  if (TBaseType.BinStrComp(LHash,usedMinerValuesForWork.target_pow)<=0) then begin
     inc(FGlobaDeviceStats.WinsCount);
     FPoolMinerThread.OnMinerNewBlockFound(self,usedMinerValuesForWork,Timestamp,nOnce);
     If Assigned(FOnFoundNOnce) then FOnFoundNOnce(Self,Timestamp,nOnce);
@@ -506,6 +512,40 @@ begin
   end;
 end;
 
+procedure TCustomMinerDeviceThread.CreateDigest(const AMinerValuesForWork: TMinerValuesForWork; Timestamp, nOnce: Cardinal; var ODigest: TRawBytes);
+begin
+  // Validation
+  SetLength(ODigest,Length(AMinerValuesForWork.part1) + Length(AMinerValuesForWork.payload_start) + Length(AMinerValuesForWork.part3) + 8);
+  move(AMinerValuesForWork.part1[0],
+    ODigest[0],
+    Length(AMinerValuesForWork.part1));
+  move(AMinerValuesForWork.payload_start[0],
+    ODigest[Length(AMinerValuesForWork.part1)],
+    Length(AMinerValuesForWork.payload_start));
+  move(AMinerValuesForWork.part3[0],
+    ODigest[ Length(AMinerValuesForWork.part1) + Length(AMinerValuesForWork.payload_start) ],
+    Length(AMinerValuesForWork.part3));
+  // Add timestamp and nonce
+  move(Timestamp,ODigest[length(ODigest)-8],4);
+  move(nOnce,ODigest[length(ODigest)-4],4);
+end;
+
+procedure TCustomMinerDeviceThread.UpdateMinerValuesForWorkLength(var OMinerValuesForWork: TMinerValuesForWork; out OChangeTimestampAndNOnceBytePos: Integer);
+var i : Integer;
+  isOk : Boolean;
+begin
+  if Not TPoolMinerThread.UseRandomHash(OMinerValuesForWork.version) then begin
+    repeat // Prepare payload_start with SHA256 compatible last chunk size
+      i := Length(OMinerValuesForWork.part1)+Length(OMinerValuesForWork.payload_start)+Length(OMinerValuesForWork.part3)+8;
+      isOk := CanBeModifiedOnLastChunk(i,OChangeTimestampAndNOnceBytePos);
+      If Not isOk then begin
+        SetLength(OMinerValuesForWork.payload_start,Length(OMinerValuesForWork.payload_start)+1);
+        OMinerValuesForWork.payload_start[High(OMinerValuesForWork.payload_start)] := Byte('.');
+      end;
+    until (isOk);
+  end else OChangeTimestampAndNOnceBytePos:=0;
+end;
+
 function TCustomMinerDeviceThread.GlobalDeviceStats: TMinerStats;
 Var g : TMinerStats;
 begin
@@ -530,18 +570,11 @@ begin
 end;
 
 procedure TCustomMinerDeviceThread.SetMinerValuesForWork(const Value: TMinerValuesForWork);
-var i,aux : Integer;
-  canWork : Boolean;
+var aux : Integer;
 begin
   FMinerValuesForWork := Value;
-  if Not TPoolMinerThread.UseRandomHash(FMinerValuesForWork.version) then begin
-    repeat // Prepare payload_start with SHA256 compatible last chunk size
-      i := Length(FMinerValuesForWork.part1)+Length(FMinerValuesForWork.payload_start)+Length(FMinerValuesForWork.part3)+8;
-      canWork := CanBeModifiedOnLastChunk(i,aux);
-      If Not canWork then FMinerValuesForWork.payload_start:=FMinerValuesForWork.payload_start+' ';
-    until (canWork);
-  end;
-  TLog.NewLog(ltinfo,classname,Format('Updated MinerValuesForWork: Target:%s Payload:%s Target_PoW:%s',[IntToHex(FMinerValuesForWork.target,8),FMinerValuesForWork.payload_start,TCrypto.ToHexaString(FMinerValuesForWork.target_pow)]));
+  UpdateMinerValuesForWorkLength(FMinerValuesForWork,aux);
+  TLog.NewLog(ltinfo,classname,Format('Updated MinerValuesForWork: Target:%s Payload:%s Target_PoW:%s',[IntToHex(FMinerValuesForWork.target,8),FMinerValuesForWork.payload_start.ToString,TCrypto.ToHexaString(FMinerValuesForWork.target_pow)]));
   If Assigned(FOnMinerValuesChanged) then FOnMinerValuesChanged(Self);
 end;
 
@@ -625,7 +658,7 @@ var l : TList;
   needminers : Integer;
 begin
   needminers := FCPUs;
-  if (FMinerValuesForWork.part1='') or (FPaused) then needminers := 0;
+  if (Length(FMinerValuesForWork.part1)=0) or (FPaused) then needminers := 0;
   If (Not FPoolMinerThread.TestingMode) And
      (Not FPoolMinerThread.PoolMinerClient.Connected) then needminers := 0;
   l := FCPUsThreads.LockList;
@@ -692,25 +725,16 @@ Var l : TList;
   npos : Integer;
   cpu : TCPUOpenSSLMinerThread;
   digest : TRawBytes;
-  Ok : Boolean;
   sflc : TSHA256HASH;
   lc : TChunk;
 begin
   l := FCPUsThreads.LockList;
   try
-    inherited;
     // Prepare final data:
+    inherited;
     CheckCPUs;
-    npos := 0;
-    if Not TPoolMinerThread.UseRandomHash(FMinerValuesForWork.version) then begin
-      repeat // Prepare payload_start with SHA256 compatible last chunk size
-        digest := FMinerValuesForWork.part1 + FMinerValuesForWork.payload_start + FMinerValuesForWork.part3 + '00000000';
-        ok := CanBeModifiedOnLastChunk(Length(digest),npos);
-        if (not ok) then FMinerValuesForWork.payload_start:=FMinerValuesForWork.payload_start+'.';
-      until (Ok);
-    end else begin
-      digest := FMinerValuesForWork.part1 + FMinerValuesForWork.payload_start + FMinerValuesForWork.part3 + '00000000';
-    end;
+    UpdateMinerValuesForWorkLength(FMinerValuesForWork,npos);
+    CreateDigest(FMinerValuesForWork,0,0,digest);
     PascalCoinPrepareLastChunk(digest,sflc,lc);
     nextmin := 0;
     for i:=0 to l.count-1 do begin
@@ -813,7 +837,7 @@ begin
                   TCrypto.DoRandomHash(LRandomHasher,FDigestStreamMsg.Memory,FDigestStreamMsg.Size,resultPoW);
                 end else
                   TCrypto.DoDoubleSha256(FDigestStreamMsg.Memory,FDigestStreamMsg.Size,resultPoW);
-                if resultPoW < FCurrentMinerValuesForWork.target_pow then begin
+                if (TBaseType.BinStrComp(resultPoW,FCurrentMinerValuesForWork.target_pow)<0) then begin
                   if (Terminated) Or (FCPUDeviceThread.Terminated) then exit;
                   dstep := 5;
                   FLock.Release;
@@ -835,7 +859,7 @@ begin
               baseHashingTC:=TPlatform.GetTickCount;
               for i := 1 to roundsToDo do begin
                 PascalCoinExecuteLastChunkAndDoSha256(FInternalSha256,FInternalChunk,FChangeTimestampAndNOnceBytePos,nonce,ts,resultPoW); // Note: RandomHash is handled above
-                if resultPoW < FCurrentMinerValuesForWork.target_pow then begin
+                if (TBaseType.BinStrComp(resultPoW,FCurrentMinerValuesForWork.target_pow)<0) then begin
                   if Terminated then exit;
                   FLock.Release;
                   try

src/core/UPoolMining.pas

@@ -87,7 +87,7 @@ Type
     FMinerValuesForWork: TMinerValuesForWork;
     FOnMinerMustChangeValues: TNotifyEvent;
     FPassword: String;
-    FPoolFinalMinerName: String;
+    FPoolFinalMinerName: TRawBytes;
     FPoolType: TPoolType;
     FStratum_Target_PoW: TRawBytes;
     FUserName: String;
@@ -103,7 +103,7 @@ Type
     Property PoolType : TPoolType read FPoolType write FPoolType;
     Property UserName : String read FUserName write FUserName;
     Property Password : String read FPassword write FPassword;
-    Property PoolFinalMinerName : String read FPoolFinalMinerName;
+    Property PoolFinalMinerName : TRawBytes read FPoolFinalMinerName;
     Property Stratum_Target_PoW : TRawBytes read FStratum_Target_PoW;
   End;
 
@@ -165,7 +165,7 @@ Type
 Function TBytesToString(Const bytes : TBytes):AnsiString;
 
 Const
-  CT_TMinerValuesForWork_NULL : TMinerValuesForWork = (block:0;version:0;part1:'';payload_start:'';part3:'';target:0;timestamp:0;target_pow:'';jobid:'');
+  CT_TMinerValuesForWork_NULL : TMinerValuesForWork = (block:0;version:0;part1:Nil;payload_start:Nil;part3:Nil;target:0;timestamp:0;target_pow:Nil;jobid:'');
 
 implementation
 
@@ -625,7 +625,7 @@ begin
   FNodeNotifyEvents.Node := TNode.Node;
   FMinerOperations := TPCOperationsComp.Create(FNodeNotifyEvents.Node.Bank);
   FMinerAccountKey := CT_TECDSA_Public_Nul;
-  FMinerPayload := '';
+  FMinerPayload := Nil;
   FPoolJobs := TPCThreadList.Create('TPoolMiningServer_PoolJobs');
   FPoolThread := TPoolMiningServerThread.Create(Self);
   FMax0FeeOperationsPerBlock := CT_MAX_0_fee_operations_per_block_by_miner;
@@ -781,7 +781,8 @@ Var s : String;
   P : PPoolJob;
   i : Integer;
   l : TList;
-  _payloadHexa,_payload : AnsiString;
+  _payloadHexa : AnsiString;
+  _payloadRaw : TRawBytes;
   _timestamp, _nOnce : Cardinal;
   _targetPoW : TRawBytes;
 begin
@@ -800,11 +801,10 @@ begin
   nbOperations := Nil;
   Try
     _payloadHexa := params.AsString('payload','');
-    _payload := TCrypto.HexaToRaw(_payloadHexa);
-    if FMinerPayload<>'' then begin
-      if (copy(_payload,1,length(FMinerPayload))<>FMinerPayload) then begin
-        if _payload='' then _payload := _payloadHexa;
-        Client.SendJSONRPCErrorResponse(id,'Invalid payload ('+_payload+'). Need start with: '+FMinerPayload);
+    _payloadRaw := TCrypto.HexaToRaw(_payloadHexa);
+    if Length(FMinerPayload)>0 then begin
+      if (Not TBaseType.Equals(copy(_payloadRaw,Low(_payloadRaw),length(FMinerPayload)),FMinerPayload)) then begin
+        Client.SendJSONRPCErrorResponse(id,'Invalid payload ('+_payloadHexa+'). Need start with: '+TCrypto.ToHexaString(FMinerPayload));
         exit;
       end;
     end;
@@ -821,8 +821,8 @@ begin
 
           _targetPow := TPascalCoinProtocol.TargetFromCompact( P^.OperationsComp.OperationBlock.compact_target, P^.OperationsComp.OperationBlock.protocol_version );
 
-          P^.OperationsComp.Update_And_RecalcPOW(_nOnce,_timestamp,_payload);
-          if (P^.OperationsComp.OperationBlock.proof_of_work<=_targetPoW) then begin
+          P^.OperationsComp.Update_And_RecalcPOW(_nOnce,_timestamp,_payloadRaw);
+          if (TBaseType.BinStrComp(P^.OperationsComp.OperationBlock.proof_of_work,_targetPoW)<=0) then begin
             // Candidate!
             nbOperations := TPCOperationsComp.Create(Nil);
             nbOperations.bank := FNodeNotifyEvents.Node.Bank;
@@ -844,7 +844,7 @@ begin
         try
           json.GetAsVariant('block').Value := FNodeNotifyEvents.Node.Bank.LastOperationBlock.block;
           json.GetAsVariant('pow').Value := TCrypto.ToHexaString( FNodeNotifyEvents.Node.Bank.LastOperationBlock.proof_of_work );
-          json.GetAsVariant('payload').Value := nbOperations.BlockPayload;
+          json.GetAsVariant('payload').Value := nbOperations.BlockPayload.ToString;
           json.GetAsVariant('timestamp').Value := nbOperations.timestamp;
           json.GetAsVariant('nonce').Value := nbOperations.nonce;
           inc(FClientsWins);
@@ -854,10 +854,10 @@ begin
         end;
         if Assigned(FOnMiningServerNewBlockFound) then FOnMiningServerNewBlockFound(Self);
       end else begin
-        Client.SendJSONRPCErrorResponse(id,'Error: '+errors+' executing '+sJobInfo+' payload:'+nbOperations.BlockPayload+' timestamp:'+InttoStr(nbOperations.timestamp)+' nonce:'+IntToStr(nbOperations.nonce));
+        Client.SendJSONRPCErrorResponse(id,'Error: '+errors+' executing '+sJobInfo+' payload:'+TCrypto.ToHexaString(nbOperations.BlockPayload)+' timestamp:'+InttoStr(nbOperations.timestamp)+' nonce:'+IntToStr(nbOperations.nonce));
       end;
     end else begin
-      Client.SendJSONRPCErrorResponse(id,'Error: No valid job found with these values! (Perhaps prior block job or old job) payload:'+_payload+' timestamp:'+InttoStr(_timestamp)+' nonce:'+IntToStr(_nonce));
+      Client.SendJSONRPCErrorResponse(id,'Error: No valid job found with these values! (Perhaps prior block job or old job) payload:'+_payloadHexa+' timestamp:'+InttoStr(_timestamp)+' nonce:'+IntToStr(_nonce));
     end;
   Finally
     if Assigned(nbOperations) then nbOperations.Free;
@@ -979,7 +979,7 @@ begin
 
     TLog.NewLog(ltInfo,ClassName,
       Format('Sending job %d to miner - Block:%d Ops:%d Target:%s PayloadStart:%s',
-      [nJobs,Operations.OperationBlock.block,Operations.Count,IntToHex(Operations.OperationBlock.compact_target,8),Operations.OperationBlock.block_payload]));
+      [nJobs,Operations.OperationBlock.block,Operations.Count,IntToHex(Operations.OperationBlock.compact_target,8),Operations.OperationBlock.block_payload.ToPrintable]));
   Finally
     params.Free;
   End;
@@ -1051,8 +1051,8 @@ begin
   FPoolType:=ptNone;
   FUserName:='';
   FPassword:='';
-  FPoolFinalMinerName:='';
-  FStratum_Target_PoW:='';
+  FPoolFinalMinerName:=Nil;
+  FStratum_Target_PoW:=Nil;
   inherited;
 end;
 
@@ -1087,18 +1087,18 @@ begin
             raws := TCrypto.HexaToRaw(s);
             If (length(s)>0) And (length(raws)=0) then begin
               TLog.NewLog(lterror,ClassName,'Invalid value to assign as a Miner name. Not hexadecimal '+s);
-              FPoolFinalMinerName:='';
+              FPoolFinalMinerName:=Nil;
             end else begin
               FPoolFinalMinerName := raws;
-              for i:=1 to length(raws) do begin
-                if Not (raws[i] in [#32..#254]) then begin
+              for i:=Low(raws) to High(raws) do begin
+                if Not (raws[i] in [32..254]) then begin
                   TLog.NewLog(ltError,ClassName,'Invalid proposed miner name. Value at pos '+inttostr(i)+' is not #32..#254: '+IntToStr(integer(raws[i])));
-                  FPoolFinalMinerName:='';
+                  FPoolFinalMinerName:=Nil;
                   break;
                 end;
               end;
             end;
-            TLog.NewLog(ltInfo,Classname,'Final miner name: "'+FPoolFinalMinerName+'" (Length '+IntToStr(length(FPoolFinalMinerName)));
+            TLog.NewLog(ltInfo,Classname,'Final miner name: "'+FPoolFinalMinerName.ToPrintable+'" (Length '+IntToStr(length(FPoolFinalMinerName)));
           end;
         end else raise Exception.Create('Not response to "'+CT_PoolMining_Method_STRATUM_MINING_SUBSCRIBE+'" method for user "'+UserName+'"');
       end else raise Exception.Create('Not response to "'+CT_PoolMining_Method_STRATUM_MINING_AUTHORIZE+'" method for user "'+UserName+'"');
@@ -1179,7 +1179,7 @@ Var _t : Cardinal;
   _t_pow : TRawBytes;
 begin
   FMinerValuesForWork := Value;
-  If FStratum_Target_PoW<>'' then begin
+  If Length(FStratum_Target_PoW)>0 then begin
     FMinerValuesForWork.target:=TPascalCoinProtocol.TargetToCompact(FStratum_Target_PoW,FMinerValuesForWork.version);
     FMinerValuesForWork.target_pow:=TPascalCoinProtocol.TargetFromCompact(FMinerValuesForWork.target,FMinerValuesForWork.version);
   end else begin
@@ -1190,7 +1190,7 @@ begin
       if (FMinerValuesForWork.target<TPascalCoinProtocol.MinimumTarget(FMinerValuesForWork.version)) then begin
         // target has no valid value... assigning compact_target!
         FMinerValuesForWork.target:=TPascalCoinProtocol.TargetToCompact(_t_pow,FMinerValuesForWork.version);
-      end else if (_t_pow<>FMinerValuesForWork.target_pow) Or (_t<>FMinerValuesForWork.target) then begin
+      end else if (Not TBaseType.Equals(_t_pow,FMinerValuesForWork.target_pow)) Or (_t<>FMinerValuesForWork.target) then begin
         TLog.NewLog(ltError,Classname,'Received bad values for target and target_pow!');
         If (FMinerValuesForWork.target<TPascalCoinProtocol.MinimumTarget(FMinerValuesForWork.version)) then begin
           FMinerValuesForWork.target_pow:=TPascalCoinProtocol.TargetFromCompact(FMinerValuesForWork.target,FMinerValuesForWork.version);
@@ -1209,7 +1209,7 @@ begin
       end;
     end;
   end;
-  If (FPoolType=ptIdentify) And (FPoolFinalMinerName<>'') then FMinerValuesForWork.payload_start:=FPoolFinalMinerName;
+  If (FPoolType=ptIdentify) And (Length(FPoolFinalMinerName)>0) then FMinerValuesForWork.payload_start:=FPoolFinalMinerName;
   if Assigned(FOnMinerMustChangeValues) then FOnMinerMustChangeValues(Self);
 end;
 

src/core/USha256.pas

@@ -32,12 +32,12 @@ function SHA256ToStr(Hash: TSHA256HASH): String;
 
 
 Function CanBeModifiedOnLastChunk(MessageTotalLength : Int64; var startBytePos : integer) : Boolean;
-Procedure PascalCoinPrepareLastChunk(Const messageToHash : AnsiString; out stateForLastChunk : TSHA256HASH; out bufferForLastChunk : TChunk);
+Procedure PascalCoinPrepareLastChunk(Const messageToHash : TBytes; out stateForLastChunk : TSHA256HASH; out bufferForLastChunk : TChunk);
 Function ExecuteLastChunk(const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal) : TSHA256HASH;
 Function ExecuteLastChunkAndDoSha256(Const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal) : TSHA256HASH;
-Procedure PascalCoinExecuteLastChunkAndDoSha256(Const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal; var ResultSha256 : AnsiString);
+Procedure PascalCoinExecuteLastChunkAndDoSha256(Const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal; var ResultSha256 : TBytes);
 Function Sha256HashToRaw(Const hash : TSHA256HASH) : AnsiString; overload;
-procedure Sha256HashToRaw(Const hash : TSHA256HASH; var raw : AnsiString); overload;
+procedure Sha256HashToRaw(Const hash : TSHA256HASH; var raw : TBytes); overload;
 
 implementation
 
@@ -256,7 +256,7 @@ Begin
   Result := (startBytePos >= 0) And ((startBytePos MOD 4)=0) And (startBytePos<=48);
 End;
 
-Procedure PascalCoinPrepareLastChunk(Const messageToHash : AnsiString; out stateForLastChunk : TSHA256HASH; out bufferForLastChunk : TChunk);
+Procedure PascalCoinPrepareLastChunk(Const messageToHash : TBytes; out stateForLastChunk : TSHA256HASH; out bufferForLastChunk : TChunk);
 var
   i,j,k,iPos: Integer;
   Size: int64;
@@ -283,7 +283,7 @@ begin
     FillChar(P^,64*2,#0);
     i := length(messageToHash) - iPos;
     if (i > 64) then i:=64;
-    Move(messageToHash[iPos+1],P[0],i);
+    Move(messageToHash[iPos],P[0],i);
     if (i = 64) then
     begin
       inc(iPos,i);
@@ -365,7 +365,7 @@ Begin
     Result[k]:= Result[k] + H[k];
 End;
 
-Procedure PascalCoinExecuteLastChunkAndDoSha256(Const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal; var ResultSha256 : AnsiString);
+Procedure PascalCoinExecuteLastChunkAndDoSha256(Const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal; var ResultSha256 : TBytes);
 Var  H: TSHA256HASH;
 Begin
   H := ExecuteLastChunkAndDoSha256(stateForLastChunk,bufferForLastChunk,nPos,nOnce,Timestamp);
@@ -386,17 +386,17 @@ begin
   end;
 End;
 
-procedure Sha256HashToRaw(Const hash : TSHA256HASH; var raw : AnsiString); overload;
+procedure Sha256HashToRaw(Const hash : TSHA256HASH; var raw : TBytes); overload;
 var i: Integer;
   c : Cardinal;
 begin
   if (length(raw)<>32) then SetLength(raw,32);
   for i:= 0 to 7 do begin
     c := hash[i];
-    raw[4+(i*4)] := AnsiChar(c MOD 256);
-    raw[3+(i*4)] := AnsiChar((c SHR 8) MOD 256);
-    raw[2+(i*4)] := AnsiChar((c SHR 16) MOD 256);
-    raw[1+(i*4)] := AnsiChar((c SHR 24) MOD 256);
+    raw[3+(i*4)] := (c MOD 256);
+    raw[2+(i*4)] := ((c SHR 8) MOD 256);
+    raw[1+(i*4)] := ((c SHR 16) MOD 256);
+    raw[  (i*4)] := ((c SHR 24) MOD 256);
   end;
 end;