private void GetKeys() { var key = new ExtKey(new Mnemonic(Mnemonic).DeriveSeed()).Derive(KeyPath.Parse(HdPath)); this.PrivateKey = key.PrivateKey.ToBytes(); this.Address = new Bech32(Network.bech32Prefix).Encode(key.PrivateKey.PubKey.Hash.ToBytes()); }
public async Task StartParticipatingAsync(CancellationToken cancellationToken) { ThrowIfDisposed(); var apiClient = new WabiSabiHttpApiClient(HttpClientFactory.NewHttpClientWithDefaultCircuit()); using var roundStateUpdater = new RoundStateUpdater(TimeSpan.FromSeconds(3), apiClient); await roundStateUpdater.StartAsync(cancellationToken).ConfigureAwait(false); var coinJoinClient = new CoinJoinClient( HttpClientFactory, Wallet, Wallet, roundStateUpdater, consolidationMode: true); // Run the coinjoin client task. var walletHdPubKey = new HdPubKey(Wallet.PubKey, KeyPath.Parse("m/84'/0/0/0/0"), SmartLabel.Empty, KeyState.Clean); walletHdPubKey.SetAnonymitySet(1); // bug if not settled if (SplitTransaction is null) { throw new InvalidOperationException($"{nameof(GenerateCoinsAsync)} has to be called first."); } var smartCoins = SplitTransaction.Transaction.Outputs.AsIndexedOutputs() .Select(x => new SmartCoin(SplitTransaction, x.N, walletHdPubKey)) .ToList(); // Run the coinjoin client task. await coinJoinClient.StartCoinJoinAsync(smartCoins, cancellationToken).ConfigureAwait(false); await roundStateUpdater.StopAsync(cancellationToken).ConfigureAwait(false); }
/// <summary> /// Derive a child address from extended public key /// </summary> /// <param name="extPubKeyWif"></param> private static BitcoinPubKeyAddress DeriveChildAddress(string extPubKeyWif, string keyDerivationPath) { ExtPubKey extPubKey = ExtPubKey.Parse(extPubKeyWif, _network); BitcoinPubKeyAddress childAddress = extPubKey.Derive(KeyPath.Parse(keyDerivationPath)).PubKey.GetAddress(_network); return(childAddress); }
/// <summary> /// Gets the signed transaction data from the Trezor wallet. /// </summary> /// <param name="transaction"> The transaction to sign. </param> /// <param name="path"> The path of the address to sign the transaction with. </param> /// <param name="onSignatureRequestSent"> Action to call once the signature request has been sent. </param> /// <returns> Task returning the SignedTransactionDataHolder instance. </returns> protected override async Task <SignedTransactionDataHolder> GetSignedTransactionData(Transaction transaction, string path, Action onSignatureRequestSent) { var trezorManager = TrezorConnector.GetWindowsConnectedTrezor(GetSignedTransactionDataEnterPin); if (trezorManager == null) { return(null); } var signedTransactionResponse = (EthereumTxRequest)null; var signedTransactionRequest = new EthereumSignTx { Nonce = transaction.Nonce, AddressNs = KeyPath.Parse(path).Indexes, GasPrice = transaction.GasPrice, GasLimit = transaction.GasLimit, To = transaction.ReceiveAddress, Value = transaction.Value, DataInitialChunk = transaction.Data, DataLength = (uint)transaction.Data.Length, ChainId = (uint)ethereumNetworkSettings.networkType }; while (true) { try { signedTransactionResponse = await trezorManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(signedTransactionRequest, onSignatureRequestSent) .ConfigureAwait(false); break; } catch (FailureException <Failure> ) { if (forceCancel) { forceCancel = false; break; } if (trezorManager.PinRequest.HasValue && trezorManager.PinRequest == false) { break; } } } if (signedTransactionResponse == null) { return(new SignedTransactionDataHolder()); } return(new SignedTransactionDataHolder { signed = true, v = signedTransactionResponse.SignatureV, r = signedTransactionResponse.SignatureR, s = signedTransactionResponse.SignatureS }); }
public void CanManageWallet() { var client = new QBitNinjaClient(Network.Main); var wallet = client.GetWalletClient("temp-1Nicolas Dorier"); wallet.CreateIfNotExists().Wait(); wallet.CreateAddressIfNotExists(BitcoinAddress.Create("15sYbVpRh6dyWycZMwPdxJWD4xbfxReeHe", client.Network)).Wait(); wallet.CreateAddressIfNotExists(BitcoinAddress.Create("1KF8kUVHK42XzgcmJF4Lxz4wcL5WDL97PB", client.Network)).Wait(); var balance = wallet.GetBalance().Result; Assert.True(balance.Operations.Count > 70); var keyset = wallet.GetKeySetClient("main"); keyset.CreateIfNotExists(new[] { new ExtKey().Neuter() }, path: KeyPath.Parse("1/2/3")).Wait(); Assert.True(keyset.Delete().Result); Assert.False(keyset.Delete().Result); keyset.CreateIfNotExists(new[] { new ExtKey().Neuter() }, path: KeyPath.Parse("1/2/3")).Wait(); var key = keyset.GetUnused(1).Result; var sets = wallet.GetKeySets().Result; Assert.True(sets.Length > 0); var model = client.GetWalletClient("temp-1Nicolas Dorier").Get().Result; Assert.NotNull(model); Assert.Null(client.GetWalletClient("ojkljdjlksj").Get().Result); Assert.True(wallet.GetAddresses().Result.Length > 1); }
static internal WalletCreation FromJson(JObject obj) { WalletCreation creation = new WalletCreation(); creation.Network = null; JToken unused; if (obj.TryGetValue("Name", out unused)) { creation.Name = (string)obj["Name"]; } else { creation.Name = null; } if (obj.Property("PurgeConnectionOnFilterChange") != null) { creation.PurgeConnectionOnFilterChange = (bool)obj["PurgeConnectionOnFilterChange"]; } JToken network; if (obj.TryGetValue("Network", out network)) { creation.Network = Network.GetNetwork((string)network); } creation.SignatureRequired = (int)(long)obj["SignatureRequired"]; creation.DerivationPath = KeyPath.Parse((string)obj["DerivationPath"]); creation.UseP2SH = (bool)obj["UseP2SH"]; var array = (JArray)obj["RootKeys"]; var keys = array.Select(i => new BitcoinExtPubKey((string)i)).ToArray(); creation.Network = creation.Network ?? keys[0].Network; creation.RootKeys = keys.Select(k => k.ExtPubKey).ToArray(); return(creation); }
void LoadCore(Stream stream) { JObject obj = JObject.Load(new JsonTextReader(new StreamReader(stream)) { DateParseHandling = DateParseHandling.DateTimeOffset }); _Parameters = WalletCreation.FromJson((JObject)obj["Parameters"]); _PathStates = new Dictionary <KeyPath, PathState>(); if (obj.Property("CurrentIndex") != null) //legacy { var idx = (int)(long)obj["CurrentIndex"]; var loadedKeys = (int)(long)obj["LoadedKeys"]; _PathStates.Add(_Parameters.DerivationPath.Derive(0), new PathState() { Next = idx, Loaded = loadedKeys }); _PathStates.Add(_Parameters.DerivationPath.Derive(1), new PathState() { Next = idx, Loaded = loadedKeys }); } var indices = obj["Indices"] as JArray; if (indices != null) { foreach (var indice in indices.OfType <JObject>()) { _PathStates.Add(KeyPath.Parse((string)indice["KeyPath"]), new PathState() { Next = (int)(long)indice["Next"], Loaded = (int)(long)indice["Loaded"] }); } } _KeyPoolSize = (int)(long)obj["KeyPoolSize"]; Created = (DateTimeOffset)obj["Created"]; _ScanLocation = new BlockLocator(); _ScanLocation.FromBytes(Encoders.Hex.DecodeData((string)obj["Location"])); _KnownScripts.Clear(); var knownScripts = (JArray)obj["KnownScripts"]; foreach (var known in knownScripts.OfType <JObject>()) { Script script = Script.FromBytesUnsafe(Encoders.Hex.DecodeData((string)known["ScriptPubKey"])); if (known["KeyPath"] != null) //Legacy data { KeyPath keypath = KeyPath.Parse((string)known["KeyPath"]); _KnownScripts.Add(script, _Parameters.DerivationPath.Derive(keypath)); } if (known["AbsoluteKeyPath"] != null) { KeyPath keypath = KeyPath.Parse((string)known["AbsoluteKeyPath"]); _KnownScripts.Add(script, keypath); } } }
public static Wallet RestoreWalletFromMnemonic(string mnemonicStr, Network env) { Mnemonic mnemonic = new Mnemonic(mnemonicStr); var seed = mnemonic.DeriveSeed(); var pk = new ExtKey(seed); var kp = KeyPath.Parse(keyPath); var key = pk.Derive(kp); var privKey = key.PrivateKey; var bytes = privKey.ToBytes(); Wallet w = new Wallet(); w._env = BinanceEnvironment.GetEnvironment(env); w._privateKey = privKey; w._privateKeyStr = BitConverter.ToString(bytes).Replace("-", string.Empty); w._publicKey = w._privateKey.PubKey.Compress(); w._publicKeyBytes = w._publicKey.ToBytes(); w._AddressBytes = w._publicKey.Hash.ToBytes(); w._addressStr = Bech32Engine.Encode(w.Env.Hrp, w._AddressBytes); w.Init(); return(w); }
static HdPubKey CreateHdPubKey(ExtPubKey extPubKey) { var hdPubKey = new HdPubKey(extPubKey.PubKey, KeyPath.Parse($"m/84'/0/0/0/{extPubKey.Child}"), SmartLabel.Empty, KeyState.Clean); hdPubKey.SetAnonymitySet(1); // bug if not settled return(hdPubKey); }
public void CanUseKeyPath() { var keyPath = KeyPath.Parse("0/1/2/3"); Assert.Equal(keyPath.ToString(), "0/1/2/3"); var key = new ExtKey(); Assert.Equal(key .Derive(0) .Derive(1) .Derive(2) .Derive(3) .ToString(Network.Main), key.Derive(keyPath).ToString(Network.Main)); var neuter = key.Neuter(); Assert.Equal(neuter .Derive(0) .Derive(1) .Derive(2) .Derive(3) .ToString(Network.Main), neuter.Derive(keyPath).ToString(Network.Main)); Assert.Equal(neuter.Derive(keyPath).ToString(Network.Main), key.Derive(keyPath).Neuter().ToString(Network.Main)); keyPath = new KeyPath(0x8000002Cu, 1u); Assert.Equal(keyPath.ToString(), "44'/1"); keyPath = KeyPath.Parse("44'/1"); Assert.False(keyPath.IsHardened); Assert.True(KeyPath.Parse("44'/1'").IsHardened); Assert.Equal(keyPath[0], 0x8000002Cu); Assert.Equal(keyPath[1], 1u); key = new ExtKey(); Assert.Equal(key.Derive(keyPath).ToString(Network.Main), key.Derive(44, true).Derive(1, false).ToString(Network.Main)); keyPath = KeyPath.Parse(""); keyPath = keyPath.Derive(44, true).Derive(1, false); Assert.Equal(keyPath.ToString(), "44'/1"); Assert.Equal(keyPath.Increment().ToString(), "44'/2"); Assert.Equal(keyPath.Derive(1, true).Increment().ToString(), "44'/1/2'"); Assert.Equal(keyPath.Parent.ToString(), "44'"); Assert.Equal(keyPath.Parent.Parent.ToString(), ""); Assert.Equal(keyPath.Parent.Parent.Parent, null); Assert.Equal(keyPath.Parent.Parent.Increment(), null); Assert.Equal(key.Derive(keyPath).ToString(Network.Main), key.Derive(44, true).Derive(1, false).ToString(Network.Main)); Assert.True(key.Derive(44, true).IsHardened); Assert.False(key.Derive(44, false).IsHardened); neuter = key.Derive(44, true).Neuter(); Assert.True(neuter.IsHardened); neuter = key.Derive(44, false).Neuter(); Assert.False(neuter.IsHardened); }
public KeyPath GetWalletKeyPathRoot(PaymentMethodId paymentMethodId) { if (WalletKeyPathRoots.TryGetValue(paymentMethodId.ToString().ToLowerInvariant(), out var k)) { return(KeyPath.Parse(k)); } return(null); }
public static byte[] SeedToPrivateKey(byte[] seed, int coinType) { //coinType: BTC 0, ETH 60, NEO 888, ONT 1024 //see https://github.com/satoshilabs/slips/blob/master/slip-0044.md var derivePath = KeyPath.Parse($"m/44'/{coinType}'/0'/0/0"); var paymentKey = new ExtKey(seed).Derive(derivePath); return(paymentKey.PrivateKey.ToBytes()); }
public void CanUseKeyPath() { var keyPath = KeyPath.Parse("0/1/2/3"); Assert.Equal("0/1/2/3", keyPath.ToString()); var key = new ExtKey(); Assert.Equal(key .Derive(0) .Derive(1) .Derive(2) .Derive(3) .ToString(Network.PurpleMain), key.Derive(keyPath).ToString(Network.PurpleMain)); var neuter = key.Neuter(); Assert.Equal(neuter .Derive(0) .Derive(1) .Derive(2) .Derive(3) .ToString(Network.PurpleMain), neuter.Derive(keyPath).ToString(Network.PurpleMain)); Assert.Equal(neuter.Derive(keyPath).ToString(Network.PurpleMain), key.Derive(keyPath).Neuter().ToString(Network.PurpleMain)); keyPath = new KeyPath(new uint[] { 0x8000002Cu, 1u }); Assert.Equal("44'/1", keyPath.ToString()); keyPath = KeyPath.Parse("44'/1"); Assert.False(keyPath.IsHardened); Assert.True(KeyPath.Parse("44'/1'").IsHardened); Assert.Equal(0x8000002Cu, keyPath[0]); Assert.Equal(1u, keyPath[1]); key = new ExtKey(); Assert.Equal(key.Derive(keyPath).ToString(Network.PurpleMain), key.Derive(44, true).Derive(1, false).ToString(Network.PurpleMain)); keyPath = KeyPath.Parse(""); keyPath = keyPath.Derive(44, true).Derive(1, false); Assert.Equal("44'/1", keyPath.ToString()); Assert.Equal("44'/2", keyPath.Increment().ToString()); Assert.Equal("44'/1/2'", keyPath.Derive(1, true).Increment().ToString()); Assert.Equal("44'", keyPath.Parent.ToString()); Assert.Equal("", keyPath.Parent.Parent.ToString()); Assert.Null(keyPath.Parent.Parent.Parent); Assert.Null(keyPath.Parent.Parent.Increment()); Assert.Equal(key.Derive(keyPath).ToString(Network.PurpleMain), key.Derive(44, true).Derive(1, false).ToString(Network.PurpleMain)); Assert.True(key.Derive(44, true).IsHardened); Assert.False(key.Derive(44, false).IsHardened); neuter = key.Derive(44, true).Neuter(); Assert.True(neuter.IsHardened); neuter = key.Derive(44, false).Neuter(); Assert.False(neuter.IsHardened); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { try { return(reader.TokenType == JsonToken.Null ? null : KeyPath.Parse(reader.Value.ToString())); } catch (FormatException) { throw new JsonObjectException("Invalid key path", reader); } }
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); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { try { return(reader.TokenType == JsonToken.Null ? null : KeyPath.Parse(reader.Value.ToString())); } catch (FormatException) { throw new JsonException($"Invalid object of type {objectType.Name} path {reader.Path}"); } }
/// <inheritdoc /> public override object?ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var s = (string)reader.Value; if (string.IsNullOrWhiteSpace(s)) { return(null); } var kp = KeyPath.Parse(s.Trim()); return(kp); }
public uint[] GetPath() { if (!string.IsNullOrEmpty(_customPath)) { var path = KeyPath.Parse(_customPath).Derive(_index); return(path.Indexes); } else { var path = KeyPath.Parse("m/44'/52752'/0'/0").Derive(_index); return(path.Indexes); } }
public IList <SimpleWallet> GetAccounts() { List <SimpleWallet> simpleWallets = new List <SimpleWallet>(); for (int i = 0; i < 10; i++) { var bitAdress = _safe.GetAddress(i); var extKEy = _safe.ExtKey.Derive(KeyPath.Parse($"/44'/60'/0'/{i}")); simpleWallets.Add(new SimpleWallet(extKEy.PrivateKey.ToBytes())); } return(simpleWallets); }
public static Wallet FromMnemonicCode(string mnemonicCode, BinanceDexEnvironmentData env) { Mnemonic mnemonic = new Mnemonic(mnemonicCode); byte[] seed = mnemonic.DeriveSeed(); ExtKey extKey = new ExtKey(seed); KeyPath keyPath = KeyPath.Parse(hdPath); ExtKey derived = extKey.Derive(keyPath); Wallet wallet = new Wallet(derived.PrivateKey, env); wallet.Mnemonic = mnemonicCode; return(wallet); }
static internal WalletCreation FromJson(JObject obj) { WalletCreation creation = new WalletCreation(); creation.SignatureRequired = (int)(long)obj["SignatureRequired"]; creation.DerivationPath = KeyPath.Parse((string)obj["DerivationPath"]); creation.UseP2SH = (bool)obj["UseP2SH"]; var array = (JArray)obj["RootKeys"]; var keys = array.Select(i => new BitcoinExtPubKey((string)i)).ToArray(); creation.Network = keys[0].Network; creation.RootKeys = keys.Select(k => k.ExtPubKey).ToArray(); return(creation); }
public string SignTransaction(string transactionHex, WalletUnsignedTransactionUnspent[] unspents, Keychain userKeychain) { var hexEncoder = new NBitcoin.DataEncoders.HexEncoder(); var extKey = ExtKey.Parse(userKeychain.ExtendedPrivateKey); var builder = new TransactionBuilder().ContinueToBuild(Transaction.Parse(transactionHex)); foreach (var unspent in unspents) { builder .AddCoins(new ScriptCoin(new OutPoint(uint256.Parse(unspent.TransactionHash), unspent.TransactionOutputIndex), new TxOut(unspent.Value, new Script(hexEncoder.DecodeData(unspent.Script))), new Script(hexEncoder.DecodeData(unspent.RedeemScript)))) .AddKeys(extKey.Derive(KeyPath.Parse($"{userKeychain.Path}/0/0{unspent.ChainPath}")).PrivateKey); } return(builder.BuildTransaction(true).ToHex()); }
public void TestBIP39_Passphrase() { Assert.Inconclusive(); string seed24 = ""; string password = ""; var mnemonic = new Mnemonic(seed24); var masterKey = mnemonic.DeriveExtKey(password); string derivationpath = "m/44'/0'/0'/0/0"; KeyPath kp = KeyPath.Parse(derivationpath); ExtKey key = masterKey.Derive(kp); var p = key.PrivateKey.GetWif(Network.Main); var PubAddr2 = p.PubKey.GetAddress(Network.Main).ToString(); Console.WriteLine(PubAddr2.ToString()); }
public void TestBIP39_BIP32Keys() { // This is a throwaway. string seed12 = "turtle front uncle idea crush write shrug there lottery flower risk shell"; var mnemonic = new Mnemonic(seed12); var masterKey = mnemonic.DeriveExtKey(null); //this is the root key int numaccounts = 5; int numaddr = 20; int coinIx = 0; //https://github.com/satoshilabs/slips/blob/master/slip-0044.md for (int i = 0; i < numaccounts; i++) { // bitcoin/account/change/addr for (int j = 0; j < numaddr; j++) { string derivationpath = "m/49'/" + Convert.ToString(coinIx) + "'/"; string fullpath = derivationpath + Convert.ToString(i) + "'/0/" + Convert.ToString(j); KeyPath kp = KeyPath.Parse(fullpath); ExtKey key = masterKey.Derive(kp); //Console.WriteLine("Key " + i + " : " + key.ToString(Network.Main)); //Change Addresses //kp = KeyPath.Parse(derivationpath + Convert.ToString(i) + "'/1/" + Convert.ToString(j)); //key = masterKey.Derive(kp); //Console.WriteLine("Key " + i + " : " + key.ToString(Network.Main)); //generate WIF var p = key.PrivateKey.GetWif(Network.Main); //bech32 addresses //var privkey = "LB8PaHs9t9UxUPYgGqeJRCZ4KK6YvnnqXbgbanWzb7ctGKfegCS8"; //var p = new BitcoinSecret(privkey, Network.Main); //var ba = BitcoinAddress.Create("bc1qsmd3m8sgrhkqp3pefag6n5yahgx3ds226qva07"); var PubAddr2 = p.PubKey.GetAddress(Network.Main).ToString(); //normal var PubAddrSW = p.PubKey.GetSegwitAddress(Network.Main); //bech32 var PubP2SH = PubAddrSW.GetScriptAddress().ToString(); //SH if (PubP2SH.Substring(0, 6) == "34xped") { int q = 1; } Console.WriteLine(PubAddrSW); } } //Assert.IsTrue(mnemonic.IsValidChecksum); }
public async Task SignEthereumTransaction() { var txMessage = new EthereumSignTx { Nonce = 10.ToBytesForRLPEncoding().ToHex().ToHexBytes(), GasPrice = 1000000000.ToBytesForRLPEncoding().ToHex().ToHexBytes(), GasLimit = 21000.ToBytesForRLPEncoding().ToHex().ToHexBytes(), To = "689c56aef474df92d44a1b70850f808488f9769c".ToHexBytes(), Value = BigInteger.Parse("10000000000000000000").ToBytesForRLPEncoding().ToHex().ToHexBytes(), AddressNs = KeyPath.Parse("m/44'/60'/0'/0/0").Indexes, ChainId = 1 }; var transaction = await KeepKeyManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(txMessage); Assert.AreEqual(transaction.SignatureR.Length, 32); Assert.AreEqual(transaction.SignatureS.Length, 32); }
public virtual GetAddressInfoResponse LoadFromJson(JObject raw, Network network) { SetSubInfo(this, raw, network); IsMine = raw.Property("ismine").Value.Value <bool>(); Solvable = raw.Property("solvable")?.Value.Value <bool>(); Desc = raw.Property("desc") == null ? null : new ScanTxoutDescriptor(raw.Property("desc").Value.Value <string>()); IsWatchOnly = raw.Property("iswatchonly").Value.Value <bool>(); IsScript = raw.Property("isscript").Value.Value <bool>(); IsWitness = raw.Property("iswitness").Value.Value <bool>(); Script = raw.Property("script")?.Value.Value <string>(); Hex = raw.Property("hex")?.Value.Value <string>(); var jEmbedded = raw.Property("embedded"); if (jEmbedded != null) { var j = jEmbedded.Value.Value <JObject>(); var e = new GetAddressInfoScriptInfoResponse(); SetSubInfo(e, j, network); Embedded = e; } IsCompressed = raw.Property("iscompressed")?.Value.Value <bool>(); Label = raw.Property("label")?.Value.Value <string>(); IsChange = raw.Property("ischange")?.Value.Value <bool>(); Timestamp = raw.Property("timestamp") == null ? (DateTimeOffset?)null : Utils.UnixTimeToDateTime(raw.Property("timestamp").Value.Value <ulong>()); HDKeyPath = raw.Property("hdkeypath") == null ? null : KeyPath.Parse(raw.Property("hdkeypath").Value.Value <string>()); HDSeedID = raw.Property("hdseedid") == null ? null : uint160.Parse(raw.Property("hdseedid").Value.Value <string>()); HDMasterKeyID = raw.Property("hdmasterkeyid") == null ? null : uint160.Parse(raw.Property("hdmasterkeyid").Value.Value <string>()); var jlabels = raw.Property("labels"); if (jlabels != null) { var labelObjects = jlabels.Value.Value <JArray>(); foreach (var jToken in labelObjects) { if (jToken is JObject jObject) // Before Bitcoin Core 0.20.0 { #pragma warning disable CS0618 // Type or member is obsolete. Labels.Add(jToken.ToObject <Dictionary <string, string> >()); #pragma warning restore CS0618 // Type or member is obsolete } } } return(this); }
public SafeAccount(uint id) { try { string firstPart = Hierarchy.GetPathString(HdPathType.Account); string lastPart = $"/{id}'"; PathString = firstPart + lastPart; KeyPath.Parse(PathString); } catch (Exception ex) { throw new ArgumentOutOfRangeException($"{nameof(id)} : {id}", ex); } Id = id; }
private void RecoverWallet(WalletManagerViewModel owner) { WalletName = Guard.Correct(WalletName); MnemonicWords = Guard.Correct(MnemonicWords); Password = Guard.Correct(Password); // Do not let whitespaces to the beginning and to the end. string walletFilePath = WalletManager.WalletDirectories.GetWalletFilePaths(WalletName).walletFilePath; if (string.IsNullOrWhiteSpace(WalletName)) { NotificationHelpers.Error("Invalid wallet name."); } else if (File.Exists(walletFilePath)) { NotificationHelpers.Error("Wallet name is already taken."); } else if (string.IsNullOrWhiteSpace(MnemonicWords)) { NotificationHelpers.Error("Recovery Words were not supplied."); } else { var minGapLimit = int.Parse(MinGapLimit); var keyPath = KeyPath.Parse(AccountKeyPath); try { var mnemonic = new Mnemonic(MnemonicWords); var km = KeyManager.Recover(mnemonic, Password, filePath: null, keyPath, minGapLimit); km.SetNetwork(Global.Network); km.SetFilePath(walletFilePath); WalletManager.AddWallet(km); NotificationHelpers.Success("Wallet was recovered."); owner.SelectLoadWallet(km); } catch (Exception ex) { Logger.LogError(ex); NotificationHelpers.Error(ex.ToUserFriendlyString()); } } }
public byte[] GetPath() { if (!string.IsNullOrEmpty(_customPath)) { var path = KeyPath.Parse(_customPath).Derive(_index); return(GetByteData(path.Indexes)); } if (_legacyPath) { var path = KeyPath.Parse("m/44'/52752'/0'").Derive(_index); return(GetByteData(path.Indexes)); } else { var path = KeyPath.Parse("m/44'/52752'/0'/0").Derive(_index); return(GetByteData(path.Indexes)); } }
public static GetAddressInfoResponse FromJsonResponse(JObject raw, Network network) { var result = new GetAddressInfoResponse(); SetSubInfo(result, raw, network); result.IsMine = raw.Property("ismine").Value.Value <bool>(); result.Solvable = raw.Property("solvable")?.Value.Value <bool>(); result.Desc = raw.Property("desc") == null ? null : new ScanTxoutDescriptor(raw.Property("desc").Value.Value <string>()); result.IsWatchOnly = raw.Property("iswatchonly").Value.Value <bool>(); result.IsScript = raw.Property("isscript").Value.Value <bool>(); result.IsWitness = raw.Property("iswitness").Value.Value <bool>(); result.Script = raw.Property("script")?.Value.Value <string>(); result.Hex = raw.Property("hex")?.Value.Value <string>(); var jEmbedded = raw.Property("embedded"); if (jEmbedded != null) { var j = jEmbedded.Value.Value <JObject>(); var e = new GetAddressInfoScriptInfoResponse(); SetSubInfo(e, j, network); result.Embedded = e; } result.IsCompressed = raw.Property("iscompressed")?.Value.Value <bool>(); result.Label = raw.Property("label").Value.Value <string>(); result.IsChange = raw.Property("ischange")?.Value.Value <bool>(); result.Timestamp = raw.Property("timestamp") == null ? (DateTimeOffset?)null : Utils.UnixTimeToDateTime(raw.Property("timestamp").Value.Value <ulong>()); result.HDKeyPath = raw.Property("hdkeypath") == null ? null : KeyPath.Parse(raw.Property("hdkeypath").Value.Value <string>()); result.HDSeedID = raw.Property("hdseedid") == null ? null : uint160.Parse(raw.Property("hdseedid").Value.Value <string>()); result.HDMasterKeyID = raw.Property("hdmasterkeyid") == null ? null : uint160.Parse(raw.Property("hdmasterkeyid").Value.Value <string>()); var jlabels = raw.Property("labels"); if (jlabels != null) { var labelObjects = jlabels.Value.Value <JArray>(); foreach (var jObj in labelObjects) { result.Labels.Add(((JObject)jObj).ToObject <Dictionary <string, string> >()); } } return(result); }