PascalCoinMiner 0.7

src/core/UGPUMining.pas

@@ -133,6 +133,7 @@ Var Timestamp, nOnce : Cardinal;
   nLap : Cardinal;
   baseRealTC,baseHashingTC,finalHashingTC,lastNotifyTC : Cardinal;
   AuxStats : TMinerStats;
+  cMVFW : TMinerValuesForWork;
 begin
   UpdateState;
   nLap := 0;
@@ -145,6 +146,7 @@ begin
       baseRealTC := GetTickCount;
       FLock.Acquire;
       try
+        cMVFW := MinerValuesForWork;
       //  AuxStats := CT_TMinerStats_NULL;
         If FReadyToGPU then begin
           Timestamp := UnivDateTimeToUnix(DateTime2UnivDateTime(now));
@@ -175,7 +177,7 @@ begin
             inc(AuxStats.WinsCount);
             FLock.Release;
             try
-              FoundNOnce(Timestamp,nOnce);
+              FoundNOnce(cMVFW,Timestamp,nOnce);
             finally
               FLock.Acquire;
             end;

src/core/UPoolMinerThreads.pas

@@ -55,7 +55,7 @@ Type
     FTestingPoWLeftBits: Byte;
     Procedure OnPoolMinerClientConnectionChanged(Sender : TObject);
     Procedure OnPoolMinerMustChangeValues(Sender : TObject);
-    Procedure OnMinerNewBlockFound(sender : TCustomMinerDeviceThread; Timestamp : Cardinal; NOnce : Cardinal);
+    Procedure OnMinerNewBlockFound(sender : TCustomMinerDeviceThread; const usedMinerValuesForWork : TMinerValuesForWork; Timestamp : Cardinal; NOnce : Cardinal);
     Procedure NotifyPoolMinerConnectionChanged;
     procedure SetMinerAddName(AValue: String);
     procedure SetTestingPoWLeftBits(AValue: Byte);
@@ -95,7 +95,7 @@ Type
     Procedure SetMinerValuesForWork(const Value : TMinerValuesForWork); virtual;
     Procedure UpdateState; virtual;
     Procedure UpdateDeviceStats(Stats : TMinerStats); virtual;
-    Procedure FoundNOnce(Timestamp,nOnce : Cardinal);
+    Procedure FoundNOnce(const usedMinerValuesForWork : TMinerValuesForWork; Timestamp,nOnce : Cardinal);
   public
     Constructor Create(APoolMinerThread : TPoolMinerThread; InitialMinerValuesForWork : TMinerValuesForWork); virtual;
     Destructor Destroy; override;
@@ -144,6 +144,7 @@ Type
     FCPUDeviceThread : TCPUDeviceThread;
     FLock : TCriticalSection;
   protected
+    FCurrentMinerValuesForWork : TMinerValuesForWork;
     FInternalSha256 : TSHA256HASH;
     FInternalChunk : TChunk;
     FDigestMsg : TRawBytes;
@@ -169,19 +170,23 @@ Var nID : Cardinal;
   ResponseMethod : String;
   l : TList;
 begin
+  DebugStep:='Starting';
   Try
     while not Terminated do begin
+      DebugStep:='Not connected';
       if not FPoolMinerClient.Connected then begin
         If Not FPoolMinerClient.Connect then begin
         end else begin
           TLog.NewLog(ltinfo,ClassName,'Starting connection to '+FPoolMinerClient.ClientRemoteAddr);
         end;
       end else begin
+          DebugStep:='Starting process';
           // Start Process
           nId:=FPoolMinerClient.GetNewId;
           FPoolMinerClient.SendJSONRPCMethod(CT_PoolMining_Method_MINER_NOTIFY,nil,nId);
           json := TPCJSONObject.create;
           try
+            DebugStep:='Starting repeat';
             repeat
               if (FPoolMinerClient.DoProcessBuffer(Self,1000,true,ResponseMethod,json)) then begin
                 FPoolMinerClient.DoProcessJSONObject(json,ResponseMethod);
@@ -191,12 +196,10 @@ begin
           finally
             json.Free;
           end;
+          DebugStep:='Disconnecting';
           FPoolMinerClient.Disconnect;
       end;
-      for i := 1 to 100 do begin
-        if terminated then exit;
-        sleep(50);
-      end;
+      sleep(1);
     end;
   Finally
     FPoolMinerClient.Disconnect;
@@ -325,14 +328,12 @@ begin
   else FTestingPoWLeftBits:=0;
 end;
 
-procedure TPoolMinerThread.OnMinerNewBlockFound(sender : TCustomMinerDeviceThread; Timestamp : Cardinal; NOnce : Cardinal);
-Var mvfw : TMinerValuesForWork;
+procedure TPoolMinerThread.OnMinerNewBlockFound(sender : TCustomMinerDeviceThread; const usedMinerValuesForWork : TMinerValuesForWork; Timestamp : Cardinal; NOnce : Cardinal);
 begin
   FDevicesList.LockList;
   try
-    mvfw := sender.FMinerValuesForWork;
-    TLog.NewLog(ltinfo,ClassName,'FOUND VALID NONCE!!! Timestamp:'+Inttostr(Timestamp)+ ' Nonce:'+Inttostr(NOnce));
-    FPoolMinerClient.SubmitBlockFound(mvfw,mvfw.payload_start,Timestamp,NOnce);
+    TLog.NewLog(ltinfo,ClassName,'FOUND VALID NONCE!!! Block:'+IntToStr(usedMinerValuesForWork.block)+' Timestamp:'+Inttostr(Timestamp)+ ' Nonce:'+Inttostr(NOnce)+' Payload:'+usedMinerValuesForWork.payload_start);
+    FPoolMinerClient.SubmitBlockFound(usedMinerValuesForWork,usedMinerValuesForWork.payload_start,Timestamp,NOnce);
   finally
     FDevicesList.UnlockList;
   end;
@@ -452,23 +453,23 @@ begin
   end;
 end;
 
-procedure TCustomMinerDeviceThread.FoundNOnce(Timestamp, nOnce: Cardinal);
+procedure TCustomMinerDeviceThread.FoundNOnce(const usedMinerValuesForWork : TMinerValuesForWork; Timestamp, nOnce: Cardinal);
 Var digest,dsha256  : TRawBytes;
 begin
   // Validation
-  digest := self.FMinerValuesForWork.part1+self.FMinerValuesForWork.payload_start+self.FMinerValuesForWork.part3+'00000000';
+  digest := usedMinerValuesForWork.part1+usedMinerValuesForWork.payload_start+usedMinerValuesForWork.part3+'00000000';
   if length(digest)<8 then exit;
   // Add timestamp and nonce
   move(Timestamp,digest[length(digest)-7],4);
   move(nOnce,digest[length(digest)-3],4);
   dsha256 := TCrypto.DoSha256(TCrypto.DoSha256(digest));
-  if (dsha256 <= self.FMinerValuesForWork.target_pow) then begin
-    FPoolMinerThread.OnMinerNewBlockFound(self,Timestamp,nOnce);
+  if (dsha256 <= usedMinerValuesForWork.target_pow) then begin
+    FPoolMinerThread.OnMinerNewBlockFound(self,usedMinerValuesForWork,Timestamp,nOnce);
     If Assigned(FOnFoundNOnce) then FOnFoundNOnce(Self,Timestamp,nOnce);
   end else begin
     inc(FGlobaDeviceStats.Invalids);
     TLog.NewLog(lterror,Self.Classname,Format('Invalid Double Sha256 found. Timestamp %s nOnce %s DSHA256 %s Valid POW %s',
-      [IntToHex(Timestamp,8),IntToHex(nOnce,8),TCrypto.ToHexaString(dsha256),TCrypto.ToHexaString(self.FMinerValuesForWork.target_pow)]));
+      [IntToHex(Timestamp,8),IntToHex(nOnce,8),TCrypto.ToHexaString(dsha256),TCrypto.ToHexaString(usedMinerValuesForWork.target_pow)]));
   end;
 end;
 
@@ -507,7 +508,7 @@ begin
     canWork := CanBeModifiedOnLastChunk(i,aux);
     If Not canWork then FMinerValuesForWork.payload_start:=FMinerValuesForWork.payload_start+' ';
   until (canWork);
-  TLog.NewLog(ltinfo,classname,Format('Updated MinerValuesForWork: Target:%s Payload:%s',[IntToHex(FMinerValuesForWork.target,8),FMinerValuesForWork.payload_start]));
+  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)]));
   If Assigned(FOnMinerValuesChanged) then FOnMinerValuesChanged(Self);
 end;
 
@@ -615,7 +616,7 @@ constructor TCPUDeviceThread.Create(PoolMinerThread: TPoolMinerThread; InitialMi
 begin
   FCPUsThreads := TPCThreadList.Create('TCPUDeviceThread_CPUsThreads');
   FCPUs:=0;
-  FUseOpenSSLFunctions := true;
+  FUseOpenSSLFunctions := True;
   inherited Create(PoolMinerThread, InitialMinerValuesForWork);
 end;
 
@@ -658,9 +659,9 @@ Var l : TList;
   sflc : TSHA256HASH;
   lc : TChunk;
 begin
-  inherited;
   l := FCPUsThreads.LockList;
   try
+    inherited;
     // Prepare final data:
     CheckCPUs;
     npos := 0;
@@ -675,6 +676,7 @@ begin
       cpu := TCPUOpenSSLMinerThread(l[i]);
       cpu.FLock.Acquire;
       try
+        cpu.FCurrentMinerValuesForWork := FMinerValuesForWork;
         cpu.FInternalSha256 := sflc;
         cpu.FInternalChunk := lc;
         cpu.FDigestMsg:=digest;
@@ -708,7 +710,7 @@ end;
 { TCPUOpenSSLMinerThread }
 
 procedure TCPUOpenSSLMinerThread.BCExecute;
-Const CT_Rounds = 10000;
+Const CT_Rounds = 1000;
 Var
   ts : Cardinal;
   i : Integer;
@@ -736,7 +738,8 @@ begin
           If (nonce<FMinNOnce) Or (nonce>FMaxNOnce) then nonce:=FMinNOnce;
           // Timestamp
           ts := UnivDateTimeToUnix(DateTime2UnivDateTime(now));
-          if ts<=FCPUDeviceThread.FMinerValuesForWork.timestamp then ts := FCPUDeviceThread.FMinerValuesForWork.timestamp+1;
+          if ts<=FCurrentMinerValuesForWork.timestamp then ts := FCurrentMinerValuesForWork.timestamp+1;
+
           If FDigestStreamMsg.Size>8 then begin
             if FCPUDeviceThread.FUseOpenSSLFunctions then begin
               FDigestStreamMsg.Position:=FDigestStreamMsg.Size - 8;
@@ -747,14 +750,14 @@ begin
                 FDigestStreamMsg.Position := FDigestStreamMsg.Size - 4;
                 FDigestStreamMsg.Write(nonce,4);
                 TCrypto.DoDoubleSha256(FDigestStreamMsg.Memory,FDigestStreamMsg.Size,resultPoW);
-                if resultPoW < FCPUDeviceThread.FMinerValuesForWork.target_pow then begin
+                if resultPoW < FCurrentMinerValuesForWork.target_pow then begin
                   if Terminated then exit;
                   inc(AuxStats.WinsCount);
                   dstep := 5;
                   FLock.Release;
                   try
                     dstep := 6;
-                    FCPUDeviceThread.FoundNOnce(ts,nonce);
+                    FCPUDeviceThread.FoundNOnce(FCurrentMinerValuesForWork, ts,nonce);
                     dstep := 7;
                   finally
                     FLock.Acquire;
@@ -768,12 +771,12 @@ begin
               baseHashingTC:=GetTickCount;
               for i := 1 to CT_Rounds do begin
                 PascalCoinExecuteLastChunkAndDoSha256(FInternalSha256,FInternalChunk,FChangeTimestampAndNOnceBytePos,nonce,ts,resultPoW);
-                if resultPoW < FCPUDeviceThread.FMinerValuesForWork.target_pow then begin
+                if resultPoW < FCurrentMinerValuesForWork.target_pow then begin
                   if Terminated then exit;
                   inc(AuxStats.WinsCount);
                   FLock.Release;
                   try
-                    FCPUDeviceThread.FoundNOnce(ts,nonce);
+                    FCPUDeviceThread.FoundNOnce(FCurrentMinerValuesForWork, ts,nonce);
                   finally
                     FLock.Acquire;
                   end;

src/core/UPoolMining.pas

@@ -68,7 +68,7 @@ Type
     Procedure SendJSONRPCErrorResponse(const id : Variant; const error : String);
     Procedure SendJSONRPCResponse(result : TPCJSONObject; const id : Variant);
     Procedure SendJSONRPCMethod(const method : String; params : TPCJSONList; const id : Variant);
-    Function SendJSONRPCMethodAndWait(const method : String; params : TPCJSONList; MaxWaitMiliseconds : Cardinal; resultObject : TPCJSONObject; processEventOnInvalid : TProcessJSONObjectEvent = Nil) : Boolean;
+    Function SendJSONRPCMethodAndWait(const method : String; params : TPCJSONList; MaxWaitMiliseconds : Int64; resultObject : TPCJSONObject; processEventOnInvalid : TProcessJSONObjectEvent = Nil) : Boolean;
     Function DoProcessBuffer(SenderThread : TPCThread; MaxWaitMiliseconds : Cardinal; DeleteBufferOnExit : Boolean; var ResponseMethod : String; var jsonObject : TPCJSONObject) : Boolean;
     Function GetNewId : Cardinal;
   End;
@@ -282,15 +282,11 @@ var PartialBuffer : TBytes;
       Result := true;
     end;
   end;
-var islocked : Boolean;
 begin
   Result := false;
   ResponseMethod := '';
   tc := TPlatform.GetTickCount;
-  Repeat
-    islocked := FLockProcessBuffer.TryEnter;
-  until (islocked) Or ((TPlatform.GetTickCount>(tc+MaxWaitMiliseconds)) And (MaxWaitMiliseconds<>0));
-  If Not islocked then exit;
+  If Not TPCThread.TryProtectEnterCriticalSection(Self,MaxWaitMiliseconds,FLockProcessBuffer) then Exit;
   try
     if Assigned(SenderThread) then continue := Not SenderThread.Terminated
     else continue := true;
@@ -430,10 +426,9 @@ begin
   End;
 end;
 
-function TJSONRPCTcpIpClient.SendJSONRPCMethodAndWait(const method: String; params: TPCJSONList; MaxWaitMiliseconds: Cardinal; resultObject : TPCJSONObject; processEventOnInvalid : TProcessJSONObjectEvent = Nil) : Boolean;
+function TJSONRPCTcpIpClient.SendJSONRPCMethodAndWait(const method: String; params: TPCJSONList; MaxWaitMiliseconds: Int64; resultObject : TPCJSONObject; processEventOnInvalid : TProcessJSONObjectEvent = Nil) : Boolean;
 Var nId : Cardinal;
   tc : TTickCount;
-  maxw : Cardinal;
   json : TPCJSONObject;
   rm : String;
 begin
@@ -446,10 +441,7 @@ begin
     json := TPCJSONObject.Create;
     Try
       repeat
-        maxw := MaxWaitMiliseconds - (TPlatform.GetTickCount - tc);
-        if maxw<1 then maxw := 1
-        else if maxw>10000 then maxw := 10000;
-        If DoProcessBuffer(nil,maxw,true,rm,json) then begin
+        If DoProcessBuffer(nil,MaxWaitMiliseconds,true,rm,json) then begin
           If json.AsCardinal('id',0)=nId then begin
             resultObject.Assign(json);
             Result := true;
@@ -461,7 +453,7 @@ begin
             end else TLog.NewLog(lterror,Classname,'Lost JSON message! '+json.ToJSON(false));
           end;
         end;
-      until (Result) Or (TPlatform.GetTickCount > (tc+MaxWaitMiliseconds));
+      until (Result) Or (TPlatform.GetElapsedMilliseconds(tc)>MaxWaitMiliseconds);
     finally
       json.free;
     end;
@@ -817,6 +809,7 @@ begin
     Try
       i := l.Count-1;
       while (i>=0) And (Not Assigned(nbOperations)) do begin
+        sJobInfo := 'Miner job '+IntToStr(i+1)+'/'+IntToStr(l.Count);
         P := l[i];
         // Best practices: Only will accept a solution if timestamp >= sent timestamp for this job (1.5.3)
         If (P^.SentMinTimestamp<=_timestamp) then begin
@@ -828,10 +821,10 @@ begin
             nbOperations.bank := FNodeNotifyEvents.Node.Bank;
             nbOperations.CopyFrom(P^.OperationsComp);
             nbOperations.AccountKey := MinerAccountKey;
-            sJobInfo := 'Miner job '+IntToStr(i+1)+'/'+IntToStr(l.Count);
             TLog.NewLog(ltInfo,ClassName,sJobInfo+' - Found a solution for block '+IntToStr(nbOperations.OperationBlock.block));
-          end;
-        end;
+          end else TLog.NewLog(lterror,ClassName,sJobInfo+Format(' Calculated Pow > Min PoW ->  %s > %s',
+            [TCrypto.ToHexaString(P^.OperationsComp.OperationBlock.proof_of_work),TCrypto.ToHexaString(_targetPoW)]));
+        end else TLog.NewLog(lterror,ClassName,sJobInfo+Format(' Timestamp %d < MinTimestamp %d',[_timestamp,P^.SentMinTimestamp]));
         dec(i);
       end;
     Finally
@@ -887,7 +880,7 @@ begin
       finally
         jsonobj.free;
       end;
-      sleep(10);
+      sleep(1);
     end;
   Finally
     Dec(FClientsCount);

src/core/USha256.pas

@@ -23,8 +23,9 @@ Function CanBeModifiedOnLastChunk(MessageTotalLength : Int64; var startBytePos :
 Procedure PascalCoinPrepareLastChunk(Const messageToHash : AnsiString; 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; out ResultSha256 : AnsiString);
-Function Sha256HashToRaw(Const hash : TSHA256HASH) : AnsiString;
+Procedure PascalCoinExecuteLastChunkAndDoSha256(Const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal; var ResultSha256 : AnsiString);
+Function Sha256HashToRaw(Const hash : TSHA256HASH) : AnsiString; overload;
+procedure Sha256HashToRaw(Const hash : TSHA256HASH; var raw : AnsiString); overload;
 
 implementation
 
@@ -352,11 +353,11 @@ Begin
     Result[k]:= Result[k] + H[k];
 End;
 
-Procedure PascalCoinExecuteLastChunkAndDoSha256(Const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal; out ResultSha256 : AnsiString);
+Procedure PascalCoinExecuteLastChunkAndDoSha256(Const stateForLastChunk : TSHA256HASH; const bufferForLastChunk : TChunk; nPos : Integer; nOnce,Timestamp : Cardinal; var ResultSha256 : AnsiString);
 Var  H: TSHA256HASH;
 Begin
   H := ExecuteLastChunkAndDoSha256(stateForLastChunk,bufferForLastChunk,nPos,nOnce,Timestamp);
-  ResultSha256 := Sha256HashToRaw(H);
+  Sha256HashToRaw(H,ResultSha256);
 End;
 
 Function Sha256HashToRaw(Const hash : TSHA256HASH) : AnsiString;
@@ -373,5 +374,18 @@ begin
   end;
 End;
 
+procedure Sha256HashToRaw(Const hash : TSHA256HASH; var raw : AnsiString); 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);
+  end;
+end;
 
 end.

src/pascalcoin_miner.pp

@@ -27,7 +27,7 @@ uses
   UBlockChain, UPoolMinerThreads, UGPUMining,
   UPoolMining, ULog, UThread, UAccounts, UCrypto,
   UConst, UTime, UNode, UNetProtocol, USha256,
-  UOpenSSL,
+  UOpenSSL, UBaseTypes,
   DelphiCL;
 
 type
@@ -58,7 +58,7 @@ type
   end;
 
 Const
-  CT_MINER_VERSION = {$IFDEF PRODUCTION}'0.6'{$ELSE}{$IFDEF TESTNET}'0.6 TESTNET'{$ELSE}ERROR{$ENDIF}{$ENDIF};
+  CT_MINER_VERSION = {$IFDEF PRODUCTION}'0.7'{$ELSE}{$IFDEF TESTNET}'0.7 TESTNET'{$ELSE}ERROR{$ENDIF}{$ENDIF};
   CT_Line_DeviceStatus = 3;
   CT_Line_ConnectionStatus = 4;
   CT_Line_MinerValues = 7;
@@ -271,14 +271,15 @@ var
   end;
 
   Procedure DoWaitAndLog;
-  Var tc : Cardinal;
+  Var tc : TTickCount;
     gs,ms : TMinerStats;
     hrReal,hrHashing, glhrHashing, glhrReal : Real;
     i : Integer;
     devt : TCustomMinerDeviceThread;
     s : String;
+    kpressed : Char;
   Begin
-    tc := GetTickCount64;
+    tc := TPlatform.GetTickCount;
     repeat
       If FPoolMinerThread.PoolMinerClient.Connected then begin
         for i:=0 to FDeviceThreads.Count-1 do begin
@@ -287,10 +288,8 @@ var
       end;
       while (Not Terminated) do begin
         sleep(100);
-        //devt := TCustomMinerDeviceThread(FDeviceThreads[0]);
-        If (tc + 1000)<GetTickCount64 then begin
+        If TPlatform.GetElapsedMilliseconds(tc)>1000 then begin
           tc := GetTickCount64;
-          //ms := devt.DeviceStats;
           For i:=0 to FDeviceThreads.Count-1 do begin
             devt := TCustomMinerDeviceThread(FDeviceThreads[i]);
             ms := devt.DeviceStats;
@@ -314,13 +313,15 @@ var
           WriteLine(CT_Line_LastFound+FDeviceThreads.Count-1,'MY VALID BLOCKS FOUND: '+IntToStr(gs.WinsCount) +' Working time: '+IntToStr(Trunc(now - FAppStartTime))+'d '+FormatDateTime('hh:nn:ss',Now-FAppStartTime) );
         end;
         If KeyPressed then begin
-          If ReadKey in ['c','C','q','Q'] then begin
+          kpressed := ReadKey;
+          If kpressed in ['c','C','q','Q'] then begin
+            TLog.NewLog(ltinfo,ClassName,'Finalizing by keypressing '+kpressed);
             WriteLine(CT_Line_Logs+FDeviceThreads.Count+CT_MaxLogs,'Finalizing...');
             terminate;
           end;
         end;
       end;
-    until Terminated;
+    until (Terminated) Or (FPoolMinerThread.Terminated);
   end;
 
   Procedure DoVisualprocess(minerName, UserName, Password : String);