void SetMnemonic(Mnemonic mnemonic)
 {
     _mnemonic     = mnemonic;
     LegacyAddress = _mnemonic.DeriveExtKey().GetPublicKey().GetAddress(ScriptPubKeyType.Legacy, Network.Main)
                     .ToString();
     PublicId = _mnemonic.DeriveExtKey().GetPublicKey().GetAddress(ScriptPubKeyType.SegwitP2SH, Network.Main)
                .ToString();
 }
Beispiel #2
0
        public void CreateHDWallet()
        {
            // 通过已知的助记词生成账号
            var wallet  = new Wallet(Words, Password);
            var account = wallet.GetAccount(0);

            Console.WriteLine(account.Address);
            var prk    = wallet.GetPrivateKey(account.Address);//获取账号对应的秘钥
            var accprk = account.PrivateKey;

            Console.WriteLine("the prk is {0}", prk.ToHex());
            Console.WriteLine("the accprk is {0}", accprk);
            // 第一次创建钱包 生成随机的助记词 并保存
            var mnemonic = new Mnemonic(Wordlist.English, WordCount.Twelve);

            Console.WriteLine(mnemonic.ToString());
            var masterKey  = mnemonic.DeriveExtKey("123456"); //生成一组组秘钥对   可以通过该秘钥继续生成子孙密钥对
            var privateKey = masterKey.PrivateKey;            //获取的是bitcoin的私钥

            var wallet1 = new  Wallet(mnemonic.ToString(), "123456");

            Console.WriteLine("the wallet1 mnemonic is {0}", mnemonic.ToString());
            var account1 = wallet1.GetAccount(0);

            Console.WriteLine("the wallet1 account is {0}", account1.Address);
            var keySvc = new KeyStoreService();
            var json   = keySvc.EncryptAndGenerateDefaultKeyStoreAsJson("123456", account1.PrivateKey.HexToByteArray(),
                                                                        account1.Address);
            var path = string.Format(@"e:\{0}.json", keySvc.GenerateUTCFileName(account1.Address));

            File.WriteAllText(path, json);
        }
Beispiel #3
0
        public void Slip77Tests()
        {
            //test vector: https://github.com/vulpemventures/slip77/commit/bc0fa0c712512d27cf1e2d6e1aaee5c36a3d38fa
            var allMnemonic = new Mnemonic("all all all all all all all all all all all all");
            var master      = Slip21Node.FromSeed(allMnemonic.DeriveSeed());

            Assert.Equal("dbf12b44133eaab506a740f6565cc117228cbf1dd70635cfa8ddfdc9af734756", master.Key.ToHex());
            var slip77                = Slip21Node.FromSeed(allMnemonic.DeriveSeed()).GetSlip77Node();
            var script                = Script.FromHex("76a914a579388225827d9f2fe9014add644487808c695d88ac");
            var privateBlindingKey    = slip77.DeriveSlip77BlindingKey(script);
            var unconfidentialAddress =
                BitcoinAddress.Create("2dpWh6jbhAowNsQ5agtFzi7j6nKscj6UnEr", Altcoins.Liquid.Instance.Regtest);
            var publicBlindingKey = privateBlindingKey.PubKey;

            Assert.Equal("4e6e94df28448c7bb159271fe546da464ea863b3887d2eec6afd841184b70592",
                         privateBlindingKey.ToHex());
            Assert.Equal("0223ef5cf5d1185f86204b9386c8541061a24b6f72fa4a29e3a0b60e1c20ffaf5b",
                         publicBlindingKey.ToHex());
            Assert.Equal("CTEkf75DFff5ReB7juTg2oehrj41aMj21kvvJaQdWsEAQohz1EDhu7Ayh6goxpz3GZRVKidTtaXaXYEJ",
                         new BitcoinBlindedAddress(publicBlindingKey, unconfidentialAddress).ToString());


            //test vector: https://github.com/trezor/trezor-firmware/pull/398/files#diff-afc9a622fb2281269983493a9da47a364e94f8bd338e5322f4a7cef99f98ee69R119
            var abusiveWords =
                new Mnemonic("alcohol woman abuse must during monitor noble actual mixed trade anger aisle");
            var derived       = abusiveWords.DeriveExtKey().Derive(new KeyPath("44'/1'/0'/0/0"));
            var addr          = derived.PrivateKey.ScriptPubKey.GetDestinationAddress(Liquid.Instance.Regtest);
            var abusiveslip77 = Slip21Node.FromSeed(abusiveWords.DeriveSeed()).GetSlip77Node();

            Assert.Equal("26f1dc2c52222394236d76e0809516255cfcca94069fd5187c0f090d18f42ad6",
                         abusiveslip77.DeriveSlip77BlindingKey(addr.ScriptPubKey).ToHex());
        }
Beispiel #4
0
        static void MasterPublicKeyAndPrivateKey1(Network net, string words, string password)
        {
            Mnemonic mnemonic = new Mnemonic(words);

            ExtKey fatherKey = mnemonic.DeriveExtKey();

            ExtPubKey pubKey = fatherKey.Neuter();

            string wifStr = pubKey.Derive(0).ToString(net);

            Console.WriteLine(wifStr);
            Console.WriteLine();
            Console.WriteLine();

            for (int i = 0; i < 10; i++)
            {
                BitcoinAddress address1 = pubKey.Derive((uint)i).PubKey.GetAddress(ScriptPubKeyType.Legacy, net);
                Console.WriteLine(address1.ToString());
            }

            //var wiff = "";
            //for (int i = 0; i < 10; i++)
            //{
            //    ExtKey key = fatherKey.Derive((uint)i);
            //    var c = ("Key " + i + " : " + key.PrivateKey.GetBitcoinSecret(net).GetAddress(ScriptPubKeyType.Legacy).ToString() + " , wif:" + key.GetWif(net));
            //    var c1 = ("Key " + i + " : " + key.PrivateKey.GetBitcoinSecret(net).GetAddress(ScriptPubKeyType.Segwit).ToString() + " , wif:" + key.GetWif(net));
            //    var c2 = ("Key " + i + " : " + key.PrivateKey.GetBitcoinSecret(net).GetAddress(ScriptPubKeyType.SegwitP2SH).ToString() + " , wif:" + key.GetWif(net));
            //    Console.WriteLine(c);
            //    Console.WriteLine(c1);
            //    Console.WriteLine(c2);
            //}
        }
Beispiel #5
0
        /// <inheritdoc />
        public Mnemonic CreateWallet(string password, string folderPath, string name, string network, string passphrase = null)
        {
            // for now the passphrase is set to be the password by default.
            if (passphrase == null)
            {
                passphrase = password;
            }

            // generate the root seed used to generate keys from a mnemonic picked at random
            // and a passphrase optionally provided by the user
            Mnemonic mnemonic    = new Mnemonic(Wordlist.English, WordCount.Twelve);
            ExtKey   extendedKey = mnemonic.DeriveExtKey(passphrase);

            Network coinNetwork = WalletHelpers.GetNetwork(network);

            // create a wallet file
            Wallet wallet = this.GenerateWalletFile(password, folderPath, name, coinNetwork, extendedKey);

            // generate multiple accounts and addresses from the get-go
            for (int i = 0; i < WalletCreationAccountsCount; i++)
            {
                HdAccount account = CreateNewAccount(wallet, this.coinType, password);
                this.CreateAddressesInAccount(account, coinNetwork, UnusedAddressesBuffer);
                this.CreateAddressesInAccount(account, coinNetwork, UnusedAddressesBuffer, true);
            }

            // save the changes to the file and add addresses to be tracked
            this.SaveToFile(wallet);
            this.PubKeys = this.LoadKeys(this.coinType);
            this.Load(wallet);

            return(mnemonic);
        }
Beispiel #6
0
        /// <summary>
        /// Gets the HD private key generated by this mnemonic and passphrase.
        /// </summary>
        /// <param name="mnemonic">The mnemonic used to generate the key.</param>
        /// <param name="passphrase">The passphrase used in generating the key.</param>
        /// <returns>The HD private key generated by this mnemonic and passphrase.</returns>
        /// <remarks>This key is sometimes referred to as the 'root seed' or the 'master key'.</remarks>
        public static ExtKey GetHdPrivateKey(Mnemonic mnemonic, string passphrase)
        {
            Guard.NotNull(mnemonic, nameof(mnemonic));
            Guard.NotEmpty(passphrase, nameof(passphrase));

            return(mnemonic.DeriveExtKey(passphrase));
        }
Beispiel #7
0
        public static HDKeyManager Create(out Mnemonic mnemonic)
        {
            mnemonic = new Mnemonic(Wordlist.English, WordCount.Twelve);
            var extKey = mnemonic.DeriveExtKey();

            return(new HDKeyManager(extKey, DefaultAccountKeyPath));
        }
Beispiel #8
0
        public static void test()
        {
            //getting the mnemonic with a custom wordlist (generated by overriding the Italian one)
            Wordlist wl = getItalianWordlist();

            int[]    arr = Enumerable.Range(0, wl.WordCount - 1).ToArray();
            String[] ewl = wl.GetWords(arr);
            ewl[0]  = "dry";
            ewl[1]  = "drive";
            ewl[2]  = "brown";
            ewl[3]  = "parade";
            ewl[4]  = "drastic";
            ewl[5]  = "shine";
            ewl[6]  = "embrace";
            ewl[7]  = "hard";
            ewl[8]  = "report";
            ewl[9]  = "loan";
            ewl[10] = "fold";
            ewl[11] = "iron";

            Wordlist wlCustom = new Wordlist(ewl, ' ', "custom");

            Mnemonic mnemo        = new Mnemonic("dry brown drive parade drastic shine embrace hard report loan fold iron", wlCustom);
            ExtKey   hdroot       = mnemo.DeriveExtKey();
            var      firstprivkey = hdroot.Derive(new KeyPath("m/0'/0/0"));
            var      firstpubKey  = firstprivkey.Neuter().PubKey;
            String   address      = firstpubKey.GetAddress(Network.Main).ToString();

            Console.WriteLine(address); // --> 1AE1LyUWpfb32dReDuGezvdMGXHiFnq4jH
        }
        /// <summary>Generates a new private key.</summary>
        public Key GeneratePrivateKey()
        {
            var mnemonic   = new Mnemonic(Wordlist.English, WordCount.Twelve);
            Key privateKey = mnemonic.DeriveExtKey().PrivateKey;

            return(privateKey);
        }
Beispiel #10
0
        public ExtKey GetPrivateKey(string mnemoic, string senha)
        {
            var    mnemo = new Mnemonic(mnemoic, Wordlist.PortugueseBrazil);
            ExtKey pkey  = mnemo.DeriveExtKey(senha);

            return(pkey);
        }
        public ExtKey GetExtKey(Network network)
        {
            ExtKey extKey = null;

            try
            {
                var mnemonic = new Mnemonic(SeedOrKey);
                extKey = mnemonic.DeriveExtKey(Passphrase);
            }
            catch (Exception)
            {
            }

            if (extKey == null)
            {
                try
                {
                    extKey = ExtKey.Parse(SeedOrKey, network);
                }
                catch (Exception)
                {
                }
            }
            return(extKey);
        }
        public void RunRule_ProvenHeadersActive_And_InvalidCoinstakeKernelSignature_BadBlockSignatureErrorIsThrown()
        {
            // Setup private key.
            var mnemonic   = new Mnemonic(Wordlist.English, WordCount.Twelve);
            Key privateKey = mnemonic.DeriveExtKey().PrivateKey;

            // Setup previous chained header.
            PosBlock          prevPosBlock          = new PosBlockBuilder(this.network, privateKey).Build();
            ProvenBlockHeader prevProvenBlockHeader = new ProvenBlockHeaderBuilder(prevPosBlock, this.network).Build();
            var previousChainedHeader = new ChainedHeader(prevProvenBlockHeader, prevProvenBlockHeader.GetHash(), null);

            previousChainedHeader.SetPrivatePropertyValue("Height", this.options.ProvenHeadersActivationHeight + 1);

            // Setup proven header with valid coinstake.
            PosBlock posBlock = new PosBlockBuilder(this.network, privateKey).Build();

            posBlock.UpdateMerkleRoot();
            ProvenBlockHeader provenBlockHeader = new ProvenBlockHeaderBuilder(posBlock, this.network).Build();

            provenBlockHeader.HashPrevBlock  = prevProvenBlockHeader.GetHash();
            provenBlockHeader.Coinstake.Time = provenBlockHeader.Time;

            // Setup chained header and move it to the height higher than proven header activation height.
            this.ruleContext.ValidationContext.ChainedHeaderToValidate = new ChainedHeader(provenBlockHeader, provenBlockHeader.GetHash(), previousChainedHeader);
            this.ruleContext.ValidationContext.ChainedHeaderToValidate.SetPrivatePropertyValue("Height", this.options.ProvenHeadersActivationHeight + 2);

            // Setup coinstake transaction with a valid stake age.
            uint unspentOutputsHeight = (uint)this.options.ProvenHeadersActivationHeight + 10;

            var unspentOutputs = new UnspentOutputs(unspentOutputsHeight, new Transaction())
            {
                Outputs = new[] { new TxOut(new Money(100), privateKey.PubKey) }
            };

            this.coinView
            .Setup(m => m.FetchCoinsAsync(It.IsAny <uint256[]>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(new FetchCoinsResponse(new[] { unspentOutputs }, posBlock.GetHash()));

            // Setup stake validator to pass signature validation.
            this.stakeValidator
            .Setup(m => m.VerifySignature(It.IsAny <UnspentOutputs>(), It.IsAny <Transaction>(), It.IsAny <int>(), It.IsAny <ScriptVerify>()))
            .Returns(true);

            // Setup stake validator to pass stake kernel hash validation.
            this.stakeChain.Setup(m => m.Get(It.IsAny <uint256>())).Returns(new BlockStake());
            this.stakeValidator
            .Setup(m => m.CheckStakeKernelHash(It.IsAny <PosRuleContext>(), It.IsAny <uint>(), It.IsAny <uint256>(), It.IsAny <UnspentOutputs>(), It.IsAny <OutPoint>(), It.IsAny <uint>()));

            // Setup stake validator to pass stake age check.
            this.stakeValidator
            .Setup(m => m.IsConfirmedInNPrevBlocks(It.IsAny <UnspentOutputs>(), It.IsAny <ChainedHeader>(), It.IsAny <long>()))
            .Returns(true);

            // When we run the validation rule, we should hit bad merkle proof error.
            Action ruleValidation = () => this.consensusRules.RegisterRule <ProvenHeaderCoinstakeRule>().Run(this.ruleContext);

            ruleValidation.Should().Throw <ConsensusErrorException>()
            .And.ConsensusError
            .Should().Be(ConsensusErrors.BadBlockSignature);
        }
Beispiel #13
0
        public void CanGenerateTaprootPubKey()
        {
            var mnemo = new Mnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
            var root  = mnemo.DeriveExtKey();

            // From BIP86
            foreach (var v in new[]
        /// <summary>
        /// Create an HD private key
        /// </summary>
        private static ExtKey CreateExtKey()
        {
            Mnemonic mnemonic = new Mnemonic(Wordlist.English, WordCount.Twelve);
            ExtKey   extKey   = mnemonic.DeriveExtKey();

            return(extKey);
        }
        public Identity(Mnemonic mnemonic, int index = 0)
        {
            Index = index;

            // This means we'll keep the recovery phrase in-memory for the lifetime of the process. This is needed for identity and
            // hub communication, but we should in the future only derive the extkey from the purpose (302) of identity, and then we should
            // use the extpubkey to derive wallet addresses (purpose 44). If we want to trust users to use the same recovery phrase for
            // both wallets and hub/identity, we must ensure that the private keys for the wallet is as secure as possible.
            this.mnemonic = mnemonic;

            masterNode = mnemonic.DeriveExtKey();

            identity = masterNode.Derive(new KeyPath("m/302'")).Derive(index, true);

            ProfileNetwork network = new ProfileNetwork();
            BitcoinAddress address = identity.ScriptPubKey.GetDestinationAddress(network);

            //this.identity = masterNode.Derive(new KeyPath("m/302'/0'"));
            // The default for keys is to be compressed, making it 33 bytes as oppose to 65.
            //identityPubKey = identity.GetPublicKey();
            // FingerPrint = identityPubKey.GetHDFingerPrint();

            // TODO: FIX THIS, API CHANGES!
            Id = address.ToString();
        }
        public static (Features.Wallet.Types.Wallet wallet, ExtKey key) GenerateBlankWalletWithExtKey(string name, string password)
        {
            var    mnemonic    = new Mnemonic("grass industry beef stereo soap employ million leader frequent salmon crumble banana");
            ExtKey extendedKey = mnemonic.DeriveExtKey(password);

            var walletFile = new Features.Wallet.Types.Wallet
            {
                Name          = name,
                EncryptedSeed = extendedKey.PrivateKey.GetEncryptedBitcoinSecret(password, KnownNetworks.Main).ToWif(),
                ChainCode     = extendedKey.ChainCode,
                CreationTime  = DateTimeOffset.Now,
                Network       = KnownNetworks.Main,
                walletStore   = new WalletMemoryStore(),
                BlockLocator  = new List <uint256>()
                {
                    KnownNetworks.Main.GenesisHash
                },
                AccountsRoot = new List <AccountRoot> {
                    new AccountRoot()
                    {
                        Accounts = new List <HdAccount>(), CoinType = KnownNetworks.Main.Consensus.CoinType, LastBlockSyncedHash = KnownNetworks.Main.GenesisHash, LastBlockSyncedHeight = 0
                    }
                },
            };

            var data = walletFile.walletStore.GetData();

            data.BlockLocator = walletFile.BlockLocator;
            data.WalletName   = walletFile.Name;
            data.WalletTip    = new Utilities.HashHeightPair(KnownNetworks.Main.GenesisHash, 0);
            walletFile.walletStore.SetData(data);

            return(walletFile, extendedKey);
        }
Beispiel #17
0
        void GenerateNewMnemonic(object sender, EventArgs args)
        {
            Mnemonic mnemo  = new Mnemonic(Wordlist.English);
            ExtKey   hdRoot = mnemo.DeriveExtKey("my password");

            message.Text = mnemo.ToString();
        }
Beispiel #18
0
    public void CreateAccount()
    {
        if (signUpPW.text.Length > 7)
        {
            password = signUpPW.text;
            WalletManager.Instance.CreateAccount(password);

            seedPanel.SetActive(true);

            // Creat mnemonic
            Mnemonic mnemo  = new Mnemonic(Wordlist.English, WordCount.Twelve);
            ExtKey   hdRoot = mnemo.DeriveExtKey(password);
            seedText.text = mnemo.ToString();

            IsEncryptedJson();

            Debug.Log(mnemo);
            Debug.Log("Address:" + WalletManager.Instance.publicAddress);
            Debug.Log("PrivateKey:" + WalletManager.Instance.privateKey);
            Debug.Log("Json:" + WalletManager.Instance.encryptedJson);
            Debug.Log("Password:" + WalletManager.Instance.password);

            password = null;
            //UIFunction();
        }
    }
Beispiel #19
0
        public dynamic CreateNewHDWallet(string walletName, string network, string passPhrase)
        {
            Network ltcNetwork = null;


            if (network.ToLower() == "main")
            {
                ltcNetwork = NBitcoin.Altcoins.Litecoin.Instance.Mainnet;
            }
            else
            {
                ltcNetwork = NBitcoin.Altcoins.Litecoin.Instance.Testnet;
            }


            Mnemonic mnemo  = new Mnemonic(Wordlist.English, WordCount.Fifteen);
            ExtKey   hdroot = mnemo.DeriveExtKey(passPhrase);
            var      wif    = hdroot.GetWif(ltcNetwork);

            dynamic response = new ExpandoObject();

            response.wif   = wif;
            response.mnemo = mnemo;

            response.Network = network.ToLower() == "main" ? "Main" : "TestNet";

            return(response);
        }
        private static void GeneratePublicPrivateKeys()
        {
            // Generate keys for signing.
            var    mnemonicForSigningKey = new Mnemonic(Wordlist.English, WordCount.Twelve);
            PubKey signingPubKey         = mnemonicForSigningKey.DeriveExtKey().PrivateKey.PubKey;

            // Generate keys for migning.
            var tool = new KeyTool(new DataFolder(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)));
            Key key  = tool.GeneratePrivateKey();

            string savePath = tool.GetPrivateKeySavePath();

            tool.SavePrivateKey(key);
            PubKey miningPubKey = key.PubKey;

            Console.WriteLine($"-----------------------------------------------------------------------------");
            Console.WriteLine($"-- Please give the following 2 public keys to the federation administrator --");
            Console.WriteLine($"-----------------------------------------------------------------------------");
            Console.WriteLine($"1. Your signing pubkey: {Encoders.Hex.EncodeData(signingPubKey.ToBytes(false))}");
            Console.WriteLine($"2. Your mining pubkey: {Encoders.Hex.EncodeData(miningPubKey.ToBytes(false))}");
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine($"------------------------------------------------------------------------------------------");
            Console.WriteLine($"-- Please keep the following 12 words for yourself and note them down in a secure place --");
            Console.WriteLine($"------------------------------------------------------------------------------------------");
            Console.WriteLine($"Your signing mnemonic: {string.Join(" ", mnemonicForSigningKey.Words)}");
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine($"------------------------------------------------------------------------------------------------------------");
            Console.WriteLine($"-- Please save the following file in a secure place, you'll need it when the federation has been created. --");
            Console.WriteLine($"------------------------------------------------------------------------------------------------------------");
            Console.WriteLine($"File path: {savePath}");
            Console.WriteLine(Environment.NewLine);
        }
Beispiel #21
0
        public dynamic CreateNewHDWallet(string walletName, string network, string passPhrase)
        {
            Network btcNetwork = null;


            if (network.ToLower() == "main")
            {
                btcNetwork = Network.Main;
            }
            else
            {
                btcNetwork = Network.TestNet;
            }


            Mnemonic mnemo  = new Mnemonic(Wordlist.English, WordCount.Fifteen);
            ExtKey   hdroot = mnemo.DeriveExtKey(passPhrase);
            var      wif    = hdroot.GetWif(btcNetwork);

            dynamic response = new ExpandoObject();

            response.wif        = wif;
            response.mnemo      = mnemo;
            response.btcNetwork = btcNetwork;

            return(response);
        }
        /// <inheritdoc />
        public Mnemonic CreateWallet(string password, string name, string passphrase = null)
        {
            // for now the passphrase is set to be the password by default.
            if (passphrase == null)
            {
                passphrase = password;
            }

            // generate the root seed used to generate keys from a mnemonic picked at random
            // and a passphrase optionally provided by the user
            Mnemonic mnemonic    = new Mnemonic(Wordlist.English, WordCount.Twelve);
            ExtKey   extendedKey = mnemonic.DeriveExtKey(passphrase);

            // create a wallet file
            Wallet wallet = this.GenerateWalletFile(password, name, extendedKey);

            // generate multiple accounts and addresses from the get-go
            for (int i = 0; i < WalletCreationAccountsCount; i++)
            {
                HdAccount account = CreateNewAccount(wallet, this.coinType, password);
                this.CreateAddressesInAccount(account, UnusedAddressesBuffer);
                this.CreateAddressesInAccount(account, UnusedAddressesBuffer, true);
            }

            // update the height of the we start syncing from
            this.UpdateLastBlockSyncedHeight(wallet, this.chain.Tip);

            // save the changes to the file and add addresses to be tracked
            this.SaveToFile(wallet);
            this.Load(wallet);
            this.LoadKeysLookup();

            return(mnemonic);
        }
Beispiel #23
0
        private Mnemonic SetSeed(string password, Mnemonic mnemonic = null)
        {
            mnemonic = mnemonic ?? new Mnemonic(Wordlist.English, WordCount.Twelve);

            ExtKey = mnemonic.DeriveExtKey(password);

            return(mnemonic);
        }
Beispiel #24
0
        public void CanNormalizeMnemonicString()
        {
            var mnemonic  = new Mnemonic("turtle front uncle idea crush write shrug there lottery flower risk shell", Wordlist.English);
            var mnemonic2 = new Mnemonic("turtle    front	uncle  idea crush write shrug there lottery flower risk shell", Wordlist.English);

            Assert.Equal(mnemonic.DeriveExtKey().ScriptPubKey, mnemonic2.DeriveExtKey().ScriptPubKey);
            Assert.Equal(mnemonic.ToString(), mnemonic2.ToString());
        }
        public ExtPubKeyExplorerTests()
        {
            Random = new Random(Seed: 6439);

            var mnemonic = new Mnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");

            ExtKey    = mnemonic.DeriveExtKey();
            ExtPubKey = ExtKey.Derive(new KeyPath("m/84'/0'/0'/1/0")).Neuter();
        }
Beispiel #26
0
        public ExtPubKeyExplorerTests()
        {
            Random = new Random(Seed: 6439);

            var mnemonic = new Mnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");

            ExtKey    = mnemonic.DeriveExtKey();
            ExtPubKey = ExtKey.Derive(new KeyPath($"{KeyManager.DefaultAccountKeyPath.ToString(true, "h")}/1/0")).Neuter();
        }
Beispiel #27
0
        public string GenerateRandomIdentity()
        {
            // Generate a random seed and new identity.
            var    mnemonic   = new Mnemonic(Wordlist.English, WordCount.Twelve);
            ExtKey masterNode = mnemonic.DeriveExtKey();

            ExtPubKey walletRoot   = masterNode.Derive(new KeyPath("m/44'")).Neuter();
            ExtKey    identityRoot = masterNode.Derive(new KeyPath("m/302'"));

            ExtKey identity0 = identityRoot.Derive(0, true);
            ExtKey identity1 = identityRoot.Derive(1, true);

            BitcoinPubKeyAddress identity0Address = identity0.PrivateKey.PubKey.GetAddress(profileNetwork);
            BitcoinPubKeyAddress identity1Address = identity1.PrivateKey.PubKey.GetAddress(profileNetwork);

            string identity0Id = identity0Address.ToString();

            // Create an identity profile that should be signed and pushed.
            IdentityModel identityModel = new IdentityModel
            {
                Id        = identity0Id,
                Name      = "Random Person",
                ShortName = "Random",
                Alias     = "Who Knows",
                Email     = "*****@*****.**",
                Title     = "President"
            };

            byte[] entityBytes = MessagePackSerializer.Serialize(identityModel);

            // Testing to only sign the name.
            string signature = identity0.PrivateKey.SignMessage(entityBytes);

            IdentityDocument identityDocument = new IdentityDocument
            {
                Owner     = identityModel.Id,
                Body      = identityModel,
                Signature = signature
            };

            string json = JsonConvert.SerializeObject(identityDocument);

            RestClient client = CreateClient();

            // Persist the identity.
            var request2 = new RestRequest($"/identity/{identityModel.Id}");

            request2.AddJsonBody(identityDocument);
            IRestResponse <string> response2 = client.Put <string>(request2);

            if (response2.StatusCode != System.Net.HttpStatusCode.OK)
            {
                throw new ApplicationException(response2.ErrorMessage);
            }

            return(identity0Id);
        }
        public OpenChainSession(ApiProxy api, string passphrase) : base(api)
        {
            Mnemonic mnemonic = new Mnemonic(passphrase);

            passphraseKey = mnemonic.DeriveExtKey();
            rootKey       = passphraseKey.Derive(44, true).Derive(64, true).Derive(0, true).Derive(0).Derive(0);
            var bprootkey = rootKey.PrivateKey.PubKey.GetAddress(OpenChainServer.OpenChainNetwork);

            Account = $"/p2pkh/{bprootkey}/";
        }
Beispiel #29
0
        public static void test2()
        {
            Mnemonic mnemo        = new Mnemonic("dry brown drive parade drastic shine embrace hard report loan fold iron", Wordlist.English);
            ExtKey   hdroot       = mnemo.DeriveExtKey();
            var      firstprivkey = hdroot.Derive(new KeyPath("m/44'/0'/0'/0/0"));
            var      firstpubKey  = firstprivkey.Neuter().PubKey;
            String   address      = firstpubKey.GetAddress(Network.Main).ToString();

            Console.WriteLine(address); // --> 1DMDJ266gxMCJiTcWk5MZFbfxxx4Ss3URN
        }
Beispiel #30
0
        private BitcoinSecret HDPrivKey(string seed, int account, int n, string passphrase = null, bool change = false, bool segwit = false, bool bech32 = false)
        {
            var     mnemonic       = new Mnemonic(seed, Wordlist.English);
            var     masterKey      = mnemonic.DeriveExtKey(passphrase); //this is the root key
            string  derivationpath = dpath(segwit, bech32);
            KeyPath kp             = KeyPath.Parse(derivationpath + Convert.ToString(account) + "'/" + (change ? "1" : "0") + "/" + Convert.ToString(n));
            ExtKey  key            = masterKey.Derive(kp);
            var     p = key.PrivateKey.GetWif(Network.Main);

            return(p);
        }