public void NonStandardSign(Script sigScript, ITxOutput spentOutput)
{
var spentOutpoint = ((BitcoinBasedTxOutput)spentOutput).Coin.Outpoint;
var input = Tx.Inputs.FindIndexedInput(spentOutpoint);
input.ScriptSig = sigScript;
}
public void Sign(Key privateKey, ITxOutput spentOutput)
{
var output = (BitcoinBasedTxOutput)spentOutput;
var currency = (BitcoinBasedCurrency)Currency;
Tx.Sign(new BitcoinSecret(privateKey, currency.Network), output.Coin);
}
public void Sign(
Key privateKey,
ITxOutput spentOutput)
{
var output = (BitcoinBasedTxOutput)spentOutput;
Tx.Sign(privateKey, output.Coin);
}
public byte[] GetSignatureHash(Script redeemScript, ITxOutput spentOutput)
{
var coin = ((BitcoinBasedTxOutput)spentOutput).Coin;
var scriptCoint = new ScriptCoin(coin, redeemScript);
return(Tx.GetSignatureHash(scriptCoint).ToBytes());
}
public void Sign(
SecureBytes privateKey,
ITxOutput spentOutput,
BitcoinBasedConfig bitcoinBasedConfig)
{
using var scopedPrivateKey = privateKey.ToUnsecuredBytes();
Sign(new Key(scopedPrivateKey), spentOutput, bitcoinBasedConfig); // todo: do not use NBitcoin.Key
}
public void Sign(
Key privateKey,
ITxOutput spentOutput,
BitcoinBasedConfig bitcoinBasedConfig)
{
var output = (BitcoinBasedTxOutput)spentOutput;
Tx.Sign(new BitcoinSecret(privateKey, bitcoinBasedConfig.Network), output.Coin);
}
public bool Verify(
ITxOutput spentOutput,
BitcoinBasedConfig bitcoinBasedConfig,
bool checkScriptPubKey = true)
{
var result = bitcoinBasedConfig.Network.CreateTransactionBuilder()
.SetTransactionPolicy(new StandardTransactionPolicy
{
CheckScriptPubKey = checkScriptPubKey,
ScriptVerify = ScriptVerify.Standard
})
.AddCoins(((BitcoinBasedTxOutput)spentOutput).Coin)
.Verify(Tx, out _);
return(result);
}
public bool Verify(
ITxOutput spentOutput)
{
if (!(Currency is BitcoinBasedCurrency btcBaseCurrency))
{
throw new NotSupportedException("Currency must be Bitcoin based");
}
var result = btcBaseCurrency.Network.CreateTransactionBuilder()
.SetTransactionPolicy(new StandardTransactionPolicy {
CheckScriptPubKey = false, ScriptVerify = ScriptVerify.Standard
})
.AddCoins(((BitcoinBasedTxOutput)spentOutput).Coin)
.Verify(Tx, out _);
return(result);
}
private async Task UpsertOutputAsync(
Currency currency,
ITxOutput output,
string address)
{
var addressOutputs = (await DataRepository
.GetOutputsAsync(currency.Name, address, currency.OutputType())
.ConfigureAwait(false))
.ToList();
addressOutputs.Add(output);
await DataRepository
.UpsertOutputsAsync(
outputs : addressOutputs.RemoveDuplicates(),
currency : currency.Name,
address : address)
.ConfigureAwait(false);
}
public bool Verify(
ITxOutput spentOutput,
out Error[] errors,
BitcoinBasedConfig bitcoinBasedConfig,
bool checkScriptPubKey = true)
{
var result = bitcoinBasedConfig.Network.CreateTransactionBuilder()
.SetTransactionPolicy(new StandardTransactionPolicy
{
CheckScriptPubKey = checkScriptPubKey,
ScriptVerify = ScriptVerify.Standard
})
.AddCoins(((BitcoinBasedTxOutput)spentOutput).Coin)
.Verify(Tx, out var policyErrors);
errors = policyErrors
.Select(pe => new Error(Errors.TransactionVerificationError, pe.ToString()))
.ToArray();
return(result);
}
public bool Verify(
ITxOutput spentOutput,
out Error[] errors)
{
if (!(Currency is BitcoinBasedCurrency btcBaseCurrency))
{
throw new NotSupportedException("Currency must be Bitcoin based");
}
var result = btcBaseCurrency.Network.CreateTransactionBuilder()
.SetTransactionPolicy(new StandardTransactionPolicy {
CheckScriptPubKey = false, ScriptVerify = ScriptVerify.Standard
})
.AddCoins(((BitcoinBasedTxOutput)spentOutput).Coin)
.Verify(Tx, out var policyErrors);
errors = policyErrors
.Select(pe => new Error(Errors.TransactionVerificationError, pe.ToString()))
.ToArray();
return(result);
}
public static int EstimateSigSize(ITxOutput output, bool forRefund = false, bool forRedeem = false)
{
if (!(output is BitcoinBasedTxOutput btcBasedOutput))
{
return(0);
}
var sigSize = 0;
if (btcBasedOutput.IsP2Pkh)
{
sigSize += P2PkhScriptSigSize; // use compressed?
}
else if (btcBasedOutput.IsSegwitP2Pkh)
{
sigSize += P2WPkhScriptSigSize;
}
else if (btcBasedOutput.IsP2PkhSwapPayment || btcBasedOutput.IsHtlcP2PkhSwapPayment)
{
sigSize += forRefund
? P2PkhSwapRefundSigSize
: P2PkhSwapRedeemSigSize;
}
else if (btcBasedOutput.IsP2Sh)
{
sigSize += forRefund
? P2PShSwapRefundScriptSigSize
: (forRedeem
? P2PShSwapRedeemScriptSigSize
: P2PkhScriptSigSize); // todo: probably incorrect
}
else
{
Log.Warning("Unknown output type, estimated fee may be wrong");
}
return(sigSize);
}
public byte[] GetSignatureHash(
ITxOutput spentOutput)
{
return(Tx.GetSignatureHash(((BitcoinBasedTxOutput)spentOutput).Coin).ToBytes());
}
public void NonStandardSign(
byte[] sigScript,
ITxOutput spentOutput)
{
NonStandardSign(new Script(sigScript), spentOutput);
}
public void Sign(
byte[] privateKey,
ITxOutput spentOutput)
{
Sign(new Key(privateKey), spentOutput);
}
public void AddData(string data)
{
List <BrowserDBData> dbData = JsonConvert.DeserializeObject <List <BrowserDBData> >(data);
foreach (var dbObj in dbData)
{
if (dbObj.type == AvailableDataType.WalletAddress.ToString())
{
_addresses[dbObj.id] =
_bsonMapper.ToObject <WalletAddress>(
BsonSerializer.Deserialize(Convert.FromBase64String(dbObj.data)));
}
else if (dbObj.type == AvailableDataType.Transaction.ToString())
{
string[] parsedId = dbObj.id.Split(Convert.ToChar("/"));
string id = parsedId[0];
string currency = parsedId[1];
BsonDocument bd = BsonSerializer.Deserialize(Convert.FromBase64String(dbObj.data));
_transactions[$"{id}:{currency}"] = (IBlockchainTransaction)_bsonMapper.ToObject(doc: bd,
type: _currencies.GetByName(currency).TransactionType);
}
else if (dbObj.type == AvailableDataType.Swap.ToString())
{
_swaps[long.Parse(dbObj.id)] =
_bsonMapper.ToObject <Swap>(
BsonSerializer.Deserialize(Convert.FromBase64String(dbObj.data)));
}
else if (dbObj.type == AvailableDataType.Output.ToString())
{
string[] parsedId = dbObj.id.Split(Convert.ToChar("/"));
string id = parsedId[0];
string currency = parsedId[1];
string address = parsedId[2];
BsonDocument bd = BsonSerializer.Deserialize(Convert.FromBase64String(dbObj.data));
BitcoinBasedConfig BtcBasedCurrency = _currencies.Get <BitcoinBasedConfig>(currency);
ITxOutput output =
(ITxOutput)_bsonMapper.ToObject(doc: bd, type: BtcBasedCurrency.OutputType());
_outputs[id] = new OutputEntity {
Output = output, Currency = currency, Address = address
};
}
else if (dbObj.type == AvailableDataType.Order.ToString())
{
_orders[dbObj.id] =
_bsonMapper.ToObject <Order>(
BsonSerializer.Deserialize(Convert.FromBase64String(dbObj.data)));
}
else if (dbObj.type == AvailableDataType.TezosTokenAddress.ToString())
{
_tezosTokensAddresses[dbObj.id] = _bsonMapper.ToObject <WalletAddress>(
BsonSerializer.Deserialize(Convert.FromBase64String(dbObj.data)));
}
else if (dbObj.type == AvailableDataType.TezosTokenContract.ToString())
{
_tezosTokensContracts[dbObj.id] =
_bsonMapper.ToObject <TokenContract>(
BsonSerializer.Deserialize(Convert.FromBase64String(dbObj.data)));
}
else if (dbObj.type == AvailableDataType.TezosTokenTransfer.ToString())
{
_tezosTokensTransfers[dbObj.id] =
_bsonMapper.ToObject <TokenTransfer>(
BsonSerializer.Deserialize(Convert.FromBase64String(dbObj.data)));
}
}
}
