/*
svs v0.1 - 2018-02-28

PGP 66 00 8A 65 39 68 AE DC
coincept.net
dbytelad42vmccwz.onion
*/


include(commonsense.lib)
include(science.lib)
include(research.lib)

const $trust = self
const $elements = array(location, liberty, activity, passion, ethos, utility, profession, scalability, security, privacy, community, authenticity, loyalty, authority, policy, interoperability)

function verifyShitcoin($coin) {

$vision = null
$shitcoin = true

for ($elements as $e1) {
for ($elements as $e2) {
if ($e1!=$e2]) $vision.merge(doResearch($trust, $e1+$e2))
}
}

if ((verifyConsensus(doMath($vision))) or ($coin==Dogecoin)) $shitcoin = false

if ($shitcoin) return "shit" else return "not shit"
}

@ECHO ON

input $coin

echo "coin is " + verifyShitcoin($coin)

EOF

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.security.Security;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Random;
import java.util.Scanner;

import org.spongycastle.asn1.sec.SECNamedCurves;
import org.spongycastle.asn1.x9.X9ECParameters;
import org.spongycastle.crypto.digests.RIPEMD160Digest;
import org.spongycastle.crypto.params.ECDomainParameters;
import org.spongycastle.math.ec.ECPoint;

public class BitcoinLottery {
private static File BitcoinAddressen = new File("./Addys.txt");
private static String genPrivateKey;
private static BigInteger privateKeyNumber;
private static byte[] publicKey;
private static String genAddy;
private static final ECDomainParameters EC_PARAMS;
private static final BigInteger BASE58_CHUNK_MOD = BigInteger.valueOf(0x5fa8624c7fba400L);
private static final int BASE58_CHUNK_DIGITS = 10;
private static final char[] BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray();
     private static int Counter = 0;

//Generate Curve for Eliptic Curve Algo:
static {
       X9ECParameters params = SECNamedCurves.getByName("secp256k1");
       EC_PARAMS = new ECDomainParameters(params.getCurve(), params.getG(), params.getN(), params.getH());
   }

     public static void main(String[] args) throws FileNotFoundException {
       System.out.println("Let`s start!!!");
     while(true) {
     System.out.println("Iteration no: " + Counter);
       Counter = Counter + 1;
     Scanner AddressStream = new Scanner(BitcoinAddressen);
    
     //Generate new privatekey and convert it to hex
     privateKeyNumber = new BigInteger(256, new Random()); //random generation
     System.out.println("Private Key Number: " + privateKeyNumber);
     //Generate PublicKey to calculate Address from:
     ECPoint uncompressed = EC_PARAMS.getG().multiply(privateKeyNumber);
     publicKey = uncompressed.getEncoded(false);
     System.out.println("Public Key: " + publicKey);
    
        
     //Generate Bitcoin-Address:
     try {
             byte[] hashedPublicKey = sha256ripemd160(publicKey);
             byte[] addressBytes = new byte[1 + hashedPublicKey.length + 4];
             addressBytes[0] = (byte) (0);
             System.arraycopy(hashedPublicKey, 0, addressBytes, 1, hashedPublicKey.length);
             MessageDigest digestSha = MessageDigest.getInstance("SHA-256");
             digestSha.update(addressBytes, 0, addressBytes.length - 4);
             byte[] check = digestSha.digest(digestSha.digest());
             System.arraycopy(check, 0, addressBytes, hashedPublicKey.length + 1, 4);
             genAddy = encodeBase58(addressBytes);
             System.out.println("Gen Bitcoin-Address: " + genAddy);
         }
     catch (NoSuchAlgorithmException e) {
         }
    
     //Check if Address is in our List:
     while(AddressStream.hasNextLine()){
     if(AddressStream.nextLine().equals(genAddy)){
     System.out.println("!!!!SUCCESS!!!!");
       //Convert PrivateKey to Wallet Input Format:
       genPrivateKey = privateKeyNumber.toString(16);
             System.out.println("Convert PK to Wallet: " + genPrivateKey);
       genPrivateKey = "80"+genPrivateKey;
             System.out.println("Convert PK to Wallet +80 (magic): " + genPrivateKey);
       try {
MessageDigest digestSha = MessageDigest.getInstance("SHA-256");
byte[] hash = digestSha.digest(genPrivateKey.getBytes(StandardCharsets.UTF_8));
hash = digestSha.digest(hash);
String checksum = "";

for(int i=1; i < 5; i++) {
 checksum = checksum + hash[i];
}

genPrivateKey = genPrivateKey + checksum;
genPrivateKey = encodeBase58(genPrivateKey.getBytes(StandardCharsets.UTF_8));
System.out.println("Final Private Key: " + genPrivateKey);
writeStuffToFile();
} catch (NoSuchAlgorithmException e) {
writeStuffToFile();
}
      
     }
      }
     AddressStream.close();  
     }
   }
    
     public static void writeStuffToFile() {
     try {
        String Info = "Private Key: "+ privateKeyNumber + " HEX: " + privateKeyNumber.toString(16) + " WIF: "+ genPrivateKey;
        Files.write(Paths.get("PrivateKeys.txt"), Info.getBytes(), StandardOpenOption.APPEND);
     }catch (IOException e) {
     System.out.println("KEY FOUND BUT THERE WAS A PROBLEM WRITING TO FILE!:");
        System.out.println("Private Key: "+ privateKeyNumber + " HEX: " + privateKeyNumber.toString(16));
        System.out.println("WIF: "+ genPrivateKey);
        System.out.println();
     }
     }
     public static String encodeBase58(byte[] input) {
         if (input == null) {
             return null;
         }
         StringBuilder str = new StringBuilder((input.length * 350) / 256 + 1);
         BigInteger bn = new BigInteger(1, input);
         long rem;
         while (true) {
             BigInteger[] divideAndRemainder = bn.divideAndRemainder(BASE58_CHUNK_MOD);
             bn = divideAndRemainder[0];
             rem = divideAndRemainder[1].longValue();
             if (bn.compareTo(BigInteger.ZERO) == 0) {
                 break;
             }
             for (int i = 0; i < BASE58_CHUNK_DIGITS; i++) {
                 str.append(BASE58[(int) (rem % 58)]);
                 rem /= 58;
             }
         }
         while (rem != 0) {
             str.append(BASE58[(int) (rem % 58)]);
             rem /= 58;
         }
         str.reverse();
         int nLeadingZeros = 0;
         while (nLeadingZeros < input.length && input[nLeadingZeros] == 0) {
             str.insert(0, BASE58[0]);
             nLeadingZeros++;
         }
         return str.toString();
     }
  
     public static byte[] sha256ripemd160(byte[] publicKey) {
         try {
             MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
             byte[] sha256hash = sha256.digest(publicKey);
             RIPEMD160Digest ripemd160Digest = new RIPEMD160Digest();
             ripemd160Digest.update(sha256hash, 0, sha256hash.length);
             byte[] hashedPublicKey = new byte[20];
             ripemd160Digest.doFinal(hashedPublicKey, 0);
             return hashedPublicKey;
         } catch (NoSuchAlgorithmException e) {
             throw new RuntimeException(e);
         }
     }
}

Main-class: BitcoinLottery

javac C:\Users\USER_NAME\Desktop\BitcoinLottery\BitcoinLottery.java

jar cfvm C:\Users\USER_NAME\Desktop\BitcoinLottery\BitcoinLottery.jar C:\Users\USER_NAME\Desktop\BitcoinLottery\Manifest.txt C:\Users\USER_NAME\Desktop\BitcoinLottery\BitcoinLottery.class