public string CalTransHash()
{
string strTransction = getRawTx();
string strTransHash = Cryptor.SHA256(strTransction, strTransction.Length);
return(strTransHash);
}
/// <summary>
/// input.hash + index + (该笔交易的所有output的value+pub)
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public string getRawDataToSign(int index)
{
// ith input and all outputs
// sigdata = input.hash + index + (该笔交易的所有output的value+pub)
string strSigData;
if (index > listInputs.Count())
{
return(null);
}
Input inEnty = listInputs[index];
strSigData = inEnty.PreTxHash + inEnty.OutputIndex;
string strAllOutput = string.Empty;
foreach (Output opEnty in listOutputs)
{
strAllOutput += opEnty.value + opEnty.scriptPubKey;
}
strSigData += strAllOutput;
string sigDataHash = Cryptor.SHA256(strSigData, strSigData.Length);
return(sigDataHash);
}
public string CalMerkleRoot(List <string> lstHash)
{
//step2: 相邻两个hash块串联，然后做hash运算，Node1((i + 1) / 2) = hash(Node0i + Node0(i + 1)),
// i = 1,3,5,7; 对于i = 9, Node1((i + 1) / 2) = hash(Node0i)
//step3: 重复step2
//step4: 重复step2
//step5: 重复step2，生成Merkle Tree Root
List <string> lstTemp = new List <string>();
int index = 0;
while (index < lstHash.Count())
{
// left
String left = lstHash[index];
index++;
// right
String right = left;
if (index != lstHash.Count())
{
right = lstHash[index];
}
// sha2 hex value
string LeftAndRight = left + right;
String sha2HexValue = Cryptor.SHA256(LeftAndRight, LeftAndRight.Length);
lstTemp.Add(sha2HexValue);
index++;
}
if (lstTemp.Count > 1)
{
CalMerkleRoot(lstTemp);
}
return(lstTemp[0]);
}
private void OP_HASH160()
{
string strTemp = this.staData.Pop();
strTemp = Cryptor.SHA256(strTemp, strTemp.Length);
this.staData.Push(strTemp);
}
// hash256(hsah + index)
public string utoxHashCode()
{
string strUtox = this.strTxHash + this.index;
string strHash = Cryptor.SHA256(strUtox, strUtox.Length);
return(strHash);
}
public MultiSignViewModel MultiSignUTXOPool2VM(bool bCommited)
{
LogHelper.WriteMethodLog(true);
Dictionary <UTXO, Output> dicMsUTXOPool = new Dictionary <UTXO, Output>();
if (bCommited)
{
dicMsUTXOPool = this.dicComitMsUTXOPool;
}
else
{
dicMsUTXOPool = this.dicUnComitMsUTXOPool;
}
MultiSignViewModel msVM = new MultiSignViewModel();
foreach (var item in dicMsUTXOPool)
{
MultiSignModel msSM = new MultiSignModel();
msSM.TxHash = item.Key.getTxHash();
msSM.OutputIndex = (int)item.Key.getIndex();
msSM.Value = item.Value.value;
msSM.OutScriptPKHash = item.Value.getPKHashFromScript();
msSM.ID = Cryptor.SHA256(msSM.OutScriptPKHash, msSM.OutScriptPKHash.Length).Substring(0, 8);
msSM.BIsAdd2PriTx = false;
msVM.AddItem(msSM);
}
LogHelper.WriteMethodLog(false);
return(msVM);
}
public string CalBlockHash()
{
string strHeader = this.Header.HeaderToStr();
// 计算两遍sha
string strhash = Cryptor.SHA256(strHeader, strHeader.Length);
strhash = Cryptor.SHA256(strhash, strhash.Length);
return(strhash);
}
public string pubkey2Hash(string pubKeyPath)
{
LogHelper.WriteMethodLog(true);
string strPubKeyValue = FileIOHelper.ReadFromText(pubKeyPath);
string strKeyHash = Cryptor.SHA256(strPubKeyValue, strPubKeyValue.Length);
LogHelper.WriteMethodLog(false);
return(strKeyHash);
}
public string pubkey2Script(string pubKeyPath)
{
LogHelper.WriteMethodLog(true);
string strPubKeyValue = FileIOHelper.ReadFromText(pubKeyPath);
string strKeyHash = Cryptor.SHA256(strPubKeyValue, strPubKeyValue.Length);
string strPubScript = string.Format("OP_DUP OP_HASH160 {0} OP_EQUALVERIFY OP_CHECKSIG", strKeyHash);
LogHelper.WriteMethodLog(false);
return(strPubScript);
}
/// <summary>
/// 计算当前交易的hash
/// </summary>
public void SetTransHash()
{
try
{
string strTransction = getRawTx();
this.TxHash = Cryptor.SHA256(strTransction, strTransction.Length);
}
catch (Exception ex)
{
LogHelper.WriteErrorLog(ex.Message);
}
}
private bool OP_CHECKMULTISIG(ref string strDecResult)
{
strDecResult = string.Empty;
List <string> lstPKHash = new List <string>();
for (int i = 0; i < this.M; i++)
{
lstPKHash.Add(this.staData.Pop());
}
List <string> lstDecryptRes = new List <string>();
for (int j = 0; j < this.N; j++)
{
this.OP_DUP();
string strTemp = this.staData.Pop();
strTemp = Cryptor.SHA256(strTemp, strTemp.Length);
if (lstPKHash.Contains(strTemp))
{
string strDecRes = OP_CHECKSIG();
if (string.IsNullOrEmpty(strDecRes))
{
LogHelper.WriteErrorLog("check signature fail");
return(false);
}
else
{
lstDecryptRes.Add(strDecRes);
}
}
}
string strResult1 = lstDecryptRes[0];
foreach (var item in lstDecryptRes)
{
if (!string.Equals(item, strResult1))
{
LogHelper.WriteErrorLog(string.Format("Result not equal, ret[0]:{0}, otherRet:{1}", strResult1, item));
return(false);
}
}
strDecResult = strResult1;
return(true);
}
public Transaction CreatCoinBaseTX(string strAddress)
{
Transaction basecoinTrans = new Transaction();
string basecoinPrehash = "0000000000000000000000000000000000000000000000000000000000000000";
int basecoinIndex = -1;
Input basecoinInput = new Input(basecoinPrehash, basecoinIndex);
scriptSig bassecoinSS = new scriptSig();
string nowTime = DateTime.Now.ToString("yyyyMMddHHmmssfff");
bassecoinSS.Signature = Cryptor.SHA256(nowTime, nowTime.Length);
bassecoinSS.PubKey = Cryptor.SHA256(bassecoinSS.Signature, bassecoinSS.Signature.Length);
basecoinInput.addSignature(bassecoinSS);
basecoinTrans.addInput(basecoinInput);
basecoinTrans.addOutput(24, strAddress);
basecoinTrans.FinalSetTrans();
return(basecoinTrans);
//this.poolTx.Add(RewardTrans);
}
public Transaction CreatTransaction(string strPreHash, uint iIndex, double dValue,
string strPaytoPKHash, string myPriKeyPath, string myPubkeyPath)
{
LogHelper.WriteMethodLog(true);
string strPubKeyValuem = FileIOHelper.ReadFromText(myPubkeyPath);
string strKeyHash = Cryptor.SHA256(strPubKeyValuem, strPubKeyValuem.Length);
string myPubScript = string.Format("OP_DUP OP_HASH160 {0} OP_EQUALVERIFY OP_CHECKSIG", strKeyHash);
UTXO utxo = new UTXO(strPreHash, iIndex);
if (!this.CommitedUtxoPool.contains(utxo))
{
LogHelper.WriteErrorLog("not in utxo");
return(null);
}
Transaction spendTrans = new Transaction();
spendTrans.addInput(strPreHash, (int)iIndex);
spendTrans.addOutput(dValue, strPaytoPKHash);
Output preOutput = this.CommitedUtxoPool.getTxOutput(utxo);
if (dValue < preOutput.value)
{
Output ctOutput = new Output();
ctOutput.value = preOutput.value - dValue;
ctOutput.scriptPubKey = myPubScript;
spendTrans.addOutput(ctOutput);
}
spendTrans.signTrans(myPriKeyPath, strPubKeyValuem);
spendTrans.FinalSetTrans();
LogHelper.WriteInfoLog("CreatTransaction: " + spendTrans.TxHash);
return(spendTrans);
}
public string SignPrimitiveTx(Dictionary <string, keyPair> KeyHashKeypair, ref Transaction PrimitiveTx)
{
LogHelper.WriteMethodLog(true);
bool bHaveSigned = true;
foreach (var item in PrimitiveTx.listInputs)
{
// 只要input有一个没有签名list，就认为没有签名
if (item.lstScriptSig == null)
{
bHaveSigned = false;
break;
}
else
{ // 有签名list后 判断自己是否已经签名，
bHaveSigned = false;
foreach (var item1 in item.lstScriptSig)
{
string strKeyHash = Cryptor.SHA256(item1.PubKey, item1.PubKey.Length);
if (KeyHashKeypair.ContainsKey(strKeyHash))
{
bHaveSigned = true;
}
}
}
}
if (bHaveSigned)
{
return("Current Primitive Tx'inputs Have signed");
}
int iInputCount = PrimitiveTx.listInputs.Count;
for (int i = 0; i < iInputCount; i++)
{
UTXO utxo = new UTXO(PrimitiveTx.listInputs[i].PreTxHash, (uint)PrimitiveTx.listInputs[i].OutputIndex);
if (!CommitedUtxoPool.contains(utxo))
{
LogHelper.WriteInfoLog(" utxoPool not contain utxo:");
return("Invalid utxo"); //check (1),utox 包含该交易返回false
}
Output output = CommitedUtxoPool.getTxOutput(utxo);
List <string> lstScript = output.scriptPubKey.Split(' ').ToList <string>();
var lstPKHash = (from x in lstScript
where x.Substring(0, 3) != "OP_"
select x).ToList();
foreach (var item in lstPKHash)
{
if (KeyHashKeypair.ContainsKey(item))
{
keyPair kp = new keyPair();
KeyHashKeypair.TryGetValue(item, out kp);
string strPriKPath = Path.Combine(AppSettings.XXPKeysFolder, kp.PriKeyNmae);
string strPubKPath = Path.Combine(AppSettings.XXPKeysFolder, kp.PubKeyNmae);
string strPubValue = FileIOHelper.ReadFromText(strPubKPath);
PrimitiveTx.MultiSignTrans(strPriKPath, strPubValue, i);
}
}
}
LogHelper.WriteMethodLog(false);
return(ConstHelper.BC_OK);
}
