public async Task <IActionResult> Edit(int id, [Bind("ID,highest,lowest,high,low,reading")] Bitcoin bitcoin)
{
if (id != bitcoin.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(bitcoin);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BitcoinExists(bitcoin.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(bitcoin));
}
public void Create2(float ihighest, float ilowest, float ihigh, float ilow, DateTime ireading)
{
Bitcoin a = new Bitcoin(ihighest, ilowest, ihigh, ilow, ireading);
_context.Add(a);
_context.SaveChangesAsync();
}
public ActionResult DeleteConfirmed(int id)
{
Bitcoin bitcoin = bitcoinRepository.GetById(id);
bitcoinRepository.Delete(bitcoin);
return(RedirectToAction("Index"));
}
public void MinerTransactions()
{
if (ValidateValueTransactions())
{
var coinBase = CreateCoinBase();
var transactions = new List <Transaction>();
transactions.Add(coinBase);
transactions.AddRange(Bitcoin.TransactionPool);
var previousBlock = Bitcoin.returnLastBlock();
var newBlock = new Block(previousBlock.Index + 1, previousBlock.Hash, transactions);
var nonce = 0;
do
{
newBlock.Hash = newBlock.GenerateHashBlock(nonce);
nonce++;
} while (newBlock.Hash.Substring(0, Bitcoin.Difficulty) != new string('0', Bitcoin.Difficulty));
ExcludeUtxo();
CreateUtxo();
Bitcoin.Chain.Add(newBlock);
Bitcoin.TransactionPool.Clear();
}
}
public void CheckConversion()
{
var unit = new FixedPrecisionUnit <Bitcoin.BTC>(12.345M);
var mBTC = Bitcoin.Convert <Bitcoin.BTC, Bitcoin.mBTC>(unit);
Assert.AreEqual(mBTC.Value, 12345M);
}
public void TestBitcoinWithdraw()
{
Bitcoin bitcoin = new Bitcoin();
double expected = 14.7;
bitcoin.Withdraw(13.3);
Assert.AreEqual(expected, bitcoin.GetBalance());
}
public void TestBitcoinDeposit()
{
Bitcoin bitcoin = new Bitcoin();
double expected = 30.9;
bitcoin.Deposit(2.9);
Assert.AreEqual(expected, bitcoin.GetBalance());
}
public void TestBitAdapterBalance()
{
Bitcoin bitcoin = new Bitcoin();
BitcoinToUSDollarsAdapter bitcoinAdapter = new BitcoinToUSDollarsAdapter(bitcoin);
double expected = 28 * 48475.30;
Assert.AreEqual(expected, bitcoinAdapter.GetBalance());
}
public async Task <IActionResult> Create([Bind("ID,highest,lowest,high,low,reading")] Bitcoin bitcoin)
{
if (ModelState.IsValid)
{
_context.Add(bitcoin);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(bitcoin));
}
public ActionResult Create(Bitcoin btc)
{
using (DatabaseContext db = new DatabaseContext())
{
db.Bitcoin.Add(btc);
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
public void Awake()
{
i = this;
t = Object.FindObjectOfType<Transport>();
Developer = new Developer(t);
Game = new Game(t);
Player = new Player(t);
Tip = new Tip(t);
Bitcoin = new Bitcoin(t);
}
/// <summary>
/// Event Handler for Bitcoin Data Events: These Bitcoin objects are created from our
/// "Bitcoin" type below and fired into this event handler.
/// </summary>
/// <param name="data">One(1) Bitcoin Object, streamed into our algorithm synchronised in time with our other data streams</param>
public void OnData(Bitcoin data)
{
//If we don't have any bitcoin "SHARES" -- invest"
if (!Portfolio.Invested)
{
//Bitcoin used as a tradable asset, like stocks, futures etc.
if (data.Close != 0)
{
Order("BTC", (Portfolio.Cash / Math.Abs(data.Close + 1)));
}
}
}
/// <summary>
/// Event Handler for Bitcoin Data Events: These Bitcoin objects are created from our
/// "Bitcoin" type below and fired into this event handler.
/// </summary>
/// <param name="data">One(1) Bitcoin Object, streamed into our algorithm synchronised in time with our other data streams</param>
public void OnData(Bitcoin data)
{
//If we don't have any bitcoin "SHARES" -- invest"
if (!Portfolio.Invested)
{
//Bitcoin used as a tradable asset, like stocks, futures etc.
if (data.Close != 0)
{
Order("BTC", (Portfolio.Cash / Math.Abs(data.Close + 1)));
}
}
}
public void TestBitAdapterDeposit()
{
Bitcoin bitcoin = new Bitcoin();
BitcoinToUSDollarsAdapter bitcoinAdapter = new BitcoinToUSDollarsAdapter(bitcoin);
var amount = 48475.30;
bitcoinAdapter.Deposit(amount);
double expected = 29 * 48475.30;
Assert.AreEqual(expected, bitcoinAdapter.GetBalance());
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Bitcoin bitcoin = bitcoinRepository.GetById(id);
if (bitcoin == null)
{
return(HttpNotFound());
}
return(View(bitcoin));
}
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));
}
/// <summary>
/// Event Handler for Bitcoin Data Events: These weather objects are created from our
/// "Weather" type below and fired into this event handler.
/// </summary>
/// <param name="data">One(1) Weather Object, streamed into our algorithm synchronised in time with our other data streams</param>
public void OnData(Bitcoin data)
{
//If we don't have any weather "SHARES" -- invest"
if (!Portfolio.Invested)
{
//Weather used as a tradable asset, like stocks, futures etc.
if (data.Close != 0)
{
Order("BTC", (Portfolio.Cash / Math.Abs(data.Close + 1)));
}
Console.WriteLine("Buying BTC 'Shares': BTC: " + data.Close);
}
Console.WriteLine("Time: " + Time.ToLongDateString() + " " + Time.ToLongTimeString() + data.Close.ToString());
}
public async Task <ActionResult> Fetch(string source)
{
if (source == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Bitcoin coin = null;
ApiService service = new ApiService();
if (coin == null)
{
return(HttpNotFound());
}
return(View(coin));
}
public static void Run()
{
Console.WriteLine("=-=-=-=ChainOfResponsibility=-=-=-=");
var bank = new Bank(100); // Bank with balance 100
var paypal = new Paypal(200); // Paypal with balance 200
var bitcoin = new Bitcoin(300); // Bitcoin with balance 300
bank.SetNext(paypal);
paypal.SetNext(bitcoin);
// Let's try to pay using the first priority i.e. bank
bank.Pay(259);
Console.WriteLine("----------------------------------" + Environment.NewLine);
}
const STATUS_SOLD = 2; // Has been sold
/// <summery>
/// Check if the user has credits or BTC to list the product
///
/// <typeparam name=""></typeparam> mixed userID
/// <typeparam name=""></typeparam> mixed paymentType
/// <returns></returns> boolean
/// </summery>
public function hasMoneyToListProduct(userID, paymentType = ShopProduct.LIST_FEE_PAYMENT_TYPE_BTC)
{
if (paymentType == ShopProduct.LIST_FEE_PAYMENT_TYPE_CREDIT)
{
tradeUserIns = new TradeUser();
return(tradeUserIns.hasCredits(userID, SHOP_PRODUCT_LISTING_FEE_IN_CREDIT));
}
else if (paymentType == ShopProduct.LIST_FEE_PAYMENT_TYPE_BTC)
{
balance = Bitcoin.getUserWalletBalance(userID);
return(balance >= SHOP_PRODUCT_LISTING_FEE_IN_BTC);
}
else
{
return(false);
}
}
static async Task Main(string[] args)
{
var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync("127.0.0.1");
var redisDb = connectionMultiplexer.GetDatabase(1);
if (redisDb == null)
{
throw new ApplicationException("Could not establish connection with the Redis database");
}
while (true)
{
var newPrivateKeyBytes = new Bitcoin().GenerateBitcoinKeyByte();
var value = Convert.ToBase64String(newPrivateKeyBytes);
var key = $"Phase0:Worker1:{value}";
var streamValue = new NameValueEntry[1];
streamValue[0] = new NameValueEntry(key, value);
await redisDb
.StreamAddAsync("Phase0", streamValue)
.ConfigureAwait(false);
// var verifiedKey = Convert.FromBase64String(key);
}
// var random = PrivateKey.CreatePrivateKey(Globals.ProdDumpKeyVersion);
// var seedBytes = random.PrivateKeyBytes;
// //create a private key using seedBytes and not supplying compressedPublicKey which by default forces the public key to be compressed
// var pkCompressed = new PrivateKey(Globals.ProdDumpKeyVersion, seedBytes);
// //get the wif encoded string that represents the pkCompressed private key
// var wifCompressed = pkCompressed.WIFEncodedPrivateKeyString;
// //here we can create a bitcoin address string using the public key ascociated with our private key
// var bitcoinAddressCompressed = BitcoinAddress.GetBitcoinAdressEncodedStringFromPublicKey(pkCompressed.PublicKey);
// //create a private key using seedBytes which forces the public key to be compressed and supplying compressedPublicKey as false so the public key will not be compressed
// var pkNotCompressed = new PrivateKey(Globals.ProdDumpKeyVersion, seedBytes, false);
// var wif = pkNotCompressed.WIFEncodedPrivateKeyString;
// var bitcoinAddress = BitcoinAddress.GetBitcoinAdressEncodedStringFromPublicKey(pkNotCompressed.PublicKey);
// Console.WriteLine($"{bitcoinAddressCompressed} | {random.ToString()}");
// Console.WriteLine($"{bitcoinAddress} | {wif}");
}
/// <summery>
/// Check if you have money or credits
///
/// <typeparam name=""></typeparam> mixed userID
/// <typeparam name=""></typeparam> mixed paymentType
/// <returns></returns> bool
/// </summery>
public function hasMoneyToListTradeItem(userID, paymentType = TradeItem.LIST_FEE_PAYMENT_TYPE_BTC)
{
if (paymentType == TradeItem.LIST_FEE_PAYMENT_TYPE_CREDIT)
{
tradeUserIns = new TradeUser();
return(tradeUserIns.hasCredits(userID, TRADE_ITEM_LISTING_FEE_IN_CREDIT));
}
else if (paymentType == TradeItem.LIST_FEE_PAYMENT_TYPE_BTC)
{
balance = Bitcoin.getUserWalletBalance(userID);
return(balance >= TRADE_ITEM_LISTING_FEE_IN_BTC);
}
else
{
return(false);
}
}
//Fetch price
public async Task <ActionResult> Fetch()
{
Bitcoin bitcoin = new Bitcoin();
BitcoinRepository repo = new BitcoinRepository();
ApiService service = new ApiService();
string url = "https://www.bitstamp.net/api/ticker/";
var model = service.GetBitstampAsync(url);
var result = await model;
bitcoin.Source = url;
bitcoin.Price = Decimal.Parse(result.ask);
bitcoin.Date = DateTime.Now;
int lastId = repo.Insert(bitcoin);
return(RedirectToAction("Details", "Bitcoins", new { id = lastId }));
}
// GET: Coindesk
public async Task <ActionResult> Fetch()
{
Bitcoin bitcoin = new Bitcoin();
BitcoinRepository repo = new BitcoinRepository();
ApiService service = new ApiService();
string url = "https://api.coindesk.com/v1/bpi/currentprice/USD.json";
var model = service.GetCoindeskAsync(url);
var result = await model;
bitcoin.Source = url;
bitcoin.Price = result.bpi.usd.rate;
bitcoin.Date = DateTime.Now;
int lastId = repo.Insert(bitcoin);
return(RedirectToAction("Details", "Bitcoins", new { id = lastId }));
}
// GET: Gdax
public async Task <ActionResult> Fetch()
{
Bitcoin bitcoin = new Bitcoin();
BitcoinRepository repo = new BitcoinRepository();
ApiService service = new ApiService();
string url = "https://api.gdax.com/products/BTC-USD/ticker";
var model = service.GetGdaxAsync(url);
var result = await model;
bitcoin.Source = url;
bitcoin.Price = result.Price;
bitcoin.Date = DateTime.Now;
int lastId = repo.Insert(bitcoin);
return(RedirectToAction("Details", "Bitcoins", new { id = lastId }));
}
public static void savePlayer()
{
string[] path = new string[] { HealthSave, BitcoinSave, FireWallSave, CrackerSave, OsSave, PlayerNameSave, PlayerTitleSave, ScannerSave, XpSave, DownloadSpeedSave, UploadSpeedSave, ConnectionSave, ipAddressSave };
string[] contents = new string[] { Health.ToString(), Bitcoin.ToString(), Firewall.ToString(), Cracker.ToString(), OperatingSystem.ToString(), PlayerName, PlayerTitle, Scanner.ToString(), Xp.ToString(), downSpeed.ToString(), upSpeed.ToString(), connectionStatus, ipAddress };
for (int i = 0; i < path.Length; i++)
{
string item = path[i];
string content = contents[i];
try
{
File.Delete(item);
}
catch
{
Console.WriteLine("savePlayer(File.Delete) return inoperatable....no big deal, continue...");
}
StreamWriter saveGame = new StreamWriter(File.Open(item, FileMode.OpenOrCreate));
saveGame.Write(content);
saveGame.Close();
}
}//save everything done to [player]
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
MallardDuck duck = new MallardDuck();
WildTurkey turkey = new WildTurkey();
IDuck turkeyAdapter = new TurkeyAdapter(turkey);
Console.WriteLine("The Turkey says...");
turkey.Gobble();
turkey.Fly();
Console.WriteLine("\nThe Duck says...");
testDuck(duck);
Console.WriteLine("\nThe TurkeyAdapter says...");
testDuck(turkeyAdapter);
Bitcoin bitcoin = new Bitcoin();
USDollars usd = new USDollars();
IBit bitAdapter = new BitcoinToUSDollarsAdapter(bitcoin);
IUSD usdAdapter = new USDollarToBitcoinAdapter(usd);
Console.WriteLine($"\nYou have ${usd.GetBalance()} in your account.");
Console.WriteLine($"\nYou have {bitcoin.GetBalance()} bitcoins in your account.");
bitAdapter.Deposit(5000);
usdAdapter.Deposit(1.5);
Console.WriteLine($"\nYou have ${usd.GetBalance()} in your account.");
Console.WriteLine($"\nYou have {bitcoin.GetBalance()} bitcoins in your account.");
}
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);
}
private static List <InputAddress> GetInputAddresses(CoinClaim userclaim, List <string> list, Dictionary <string, double> balances = null)
{
List <InputAddress> inputs;
if (userclaim.CoinShortName == "BTCP")
{
inputs = list.Select(li => new InputAddress()
{
AddressId = Guid.NewGuid(),
PublicAddress = li + " -> " + Bitcoin.ParseAddress(li).Convert(Network.BTCP).ToString(),
CoinShortName = userclaim.CoinShortName,
ClaimId = userclaim.ClaimId,
ClaimValue = balances != null ? balances[li] : -1,
}).ToList();
}
else if (userclaim.CoinShortName == "BCI")
{
inputs = list.Select(li => new InputAddress()
{
AddressId = Guid.NewGuid(),
PublicAddress = li + " -> " + Bitcoin.ParseAddress(li).Convert(Network.BCI).ToString(),
CoinShortName = userclaim.CoinShortName,
ClaimId = userclaim.ClaimId,
ClaimValue = balances != null ? balances[li] : -1,
}).ToList();
}
else if (userclaim.CoinShortName == "BCA")
{
inputs = list.Select(li => new InputAddress()
{
AddressId = Guid.NewGuid(),
PublicAddress = li + " -> " + Bitcoin.ParseAddress(li).Convert(Network.BCA).ToString(),
CoinShortName = userclaim.CoinShortName,
ClaimId = userclaim.ClaimId,
ClaimValue = balances != null ? balances[li] : -1,
}).ToList();
}
else if (userclaim.CoinShortName == "BTG")
{
inputs = list.Select(li => new InputAddress()
{
AddressId = Guid.NewGuid(),
PublicAddress = li + " -> " + Bitcoin.ParseAddress(li).Convert(Network.BTG).ToString(),
CoinShortName = userclaim.CoinShortName,
ClaimId = userclaim.ClaimId,
ClaimValue = balances != null ? balances[li] : -1,
}).ToList();
}
else
{
inputs = list.Select(li => new InputAddress()
{
AddressId = Guid.NewGuid(),
PublicAddress = li,
CoinShortName = userclaim.CoinShortName,
ClaimId = userclaim.ClaimId,
ClaimValue = balances != null ? balances[li] : -1,
}).ToList();
}
return(inputs);
}
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 }));
}
//insert
public int Insert(Bitcoin bitcoin)
{
db.Entry(bitcoin).State = EntityState.Added;
db.SaveChanges();
return(bitcoin.Id);
}
//delete
public void Delete(Bitcoin bitcoin)
{
db.Entry(bitcoin).State = EntityState.Deleted;
db.SaveChanges();
}
