public static T ToNetwork <T>(this T base58, Network network) where T : Base58Data
{
if (network == null)
{
throw new ArgumentNullException("network");
}
if (base58.Network == network)
{
return(base58);
}
if (base58 == null)
{
throw new ArgumentNullException("base58");
}
var inner = base58.ToBytes();
if (base58.Type != Base58Type.COLORED_ADDRESS)
{
byte[] version = network.GetVersionBytes(base58.Type);
var newBase58 = Encoders.Base58Check.EncodeData(version.Concat(inner).ToArray());
return(Network.CreateFromBase58Data <T>(newBase58, network));
}
else
{
var colored = BitcoinColoredAddress.GetWrappedBase58(base58.ToWif(), base58.Network);
var address = Network.CreateFromBase58Data <BitcoinAddress>(colored).ToNetwork(network);
return((T)(object)address.ToColoredAddress());
}
}
private void FormDetails_Load(object sender, EventArgs e)
{
string address = "";
string bitcoinAddress = "";
string hash = "";
string script = "";
string base58Type = "";
Type type = Address.GetType();
using (new HourGlass())
{
switch (type.ToString())
{
case "NBitcoin.BitcoinScriptAddress":
BitcoinScriptAddress bsa = Address as BitcoinScriptAddress;
bitcoinAddress = bsa.ToString();
hash = bsa.Hash.ToString();
script = bsa.ScriptPubKey.ToString();
base58Type = bsa.Type.ToString();
break;
case "NBitcoin.BitcoinAddress":
BitcoinAddress ba = Address as BitcoinAddress;
bitcoinAddress = ba.ToString();
hash = ba.Hash.ToString();
script = ba.ScriptPubKey.ToString();
base58Type = ba.Type.ToString();
break;
case "NBitcoin.Stealth.BitcoinStealthAddress":
BitcoinStealthAddress stealth = Address as BitcoinStealthAddress;
bitcoinAddress = stealth.ToString();
hash = stealth.ScanPubKey.Hash.ToString();
script = stealth.ScanPubKey.ScriptPubKey.ToString();
base58Type = stealth.Type.ToString();
break;
case "NBitcoin.BitcoinColoredAddress":
BitcoinColoredAddress colored = Address as BitcoinColoredAddress;
address = colored.ToString();
bitcoinAddress = colored.Address.ToString();
hash = colored.Address.Hash.ToString();
script = colored.ScriptPubKey.ToString();
base58Type = colored.Type.ToString();
break;
default:
textBoxType.Text = type.ToString();
break;
}
}
textBoxAddress.Text = address;
textBoxBitcoinAddress.Text = bitcoinAddress;
textBoxPubHash.Text = hash;
textBoxScriptPubKey.Text = script;
textBoxType.Text = base58Type;
textBoxBitcoinAddress.Focus();
}
private string GetUncoloredAddress(string address)
{
if (BitcoinAddressHelper.IsBitcoinColoredAddress(address, _network))
{
var coloredAddress = new BitcoinColoredAddress(address, _network);
return(coloredAddress.Address.ToString());
}
return(address);
}
public static bool IsBitcoinColoredAddress(string base58, Network network)
{
try
{
var notUsed = new BitcoinColoredAddress(base58, network);
return(true);
}
catch (Exception)
{
return(false);
}
}
public uint256 IssueAsset(BitcoinAddress sourceAddress, BitcoinColoredAddress toAddress, int amount)
{
uint256 txid = null;
try
{
txid = IssueAssetAsync(sourceAddress, toAddress, amount).Result;
}
catch (AggregateException aex)
{
ExceptionDispatchInfo.Capture(aex.InnerException).Throw();
}
return(txid);
}
/// <summary>
/// Simple method to add a person to a community.
/// A new issuance coin is used for every invite.
/// This is so that the colored coin can be traced back to the inviters scriptPubKey.
/// The payment of the community application coin to the registration address adds the new
/// community to the community registration address list. This enables the referencing of a
/// community through its public key.
/// </summary>
/// <param name="rpcClient"></param>
/// <param name="community"></param>
/// <param name="member"></param>
/// <param name="invitee"></param>
/// <param name="definitionUrl"></param>
/// <returns></returns>
public static bool Invite(RPCClient rpcClient, Community community, CommunityMember member, CommunityMember invitee, string definitionUrl, Network network)
{
decimal amount = 0.0001m;
Script scriptPubKey = new Script();
uint256 transactionId = new uint256();
bool canProceed = false;
//check is member belongs in community to which they are inviting invitee
if (IsCommunityMember(community, member))
{
//check that the inviter has at least one transaction balance that is big enough for the current transaction.
UnspentCoin[] transactions = rpcClient.ListUnspent();
for (int i = 0; i < transactions.Length; i++)
{
if (transactions[i].Amount.ToUnit(MoneyUnit.Satoshi) >= amount)
{
scriptPubKey = transactions[i].ScriptPubKey;
transactionId = transactions[i].OutPoint.Hash;
canProceed = true;
break;
}
}
if (!canProceed)
{
return(false);
}
IssuanceCoin issuanceCoin = MarketService.IssueCoin(transactionId, scriptPubKey, definitionUrl);
//build and verify the transaction
BitcoinColoredAddress inviteePubKey = BitcoinAddress.Create(invitee.Key).ToColoredAddress();
BitcoinSecret bitcoinSecret = new BitcoinSecret(community.Key);
Transaction transaction = MarketService.BuildCommunityTransaction(issuanceCoin, inviteePubKey, bitcoinSecret, amount, 1);
if (transaction != null)
{
MarketService.Broadcast(transaction, network);
return(true);
}
}
return(false);
}
public async Task <IAddressMainInfo> GetMainInfoAsync(string id)
{
if (BitcoinAddressHelper.IsBitcoinColoredAddress(id, _appSettings.BcnExploler.UsedNetwork()))
{
var result = new BitcoinColoredAddress(id, _appSettings.BcnExploler.UsedNetwork());
return(new AddressMainInfo
{
AddressId = id,
ColoredAddress = result.ToWif(),
UncoloredAddress = result.Address.ToString(),
IsColored = true
});
}
if (BitcoinAddressHelper.IsBitcoinPubKeyAddress(id, _appSettings.BcnExploler.UsedNetwork()))
{
var result = new BitcoinPubKeyAddress(id, _appSettings.BcnExploler.UsedNetwork());
return(new AddressMainInfo
{
AddressId = id,
ColoredAddress = result.ToColoredAddress().ToWif(),
UncoloredAddress = result.ToString(),
IsColored = false
});
}
if (BitcoinAddressHelper.IsBitcoinScriptAddress(id, _appSettings.BcnExploler.UsedNetwork()))
{
var result = new BitcoinScriptAddress(id, _appSettings.BcnExploler.UsedNetwork());
return(new AddressMainInfo
{
AddressId = id,
ColoredAddress = result.ToColoredAddress().ToWif(),
UncoloredAddress = result.ToString(),
IsColored = false
});
}
return(null);
}
/// <summary>
/// Builds a colored coin transaction.
/// </summary>
/// <param name="issuanceCoin"></param>
/// <param name="destinitionPubKey"></param>
/// <param name="bitcoinSecret"></param>
/// <param name="amount"></param>
/// <param name="quantity"></param>
/// <returns></returns>
public static Transaction BuildCommunityTransaction
(IssuanceCoin issuanceCoin, BitcoinColoredAddress destinitionPubKey, BitcoinSecret bitcoinSecret, decimal amount, int quantity)
{
TransactionBuilder transactionBuilder = new TransactionBuilder();
Transaction transaction = transactionBuilder
.AddKeys(bitcoinSecret)
.AddCoins(issuanceCoin)
.IssueAsset(destinitionPubKey, new AssetMoney(issuanceCoin.AssetId, quantity: quantity))
.SendFees(Money.Coins(amount))
.SetChange(bitcoinSecret.GetAddress())
.BuildTransaction(true);
if (transactionBuilder.Verify(transaction))
{
return(transaction);
}
return(null);
}
public void temp()
{
var client = CreateClient();
client.Colored = true;
var colored = new BitcoinColoredAddress("akDqb3L5hC2MRzzZNhhZyrRLJSS8HXysKrF");
var balance = client.GetBalance(colored).Result;
Money coins = new Money(0);
foreach (var op in balance.Operations)
{
var tx = client.GetTransaction(op.TransactionId).Result;
foreach (var i in op.ReceivedCoins)
{
if (!(i.GetType() == typeof(ColoredCoin)))
{
continue;
}
var cc = (ColoredCoin)i;
var dest = cc.ScriptPubKey.GetDestinationAddress(Network.Main).ToColoredAddress();
coins += i.Amount;
Debug.WriteLine("{0} to {1}", i.Amount.ToUnit(MoneyUnit.Bit), dest);
}
foreach (var s in op.SpentCoins)
{
if (!(s.GetType() == typeof(ColoredCoin)))
{
continue;
}
var cc = (ColoredCoin)s;
var dest = cc.ScriptPubKey.PaymentScript.PaymentScript.GetDestinationAddress(Network.Main).ToColoredAddress();
coins -= s.Amount;
// breakpoint here:
Debug.WriteLine("-{0} to {1}", s.Amount.ToUnit(MoneyUnit.Bit), dest);
}
Debug.WriteLine("balance: {0}", coins.ToUnit(MoneyUnit.Bit));
}
}
public async Task <uint256> IssueAssetAsync(BitcoinAddress sourceAddress, BitcoinColoredAddress toAddress, long amount)
{
List <object> parameters = new List <object>();
parameters.Add(sourceAddress.ToString());
parameters.Add(amount.ToString());
List <string> paramNames = new List <string>();
paramNames.Add("address");
paramNames.Add("amount");
if (toAddress != null)
{
parameters.Add(toAddress.ToString());
paramNames.Add("to");
}
var resp = await SendCommandAsync(RPCOperations.issueasset, paramNames.ToArray(), parameters.ToArray()).ConfigureAwait(false);
return(uint256.Parse(resp.Result.ToString().Replace("\"", string.Empty)));
}
public void CanParseColoredAddress()
{
var address = new BitcoinPubKeyAddress("16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM", this.networkMain);
BitcoinColoredAddress colored = address.ToColoredAddress();
Assert.Equal("akB4NBW9UuCmHuepksob6yfZs6naHtRCPNy", colored.ToWif());
Assert.Equal(address.ScriptPubKey, colored.ScriptPubKey);
BitcoinPubKeyAddress testAddress = address.ToNetwork(this.networkTest);
BitcoinColoredAddress testColored = testAddress.ToColoredAddress();
Assert.Equal(this.networkTest, testAddress.Network);
Assert.Equal(address.Hash, testAddress.Hash);
Assert.Equal(colored.ToNetwork(this.networkTest), testColored);
Assert.Equal(testAddress.ScriptPubKey, testColored.ScriptPubKey);
Assert.Equal(this.networkTest, testColored.Network);
testColored = new BitcoinColoredAddress("bWqaKUZETiECYgmJNbNZUoanBxnAzoVjCNx");
Assert.Contains(testColored.Network, new[] { this.networkRegTest, this.networkTest });
Assert.Equal(colored.ToNetwork(this.networkTest), testColored);
}
public void CanParseColoredAddress()
{
var address = new BitcoinAddress("16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM");
var colored = address.ToColoredAddress();
Assert.Equal("akB4NBW9UuCmHuepksob6yfZs6naHtRCPNy", colored.ToWif());
Assert.Equal(address.ScriptPubKey, colored.ScriptPubKey);
var testAddress = address.ToNetwork(Network.TestNet);
var testColored = testAddress.ToColoredAddress();
Assert.Equal(Network.TestNet, testAddress.Network);
Assert.Equal(address.Hash, testAddress.Hash);
Assert.Equal(colored.ToNetwork(Network.TestNet), testColored);
Assert.Equal(testAddress.ScriptPubKey, testColored.ScriptPubKey);
Assert.Equal(Network.TestNet, testColored.Network);
testColored = new BitcoinColoredAddress("bWqaKUZETiECYgmJNbNZUoanBxnAzoVjCNx");
Assert.Equal(Network.TestNet, testColored.Network);
Assert.Equal(colored.ToNetwork(Network.TestNet), testColored);
}
public string NormalizeOrDefault(string address, bool isTransactionNormalization = false)
{
try
{
var bitcoinAddress = BitcoinAddress.Create(address, _network);
return(bitcoinAddress.ToString());
}
catch (FormatException)
{
try
{
var coloredAddress = new BitcoinColoredAddress(address, _network);
var bitcoinAddress = coloredAddress.ScriptPubKey.GetDestinationAddress(_network);
return(bitcoinAddress.ToString());
}
catch (FormatException)
{
return(null);
}
}
}
public WhatIsColoredAddress(BitcoinColoredAddress colored)
: base(colored)
{
UncoloredAddress = colored.Address;
}
public void CanParseColoredAddress()
{
var address = new BitcoinAddress("16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM");
var colored = address.ToColoredAddress();
Assert.Equal("akB4NBW9UuCmHuepksob6yfZs6naHtRCPNy", colored.ToWif());
Assert.Equal(address.ScriptPubKey, colored.ScriptPubKey);
var testAddress = address.ToNetwork(Network.TestNet);
var testColored = testAddress.ToColoredAddress();
Assert.Equal(Network.TestNet, testAddress.Network);
Assert.Equal(address.Hash, testAddress.Hash);
Assert.Equal(colored.ToNetwork(Network.TestNet), testColored);
Assert.Equal(testAddress.ScriptPubKey, testColored.ScriptPubKey);
Assert.Equal(Network.TestNet, testColored.Network);
testColored = new BitcoinColoredAddress("bWqaKUZETiECYgmJNbNZUoanBxnAzoVjCNx");
Assert.Equal(Network.TestNet, testColored.Network);
Assert.Equal(colored.ToNetwork(Network.TestNet), testColored);
}
private static async Task <UnsignedClientCommitmentTransactionResponse> GetOffchainSignedSetup
(string[] privateKeys)
{
var settings = settingsProvider.GetSettings();
var clientPrivateKey = new BitcoinSecret(privateKeys[0]);
var hubPrivateKey = new BitcoinSecret(privateKeys[1]);
var hubSelfRevokKey = new BitcoinSecret(privateKeys[3]);
var multisig = GetMultiSigFromTwoPubKeys(clientPrivateKey.PubKey, hubPrivateKey.PubKey);
var coloredRPC = GetColoredRPCClient(settings as IBlockchainStateManagerSettings);
BitcoinColoredAddress[] addresses = new BitcoinColoredAddress[3];
addresses[0] = clientPrivateKey.PubKey.WitHash.ScriptPubKey.GetScriptAddress(settings.Network).ToColoredAddress(); // c74X52L89exgnqwrFmeKzZTAxi49sLxqoNS
addresses[1] = hubPrivateKey.PubKey.WitHash.ScriptPubKey.GetScriptAddress(settings.Network).ToColoredAddress(); // c7Acx1CTvvwPr9kEa91roJDeNLjB1evkXWG
addresses[2] = BitcoinAddress.Create(multisig.SegwitMultiSigAddress).ToColoredAddress(); // c7GuJuSS5aNg9s791bDk6RgSpYCge3kaiHn
long[] valuesToSend = new long[3];
valuesToSend[0] = 100 * DESIREDASSETMULTIPLICATIONFACTOR;
valuesToSend[1] = 100 * DESIREDASSETMULTIPLICATIONFACTOR;
valuesToSend[2] = 85 * DESIREDASSETMULTIPLICATIONFACTOR;
uint256[] txIds = new uint256[3];
for (int i = 0; i < 3; i++)
{
if (ASSET.ToLower().Trim() == "btc")
{
txIds[i] = await daemonHelper.SendBitcoinToDestination(addresses[i].Address, valuesToSend[i]);
}
else
{
txIds[i] = await coloredRPC.IssueAssetAsync(Constants.USDAssetPrivateKey.GetAddress(), addresses[i], valuesToSend[i]);
}
}
var bitcoinRPCCLient = GetRPCClient(settings as IBlockchainStateManagerSettings);
var blkIds = await bitcoinRPCCLient.GenerateBlocksAsync(1);
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasBlockIndexed, blkIds);
for (int i = 0; i < txIds.Count(); i++)
{
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasTransactionIndexed, new string[] { txIds[i].ToString() });
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed(blockchainExplorerHelper.HasBalanceIndexed,
new string[] { txIds[i].ToString() }, addresses[i].Address.ToString());
}
var unsignedChannelsetup = await offchainHelper.GenerateUnsignedChannelSetupTransaction
(clientPrivateKey.PubKey, 10, hubPrivateKey.PubKey, 10, ASSET, 7);
var clientSignedTx = await Helper.SignTransactionWorker(new TransactionSignRequest
{
TransactionToSign = unsignedChannelsetup.UnsigndTransaction,
PrivateKey = clientPrivateKey.ToString()
});
var unsignedResp = await offchainHelper.CreateUnsignedClientCommitmentTransaction
(unsignedChannelsetup.UnsigndTransaction, clientSignedTx, 30, 75, clientPrivateKey.PubKey,
hubPrivateKey.ToString(), ASSET, hubSelfRevokKey.PubKey, 144);
return(unsignedResp);
}
