public virtual void SetUp()
{
datanode = Org.Mockito.Mockito.Mock <DataNode>();
storage = Org.Mockito.Mockito.Mock <DataStorage>();
this.conf = new Configuration();
this.conf.SetLong(DFSConfigKeys.DfsDatanodeScanPeriodHoursKey, 0);
DNConf dnConf = new DNConf(conf);
Org.Mockito.Mockito.When(datanode.GetConf()).ThenReturn(conf);
Org.Mockito.Mockito.When(datanode.GetDnConf()).ThenReturn(dnConf);
BlockScanner disabledBlockScanner = new BlockScanner(datanode, conf);
Org.Mockito.Mockito.When(datanode.GetBlockScanner()).ThenReturn(disabledBlockScanner
);
ShortCircuitRegistry shortCircuitRegistry = new ShortCircuitRegistry(conf);
Org.Mockito.Mockito.When(datanode.GetShortCircuitRegistry()).ThenReturn(shortCircuitRegistry
);
CreateStorageDirs(storage, conf, NumInitVolumes);
dataset = new FsDatasetImpl(datanode, storage, conf);
foreach (string bpid in BlockPoolIds)
{
dataset.AddBlockPool(bpid, conf);
}
NUnit.Framework.Assert.AreEqual(NumInitVolumes, dataset.GetVolumes().Count);
NUnit.Framework.Assert.AreEqual(0, dataset.GetNumFailedVolumes());
}
public virtual void SetUp()
{
dataset = Org.Mockito.Mockito.Mock <FsDatasetImpl>();
baseDir = new FileSystemTestHelper().GetTestRootDir();
Configuration blockScannerConf = new Configuration();
blockScannerConf.SetInt(DFSConfigKeys.DfsDatanodeScanPeriodHoursKey, -1);
blockScanner = new BlockScanner(null, blockScannerConf);
}
public void Explorer_Query_P2PKH_BTG()
{
string BTCaddr = "GMRz9M1jnc69kW15u8aiGV1EzTgaTuguZQ";
BitcoinAddress ca = BitcoinAddress.Create(BTCaddr, Network.Main);
var addr = ca.Convert(Network.BTG);
string baseURL = "https://explorer.bitcoingold.org/insight-api/";
List <ICoin> UTXOs = new List <ICoin>();
var unspentCoins = BlockScanner.GetUTXOFromInsight(UTXOs, addr, baseURL);
int z = 1;
}
public void Explorer_Query_P2PKH_BCI()
{
string BTCaddr = "14jkz2hJPqgqqKRhDqMYUx37CycQ7G6Ygy";
BitcoinAddress ca = BitcoinAddress.Create(BTCaddr, Network.Main);
var addr = ca.Convert(Network.BCI);
string baseURL = "https://explorer.bitcoininterest.io/api/";
List <ICoin> UTXOs = new List <ICoin>();
var unspentCoins = BlockScanner.GetUTXOFromInsight(UTXOs, addr, baseURL);
int z = 1;
}
public void Explorer_Query_BCBC()
{
// Create a query and utxo set from an address
string BCBCaddr = "14Z1kt7uUCB8rKwhauXmh5qFdv8cKK9fVj";
BitcoinAddress ca = BitcoinAddress.Create(BCBCaddr, Network.BCBC);
string baseURL = "http://be.cleanblockchain.org";
List <ICoin> UTXOs = new List <ICoin>();
var unspentCoins = BlockScanner.GetUTXOFromABE(UTXOs, ca, baseURL);
int z = 1;
}
internal FsVolumeList(IList <VolumeFailureInfo> initialVolumeFailureInfos, BlockScanner
blockScanner, VolumeChoosingPolicy <FsVolumeImpl> blockChooser)
{
// Tracks volume failures, sorted by volume path.
this.blockChooser = blockChooser;
this.blockScanner = blockScanner;
foreach (VolumeFailureInfo volumeFailureInfo in initialVolumeFailureInfos)
{
volumeFailureInfos[volumeFailureInfo.GetFailedStorageLocation()] = volumeFailureInfo;
}
}
public void Explorer_Query_P2SH_BTCP()
{
string BTCaddr = "38q354WHtHUDFeVXCh4nkQ2UtL66M3FVnK";
BitcoinAddress ca = BitcoinAddress.Create(BTCaddr, Network.Main);
var btcpa = ca.Convert(Network.BTCP);
string baseURL = "https://explorer.btcprivate.org/api";
List <ICoin> UTXOs = new List <ICoin>();
var unspentCoins = BlockScanner.GetUTXOFromInsight(UTXOs, btcpa, baseURL);
int z = 1;
}
/// <exception cref="System.IO.IOException"/>
public virtual void TestChangeVolumeWithRunningCheckDirs()
{
RoundRobinVolumeChoosingPolicy <FsVolumeImpl> blockChooser = new RoundRobinVolumeChoosingPolicy
<FsVolumeImpl>();
conf.SetLong(DFSConfigKeys.DfsDatanodeScanPeriodHoursKey, -1);
BlockScanner blockScanner = new BlockScanner(datanode, conf);
FsVolumeList volumeList = new FsVolumeList(Sharpen.Collections.EmptyList <VolumeFailureInfo
>(), blockScanner, blockChooser);
IList <FsVolumeImpl> oldVolumes = new AList <FsVolumeImpl>();
// Initialize FsVolumeList with 5 mock volumes.
int NumVolumes = 5;
for (int i = 0; i < NumVolumes; i++)
{
FsVolumeImpl volume = Org.Mockito.Mockito.Mock <FsVolumeImpl>();
oldVolumes.AddItem(volume);
Org.Mockito.Mockito.When(volume.GetBasePath()).ThenReturn("data" + i);
FsVolumeReference @ref = Org.Mockito.Mockito.Mock <FsVolumeReference>();
Org.Mockito.Mockito.When(@ref.GetVolume()).ThenReturn(volume);
volumeList.AddVolume(@ref);
}
// When call checkDirs() on the 2nd volume, anther "thread" removes the 5th
// volume and add another volume. It does not affect checkDirs() running.
FsVolumeImpl newVolume = Org.Mockito.Mockito.Mock <FsVolumeImpl>();
FsVolumeReference newRef = Org.Mockito.Mockito.Mock <FsVolumeReference>();
Org.Mockito.Mockito.When(newRef.GetVolume()).ThenReturn(newVolume);
Org.Mockito.Mockito.When(newVolume.GetBasePath()).ThenReturn("data4");
FsVolumeImpl blockedVolume = volumeList.GetVolumes()[1];
Org.Mockito.Mockito.DoAnswer(new _Answer_295(volumeList, newRef)).When(blockedVolume
).CheckDirs();
FsVolumeImpl brokenVolume = volumeList.GetVolumes()[2];
Org.Mockito.Mockito.DoThrow(new DiskChecker.DiskErrorException("broken")).When(brokenVolume
).CheckDirs();
volumeList.CheckDirs();
// Since FsVolumeImpl#checkDirs() get a snapshot of the list of volumes
// before running removeVolume(), it is supposed to run checkDirs() on all
// the old volumes.
foreach (FsVolumeImpl volume_1 in oldVolumes)
{
Org.Mockito.Mockito.Verify(volume_1).CheckDirs();
}
// New volume is not visible to checkDirs() process.
Org.Mockito.Mockito.Verify(newVolume, Org.Mockito.Mockito.Never()).CheckDirs();
NUnit.Framework.Assert.IsTrue(volumeList.GetVolumes().Contains(newVolume));
NUnit.Framework.Assert.IsFalse(volumeList.GetVolumes().Contains(brokenVolume));
NUnit.Framework.Assert.AreEqual(NumVolumes - 1, volumeList.GetVolumes().Count);
}
public ActionResult CoinBalance(string coin, string addresses)
{
List <string> addressList = new List <string>(
addresses.Split(new string[] { "," },
StringSplitOptions.RemoveEmptyEntries));
var invalid = addressList.Where(a => !Bitcoin.IsValidAddress(a)).ToList();
var addressesToCheck = addressList.Except(invalid).ToList();
var scanner = new BlockScanner();
var claimAddresses = Bitcoin.ParseAddresses(addressesToCheck);
Tuple <List <ICoin>, Dictionary <string, double> > claimcoins;
bool usedExplorer = false;
double TotalValue = 0.0;
bool searchError = false;
Dictionary <string, double> balances;
try
{
claimcoins = scanner.GetUnspentTransactionOutputs(claimAddresses, coin, out usedExplorer);
TotalValue = Convert.ToDouble(claimcoins.Item1.Sum(o => ((Money)o.Amount).ToDecimal(MoneyUnit.BTC)));
balances = claimcoins.Item2;
}
catch (Exception e)
{
balances = new Dictionary <string, double>();
searchError = true;
}
using (CoinpanicContext db = new CoinpanicContext())
{
db.IndexCoinInfo.Where(i => i.Coin == coin).ToList();
}
AddressSummary result = new AddressSummary()
{
InvalidAddresses = invalid,
CoinName = BitcoinForks.ForkByShortName[coin].LongName,
Empty = TotalValue <= 0,
Coin = coin,
Balance = Convert.ToString(TotalValue),
UsedExplorer = usedExplorer,
Addresses = addressesToCheck,
SearchError = searchError,
};
return(PartialView(result));
}
private static string createUnsignedTransaction(string coin, string fromAddr, string toAddr, double fee, out string utxos, string ForceCoin = "")
{
var n = BitcoinForks.ForkByShortName[coin].Network;
var destination = BitcoinAddress.Create(toAddr, n);
var origin = BitcoinAddress.Create(fromAddr);
Console.WriteLine("From: " + fromAddr);
Console.WriteLine("To: " + toAddr);
BlockScanner bsc = new BlockScanner();
var balances = bsc.GetUnspentTransactionOutputs(new List <BitcoinAddress>()
{
origin
}, ForceCoin != "" ? ForceCoin : coin, out bool usedExplorer);
//Unspent transaction outputs
var autxos = balances.Item1;
var inputAmount = autxos.Sum(u => ((Money)u.Amount).ToDecimal(MoneyUnit.BTC));
Console.WriteLine("Input Amount: " + Convert.ToString(inputAmount));
decimal txfeeAmount = Convert.ToDecimal(fee);
var transferAmount = Money.Coins(Convert.ToDecimal(inputAmount - txfeeAmount));
var txfeesAmount = Money.Coins(Convert.ToDecimal(txfeeAmount));
var bcdbuilder = new TransactionBuilder();
Transaction BCDtx = bcdbuilder
.AddCoins(coins: autxos)
.Send(destination, transferAmount)
.SetChange(destination)
.SendFees(txfeesAmount)
.BuildTransaction(sign: false);
BCDtx.Version = BitcoinForks.ForkByShortName[coin].TransactionVersion;
string utx = BCDtx.ToHex();
var ustr = NBitcoin.JsonConverters.Serializer.ToString(autxos);
Console.WriteLine("UTXO_Str: " + ustr);
Console.WriteLine("UTX: " + utx);
utxos = ustr;
return(utx);
}
public void TestGenerate()
{
string coin = "BTP";
//Create an unsigned transaction and encode
var scanner = new BlockScanner();
List <string> addresslist = new List <string>()
{
"123qWRaufkCnUfh7WMAmJpKdFDw6zBQkn9",
};
var mydepaddr = "15Lo7GRtK7b8WaYQeynwRFU479FJBSyewr";
var claimAddresses = Bitcoin.ParseAddresses(addresslist);
Tuple <List <ICoin>, Dictionary <string, double> > claimcoins;
claimcoins = scanner.GetUnspentTransactionOutputs(claimAddresses, coin, out bool usedExplorer, estimate: true);
var amounts = scanner.CalculateOutputAmounts_Their_My_Fee(claimcoins.Item1, 0.05, 0.0003 * claimcoins.Item1.Count);
// Generate unsigned tx
var utx = Bitcoin.GenerateUnsignedTX(claimcoins.Item1, amounts, Bitcoin.ParseAddress(mydepaddr),
Bitcoin.ParseAddress(mydepaddr),
coin);
//var w = Bitcoin.GetBlockData(claimcoins.Item1);
BlockData bd = new BlockData()
{
fork = coin,
coins = claimcoins.Item1,
utx = utx,
};
string bdstr = NBitcoin.JsonConverters.Serializer.ToString(bd);
System.IO.File.WriteAllText("D:\\ClaimData.txt", bdstr);
Console.WriteLine(bdstr);
}
public ActionResult InitializeClaim(string claimId, string PublicKeys, string depositAddress, string emailAddress)
{
using (CoinpanicContext db = new CoinpanicContext())
{
CoinClaim userclaim = db.Claims.Where(c => c.ClaimId == claimId).Include(c => c.InputAddresses).First();
// Clean up input
depositAddress = depositAddress.Replace("\n", String.Empty);
depositAddress = depositAddress.Replace("\r", String.Empty);
depositAddress = depositAddress.Replace("\t", String.Empty);
depositAddress = depositAddress.Trim().Replace(" ", "");
userclaim.DepositAddress = depositAddress;
userclaim.Email = emailAddress;
List <string> list = new List <string>(
PublicKeys.Split(new string[] { "\r\n" },
StringSplitOptions.RemoveEmptyEntries));
if (list.Count < 1)
{
return(RedirectToAction("ClaimError", new { message = "You must enter at least one address to claim", claimId = claimId }));
}
// Convert depositAddress if BCH
if (userclaim.CoinShortName == "BCH" && depositAddress.StartsWith("bitcoincash:"))
{
// Convert
depositAddress = SharpCashAddr.Converter.cashAddrToOldAddr(depositAddress, out bool isP2PKH, out _);
}
if (!Bitcoin.IsValidAddress(depositAddress, userclaim.CoinShortName, BitcoinForks.ForkByShortName[userclaim.CoinShortName].Network))
{
return(RedirectToAction("ClaimError", new { message = "Deposit Address not valid", claimId = claimId }));
}
var invalid = list.Where(a => !Bitcoin.IsValidAddress(a));
if (invalid.Count() > 0)
{
return(RedirectToAction("ClaimError", new { message = String.Join(", ", invalid) + (invalid.Count() < 2 ? " is" : " are") + " invalid.", claimId = claimId }));
}
var scanner = new BlockScanner();
var claimAddresses = Bitcoin.ParseAddresses(list);
Tuple <List <ICoin>, Dictionary <string, double> > claimcoins;
try
{
claimcoins = scanner.GetUnspentTransactionOutputs(claimAddresses, userclaim.CoinShortName, out bool usedExplorer);
}
catch (Exception e)
{
return(RedirectToAction("ClaimError", new { message = "Error searching for your addresses in the blockchain", claimId = claimId }));
}
var amounts = scanner.CalculateOutputAmounts_Their_My_Fee(claimcoins.Item1, 0.05, 0.0003 * claimcoins.Item1.Count);
var balances = claimcoins.Item2;
// Return converted addresses to user
List <InputAddress> inputs;
inputs = GetInputAddresses(userclaim, list, balances);
userclaim.InputAddresses = inputs;
userclaim.Deposited = Convert.ToDouble(amounts[0].ToDecimal(MoneyUnit.BTC));
userclaim.MyFee = Convert.ToDouble(amounts[1].ToDecimal(MoneyUnit.BTC));
userclaim.MinerFee = Convert.ToDouble(amounts[2].ToDecimal(MoneyUnit.BTC));
userclaim.TotalValue = userclaim.Deposited + userclaim.MyFee + userclaim.MinerFee;
userclaim.InitializeDate = DateTime.Now;
if (userclaim.Deposited < 0)
{
userclaim.Deposited = 0;
}
if (userclaim.MyFee < 0)
{
userclaim.MyFee = 0;
}
// Generate unsigned tx
var mydepaddr = ConfigurationManager.AppSettings[userclaim.CoinShortName + "Deposit"];
if (userclaim.CoinShortName == "BCH" && mydepaddr.StartsWith("bitcoincash:"))
{
// Convert
mydepaddr = SharpCashAddr.Converter.cashAddrToOldAddr(mydepaddr, out bool isP2PKH, out _);
}
var utx = Bitcoin.GenerateUnsignedTX(
UTXOs: claimcoins.Item1,
amounts: amounts,
clientDepAddr: Bitcoin.ParseAddress(depositAddress, userclaim.CoinShortName, BitcoinForks.ForkByShortName[userclaim.CoinShortName].Network),
MyDepositAddr: Bitcoin.ParseAddress(mydepaddr, userclaim.CoinShortName, BitcoinForks.ForkByShortName[userclaim.CoinShortName].Network),
forkShortName: userclaim.CoinShortName);
userclaim.UnsignedTX = utx;
// Generate witness data
var w = Bitcoin.GetBlockData(claimcoins.Item1);
userclaim.BlockData = w;
// New format of message
BlockData bd = new BlockData()
{
fork = userclaim.CoinShortName,
coins = claimcoins.Item1,
utx = utx,
addresses = balances.Select(kvp => kvp.Key).ToList(),
};
string bdstr = NBitcoin.JsonConverters.Serializer.ToString(bd);
userclaim.ClaimData = bdstr;
db.SaveChanges();
MonitoringService.SendMessage("New " + userclaim.CoinShortName + " claim", "new claim Initialized. https://www.coinpanic.com/Claim/ClaimConfirm?claimId=" + claimId + " " + " for " + userclaim.CoinShortName);
}
return(RedirectToAction("ClaimConfirm", new { claimId = claimId }));
}
