public static Encode ( long intData ) : string | ||
intData | long | |
Résultat | string |
public static string HashAlias(Alias alias) { var aliasClone = alias.Clone(); aliasClone.Realm = ""; return(Base58.Encode(Sha256Hash(Encoding.UTF8.GetBytes(ToJson(aliasClone))))); }
public override void Deserialize(byte[] bytes, ref int index) { var addressBytes = new byte[28]; Array.Copy(bytes, index, addressBytes, 0, addressBytes.Length); index += addressBytes.Length; var serialNoLenBytes = new byte[4]; Array.Copy(bytes, index, serialNoLenBytes, 0, serialNoLenBytes.Length); SerialNoLen = BitConverter.ToInt32(serialNoLenBytes, 0); index += serialNoLenBytes.Length; var serialNoBytes = new byte[SerialNoLen]; Array.Copy(bytes, index, serialNoBytes, 0, serialNoBytes.Length); index += serialNoBytes.Length; var nameBytes = new byte[bytes.Length - index - 1]; Array.Copy(bytes, index, nameBytes, 0, nameBytes.Length); index += nameBytes.Length; WalletAddress = Base58.Encode(addressBytes); SerialNo = Encoding.UTF8.GetString(serialNoBytes); Name = Encoding.UTF8.GetString(nameBytes); }
public static string getSinFromPem(string pem) { string[] keyInfo = keysFromPem(pem); string hexPubKey = keyInfo [1]; // Step 1 and 2 // Hex to Bytes, SHA-256 and RIPEMD-160 byte[] bytesPubKey1 = hexToBytes(hexPubKey); byte[] bytesPubKey2 = Utils.Sha256Hash160(bytesPubKey1); String shaAndRipe = Utils.BytesToHexString(bytesPubKey2); // Step 3 // Add 0F02 to Hex of Step 2 String step3 = "0F02" + shaAndRipe; // Step 4 // Hex to Bytes, Double SHA-256 byte[] bytesPubKey3 = hexToBytes(step3); byte[] bytesPubKey4 = Utils.DoubleDigest(bytesPubKey3); //Utils.doubleDigest(bytesPubKey3); // Step 5 // Substring of first 4 bytes (first 8 characters) String step4Hex = Utils.BytesToHexString(bytesPubKey4); String step5 = step4Hex.Substring(0, 8); // Step 6 // Combine step 3 and step 5 String step6 = step3 + step5; // Convert to base 58 byte[] step6bytes = hexToBytes(step6); String sin = Base58.Encode(step6bytes); return(sin); }
public static string KeyToString(byte[] key, string keyType, string prefix = null) { byte[] digest = null; if (keyType == "sha256x2") { digest = Sha256Manager.GetHash(Sha256Manager.GetHash(SerializationHelper.Combine(new List <byte[]>() { new byte[] { 128 }, key }))); } else if (!string.IsNullOrWhiteSpace(keyType)) { digest = Ripemd160Manager.GetHash(SerializationHelper.Combine(new List <byte[]>() { key, Encoding.UTF8.GetBytes(keyType) })); } else { digest = Ripemd160Manager.GetHash(key); } return(prefix + Base58.Encode(SerializationHelper.Combine(new List <byte[]>() { key, digest.Take(4).ToArray() }))); }
public void Base58EncodeTest(string key, string value) { var b = Hex.HexToBytes(value); var rez = Base58.Encode(b); Assert.IsTrue(key.Equals(rez)); }
public static string SignHash(string privateKeyString, byte[] hash) { try { ECPrivateKeyParameters privateKeyParameters = EosKeyHelper.GetECPrivateKeyParametersFromString(privateKeyString); ISigner signer = SignerUtilities.GetSigner("NONEwithECDSA"); signer.Init(true, privateKeyParameters); signer.BlockUpdate(hash, 0, hash.Length); byte[] sigBytes = signer.GenerateSignature(); var check = new List <byte[]>() { sigBytes, KEY_TYPE_BYTES }; var checksum = Ripemd160Manager.GetHash(SerializationHelper.Combine(check)).Take(CHECKSUM_LENGHT).ToArray(); var signAndChecksum = new List <byte[]>() { sigBytes, checksum }; var finalSig = SIG_PREFIX + Base58.Encode(SerializationHelper.Combine(signAndChecksum)); return(finalSig); } catch (Exception exc) { Console.WriteLine("Signing Failed: " + exc.ToString()); return(null); } }
public override bool IsValid(IList <Block> chain) { if (!base.IsValid(chain)) { return(false); } var members = chain.SelectMany(b => b.Members.Where(m => m.Address.SequenceEqual(PublicKey))).ToArray(); if (members.Length == 0) { // TODO: validar que el miembro sea de la organización ¿y que esté en el padrón o sea miembro desde antes del inicio de la votación? Messages.Add($"La persona [{Base58.Encode(PublicKey)}] no es miembro de esta comunidad"); return(false); } var member = members[0]; // TODO: ¿que pasa si los dos votos están entrando en el mismo bloque? foreach (var block in chain) { var previous = block.Votes.Any(v => v.QuestionId.Equals(QuestionId) && v.PublicKey.SequenceEqual(PublicKey)); if (previous) { Messages.Add($"La persona [{Base58.Encode(PublicKey)}] ya votó"); return(false); } } return(true); }
public async Task SerializeAndSignMultiActionTx() { var keyStore = new InMemoryKeyStore(); var keyPair = KeyPair.FromString("ed25519:2wyRcSwSuHtRVmkMCGjPwnzZmQLeXLzLLyED1NDMt4BjnKgQL6tF85yBx6Jr26D2dUNeC716RBoTxntVHsegogYw"); await keyStore.SetKeyAsync("test", "test.near", keyPair); var publicKey = keyPair.GetPublicKey(); var actions = new[] { Action.CreateAccount(), Action.DeployContract(new byte[] { 1, 2, 3 }), Action.FunctionCall("qqq", new byte[] { 1, 2, 3 }, 1000, 1000000), Action.Transfer(123), Action.Stake(1000000, publicKey), Action.AddKey(publicKey, AccessKey.FunctionCallAccessKey("zzz", new [] { "www" }, null)), Action.DeleteKey(publicKey), Action.DeleteAccount("123") }; var blockHash = new ByteArray32() { Buffer = Base58.Decode("244ZQ9cgj3CQ6bWBdytfrJMuMQ1jdXLFGnr4HhvtCTnM") }; var signedTransaction = await SignedTransaction.SignTransactionAsync("123", 1, actions, blockHash, new InMemorySigner(keyStore), "test.near", "test"); const string expected = "Fo3MJ9XzKjnKuDuQKhDAC6fra5H2UWawRejFSEpPNk3Y"; var actual = Base58.Encode(signedTransaction.Item1); Assert.AreEqual(expected, actual); }
public void Community() { var community1 = new Community { Id = new Guid("4814e8f885f74230b04d2daa4e2d88a4"), Name = "Crypto Vote", CreateAt = DateTimeOffset.FromUnixTimeMilliseconds(1551715934000) }; var keys = service.GeneratePair(); var signer = new Signer(service); community1.Signature = signer.Sign(community1.GetData(), keys); var signatureBase58 = Base58.Encode(community1.Signature); community1.PublicKey = new byte[keys.PublicKey.Length]; Buffer.BlockCopy(keys.PublicKey, 0, community1.PublicKey, 0, keys.PublicKey.Length); var json = JsonSerializer.Serialize(community1, JsonDefaultSettings.Options); Console.WriteLine(json); var community2 = JsonSerializer.Deserialize <Community>(json, JsonDefaultSettings.Options); var publicKeyBase58 = Base58.Encode(community2.PublicKey); var verifier = new SignatureVerify(service); Assert.IsTrue(verifier.Verify(community2)); Assert.IsTrue(verifier.Verify(community2.GetData(), Base58.Decode(publicKeyBase58), community2.Signature)); Assert.IsTrue(verifier.Verify(community2.GetData(), Base58.Decode(publicKeyBase58), Base58.Decode(signatureBase58))); }
public void Member() { var member1 = new Member { Id = new Guid("bedcbb2a476547d5b395524ffb6d157b"), CommunityId = new Guid("4814e8f885f74230b04d2daa4e2d88a4"), Name = "Nelo Pauselli" }; var keys = service.GeneratePair(); var signer = new Signer(service); member1.Signature = signer.Sign(member1.GetData(), keys); var signatureBase58 = Base58.Encode(member1.Signature); member1.PublicKey = new byte[keys.PublicKey.Length]; Buffer.BlockCopy(keys.PublicKey, 0, member1.PublicKey, 0, keys.PublicKey.Length); var json = JsonSerializer.Serialize(member1, JsonDefaultSettings.Options); Console.WriteLine(json); var member2 = JsonSerializer.Deserialize <Member>(json, JsonDefaultSettings.Options); var publicKeyBase58 = Base58.Encode(member2.PublicKey); var verifier = new SignatureVerify(service); Assert.IsTrue(verifier.Verify(member2)); Assert.IsTrue(verifier.Verify(member2.GetData(), Base58.Decode(publicKeyBase58), member2.Signature)); Assert.IsTrue(verifier.Verify(member2.GetData(), Base58.Decode(publicKeyBase58), Base58.Decode(signatureBase58))); }
public void Main4Test() { Wallet.WalletClient wallet = GetMainNetWalletClient; var keyTriple = new KeyTriple("B7E85CA5910922C49DCCB92EE48DFEC13A60674845CB7152C86B88F31DA6DC67"); byte[] hashTransaction1 = StringHelper.HexStringToByteArray("a7e974c6e69fb7741bf5e08de8a2d8f6617826c59422b440de22e0612b03c393"); BytesMessage bytesMessage1 = new BytesMessage(); bytesMessage1.Value = ByteString.CopyFrom(hashTransaction1); Transaction transactionLoad1 = wallet.GetTransactionByIdAsync(bytesMessage1).GetAwaiter().GetResult(); Transaction.Types.Contract contract = transactionLoad1.RawData.Contract[0]; TransferContract transferContract = TransferContract.Parser.ParseFrom(contract.Parameter.Value.ToByteArray()); byte[] publicKeyOwner = transferContract.OwnerAddress.ToByteArray(); string encode = Base58.Encode(publicKeyOwner); byte[] transactionRaw = transactionLoad1.RawData.ToByteArray(); byte[] hash = Sha256.Hash(transactionRaw); string signBase64 = transactionLoad1.Signature[0].ToBase64(); byte[] byteArray = transactionLoad1.Signature[0].ToByteArray(); bool isSignatureValidFromBytes = new ECSigner().IsSignatureValidFromBytes(hash, byteArray, publicKeyOwner); }
public override string ToString() { var checksum = Ripemd160Manager.GetHash(this.Data).Take(4).ToArray(); var public_key_with_checksum = this.Data.Concat(checksum).ToArray(); return(PREFIX + Base58.Encode(public_key_with_checksum)); }
public void Base58Test() { string userCode = "3999999"; string result = Base58.Encode(Encoding.UTF8.GetBytes(userCode)); Debug.WriteLine(result); }
public void getTransactionFromTestNetTesst() { Wallet.WalletClient wallet = GetMainNetWalletClient; // wallet.tra byte[] hashTransaction = StringHelper.HexStringToByteArray("d2e635f7c2d85cbcd343721047447b122a3c19e86f30651d8ec6ee76f744d065"); BytesMessage bytesMessage = new BytesMessage(); bytesMessage.Value = ByteString.CopyFrom(hashTransaction); // Transaction transactionLoad = wallet.GetTransactionByIdAsync(bytesMessage).GetAwaiter().GetResult(); // Transaction transactionLoad = wallet.GetTransactionByIdAsync(bytesMessage).GetAwaiter().GetResult(); NodeList nodeList = wallet.ListNodes(GetEmptyMessage); Block result = wallet.GetNowBlockAsync(GetEmptyMessage).GetAwaiter().GetResult(); //TK4BAeF72P3gop24RsoqPJynWgBBDv9fXX var keyTriple = new KeyTriple("B7E85CA5910922C49DCCB92EE48DFEC13A60674845CB7152C86B88F31DA6DC67"); byte[] addressWallet = keyTriple.GetAddressWallet(TypeNet.Main); string encode = Base58.Encode(addressWallet); Account account = new Account(); account.Address = ByteString.CopyFrom(addressWallet); Account account1 = wallet.GetAccountAsync(account).GetAwaiter().GetResult(); // new WalletExtension byte[] hashTransaction1 = StringHelper.HexStringToByteArray("a7e974c6e69fb7741bf5e08de8a2d8f6617826c59422b440de22e0612b03c393"); BytesMessage bytesMessage1 = new BytesMessage(); bytesMessage1.Value = ByteString.CopyFrom(hashTransaction1); Transaction transactionLoad1 = wallet.GetTransactionByIdAsync(bytesMessage1).GetAwaiter().GetResult(); TransferContract transferContract = TransferContract.Parser.ParseFrom(transactionLoad1.RawData.Contract[0].Parameter.Value.ToByteArray()); }
private void btnBase58Encode_Click(object sender, EventArgs e) { var buff = GetBase58PlainEncoding().GetBytes(txt_base58_plain.Text.Trim()); string cipher = Base58.Encode(buff); txt_base58_cipher.Text = cipher; }
public static Wallet Generate(bool compressed) { byte[] randomKey = Secp256K1Manager.GenerateRandomKey(); byte[] array1 = ((IEnumerable <byte>) new byte[1]).Concat <byte>((IEnumerable <byte>)Ripemd160Manager.GetHash(Sha256Manager.GetHash(Secp256K1Manager.GetPublicKey(randomKey, compressed)))).ToArray <byte>(); string pub = Base58.Encode(((IEnumerable <byte>)array1).Concat <byte>(((IEnumerable <byte>)Sha256Manager.GetHash(Sha256Manager.GetHash(array1))).Take <byte>(4)).ToArray <byte>()); byte[] array2; if (!compressed) { array2 = ((IEnumerable <byte>) new byte[1] { (byte)128 }).Concat <byte>((IEnumerable <byte>)randomKey).ToArray <byte>(); } else { array2 = ((IEnumerable <byte>) new byte[1] { (byte)128 }).Concat <byte>((IEnumerable <byte>)randomKey).Concat <byte>((IEnumerable <byte>) new byte[1] { (byte)1 }).ToArray <byte>(); } return(new Wallet(Base58.Encode(((IEnumerable <byte>)array2).Concat <byte>(((IEnumerable <byte>)Sha256Manager.GetHash(Sha256Manager.GetHash(array2))).Take <byte>(4)).ToArray <byte>()), pub)); }
public static Address GetLegacyAddress(string _private = "", bool _mainnet = true) { _private = _private == "" ? RandomPlus.RandomHex(64) : _private; BigInteger _privateInt = BigInteger.Parse("0" + _private, NumberStyles.HexNumber); byte[] _public = Secp256k1.PrivateKeyToPublicKey(_privateInt, false); RIPEMD160Managed _ripemd = new RIPEMD160Managed(); byte[] _ripemdHashed = _ripemd.ComputeHash(SHA.EncodeSHA256(_public)); byte[] _addedVersion = new byte[_ripemdHashed.Length + 1]; _addedVersion[0] = (byte)(_mainnet ? 0x00 : 0x6f); Array.Copy(_ripemdHashed, 0, _addedVersion, 1, _ripemdHashed.Length); byte[] _shaHashed = SHA.EncodeSHA256(SHA.EncodeSHA256(_addedVersion)); Array.Resize(ref _shaHashed, 4); byte[] _result = new byte[_addedVersion.Length + _shaHashed.Length]; Array.Copy(_addedVersion, 0, _result, 0, _addedVersion.Length); Array.Copy(_shaHashed, 0, _result, _addedVersion.Length, _shaHashed.Length); string _key1 = string.Join("", (_mainnet ? "80" : "ef"), _private); string _key2 = HexPlus.ByteArrayToHexString(SHA.EncodeSHA256(SHA.EncodeSHA256(HexPlus.HexStringToByteArray(_key1))).Take(4).ToArray()); Address _address = new Address { Text = Base58.Encode(_result), Public = HexPlus.ByteArrayToHexString(_public), Private = Base58.Encode(_key1 + _key2) }; return(_address); }
public Task <IEnumerable <string> > Sign(string chainId, IEnumerable <string> requiredKeys, byte[] signBytes, IEnumerable <string> abiNames = null) { var data = new List <byte[]>() { Hex.HexToBytes(chainId), signBytes, new byte[32] }; var hash = Sha256Manager.GetHash(SerializationHelper.Combine(data)); return(Task.FromResult(requiredKeys.Select(key => { var sign = Secp256K1Manager.SignCompressedCompact(hash, Keys[key]); var check = new List <byte[]>() { sign, KeyTypeBytes }; var checksum = Ripemd160Manager.GetHash(SerializationHelper.Combine(check)).Take(4).ToArray(); var signAndChecksum = new List <byte[]>() { sign, checksum }; return "SIG_K1_" + Base58.Encode(SerializationHelper.Combine(signAndChecksum)); }))); }
public static string CreateAccountAddressByPublicKeyHash(byte[] pubkHash) { //byte[] prefix = new byte[] { 0x00 }; //1 //byte[] prefix = new byte[] { 0x40, 0xE7, 0xE9, 0x26 }; //fiiit byte[] fullPrefix; if (GlobalParameters.IsTestnet) { fullPrefix = BitConverter.GetBytes(testnetPrefix); } else { fullPrefix = BitConverter.GetBytes(mainnetPrefix); } if (BitConverter.IsLittleEndian) { Array.Reverse(fullPrefix); } var payload = new List <byte>(); payload.AddRange(fullPrefix); payload.AddRange(pubkHash); var checksum = HashHelper.DoubleHash(payload.ToArray()).Take(4); payload.AddRange(checksum); return(Base58.Encode(payload.ToArray())); }
public static string ToAddress(UInt160 hash, bool p2sh) { byte version = p2sh ? P2SHVersion : CoinVersion; byte[] data = new byte[] { version }.Concat(hash.ToArray()).ToArray(); return(Base58.Encode(data.Concat(data.Sha256().Sha256().Take(4)).ToArray())); }
public static String deriveSIN(EcKey ecKey) { // Get sha256 hash and then the RIPEMD-160 hash of the public key (this call gets the result in one step). byte[] pubKeyHash = ecKey.PubKeyHash; // Convert binary pubKeyHash, SINtype and version to Hex String version = "0F"; String SINtype = "02"; String pubKeyHashHex = bytesToHex(pubKeyHash); // Concatenate all three elements String preSIN = version + SINtype + pubKeyHashHex; // Convert the hex string back to binary and double sha256 hash it leaving in binary both times byte[] preSINbyte = hexToBytes(preSIN); byte[] hash2Bytes = Utils.DoubleDigest(preSINbyte); // Convert back to hex and take first four bytes String hashString = bytesToHex(hash2Bytes); String first4Bytes = hashString.Substring(0, 8); // Append first four bytes to fully appended SIN string String unencoded = preSIN + first4Bytes; byte[] unencodedBytes = new BigInteger(unencoded, 16).ToByteArray(); String encoded = Base58.Encode(unencodedBytes); return(encoded); }
public void Vote() { var vote1 = new Vote { QuestionId = new Guid("bd746b3b276e454a8B1e041cf53a8747"), ChoiceId = Guid.NewGuid(), Time = DateTimeOffset.Now.ToUnixTimeMilliseconds() }; var keys = service.GeneratePair(); var signer = new Signer(service); vote1.Signature = signer.Sign(vote1.GetData(), keys); var signatureBase58 = Base58.Encode(vote1.Signature); vote1.PublicKey = new byte[keys.PublicKey.Length]; Buffer.BlockCopy(keys.PublicKey, 0, vote1.PublicKey, 0, keys.PublicKey.Length); var json = JsonSerializer.Serialize(vote1, JsonDefaultSettings.Options); Console.WriteLine(json); var vote = JsonSerializer.Deserialize <Vote>(json, JsonDefaultSettings.Options); var publicKeyBase58 = Base58.Encode(vote.PublicKey); var verifier = new SignatureVerify(service); }
/// <summary> /// compress private key /// https://sourceforge.net/p/bitcoin/mailman/bitcoin-development/thread/CAPg+sBhDFCjAn1tRRQhaudtqwsh4vcVbxzm+AA2OuFxN71fwUA@mail.gmail.com/ /// </summary> /// <param name="_uncompressKey"></param> /// <returns></returns> public static string CompressPrivateKey(string _uncompressKey, bool _mainnet) { string _orgKey = string.Join("", (!_mainnet ? "ef" : "80"), _uncompressKey); string _addmin = HexPlus.ByteArrayToHexString(Lion.Encrypt.SHA.EncodeSHA256(Lion.Encrypt.SHA.EncodeSHA256(Lion.HexPlus.HexStringToByteArray(_orgKey))).Take(4).ToArray()); return(Base58.Encode(_orgKey + _addmin)); }
public static Address GenerateAddress(out string _uncompressKey, string _existsPrivateKey = "", bool _mainNet = true) { string _netVersion = _mainNet ? "00" : "6f"; string _privateKey = string.IsNullOrWhiteSpace(_existsPrivateKey) ? Lion.RandomPlus.RandomHex() : _existsPrivateKey; _uncompressKey = _privateKey; BigInteger _bigPrivateKey = BigInteger.Parse("0" + _privateKey, System.Globalization.NumberStyles.HexNumber); var _publicKey = Secp256k1.PrivateKeyToPublicKey(_bigPrivateKey); SHA256Managed sha256 = new SHA256Managed(); var _ripemd = new RIPEMD160Managed(); var _ripemdHashed = _ripemd.ComputeHash(sha256.ComputeHash(_publicKey)); var _addedVersion = new byte[_ripemdHashed.Length + 1]; if (!_mainNet) { _addedVersion[0] = 0x6f; } Buffer.BlockCopy(_ripemdHashed, 0, _addedVersion, 1, _ripemdHashed.Length); var _doubleSha = sha256.ComputeHash(sha256.ComputeHash(_addedVersion)); Array.Resize(ref _doubleSha, 4); byte[] _result = new byte[_addedVersion.Length + _doubleSha.Length]; Buffer.BlockCopy(_addedVersion, 0, _result, 0, _addedVersion.Length); Buffer.BlockCopy(_doubleSha, 0, _result, _addedVersion.Length, _doubleSha.Length); Address _address = new Address(); _address.Text = Base58.Encode(_result); _address.PublicKey = Lion.HexPlus.ByteArrayToHexString(_publicKey); _address.PrivateKey = CompressPrivateKey(_privateKey, _mainNet); _address.Text = (_mainNet ? (_address.Text.StartsWith("1") ? "" : "1") : "") + _address.Text; return(_address); }
public static Address GenerateAddress(string _privateKey = "", bool _mainNet = true) { _privateKey = _privateKey == "" ? RandomPlus.RandomHex(64) : _privateKey; BigInteger _privateInt = BigInteger.Parse("0" + _privateKey, System.Globalization.NumberStyles.HexNumber); byte[] _publicKey = Secp256k1.PrivateKeyToPublicKey(_privateInt); SHA256Managed _sha256 = new SHA256Managed(); RIPEMD160Managed _ripemd = new RIPEMD160Managed(); byte[] _ripemdHashed = _ripemd.ComputeHash(_sha256.ComputeHash(_publicKey)); byte[] _addedVersion = new byte[_ripemdHashed.Length + 1]; _addedVersion[0] = (byte)(_mainNet ? 0x00 : 0x6f); Array.Copy(_ripemdHashed, 0, _addedVersion, 1, _ripemdHashed.Length); byte[] _shaHashed = _sha256.ComputeHash(_sha256.ComputeHash(_addedVersion)); Array.Resize(ref _shaHashed, 4); byte[] _result = new byte[_addedVersion.Length + _shaHashed.Length]; Array.Copy(_addedVersion, 0, _result, 0, _addedVersion.Length); Array.Copy(_shaHashed, 0, _result, _addedVersion.Length, _shaHashed.Length); string _key1 = string.Join("", (_mainNet ? "80" : "ef"), _privateKey); string _key2 = HexPlus.ByteArrayToHexString(SHA.EncodeSHA256(SHA.EncodeSHA256(HexPlus.HexStringToByteArray(_key1))).Take(4).ToArray()); Address _address = new Address(); _address.Text = Base58.Encode(_result); _address.PublicKey = HexPlus.ByteArrayToHexString(_publicKey); _address.PrivateKey = Base58.Encode(_key1 + _key2); _address.Text = (_mainNet ? (_address.Text.StartsWith("1") ? "" : "1") : "") + _address.Text; return(_address); }
// Converts a set of public keys to a readable address public static string AddressFromKeys(string PublicSpendKey, string PublicViewKey, ulong Prefix) { // First we create a byte buffer byte[] Buffer = new byte[0]; // Pack address prefix into buffer Buffer = Buffer.AppendVarInt(Prefix); // Add keys to buffer Buffer = Buffer.AppendBytes(HexStringToByteArray(PublicSpendKey)); Buffer = Buffer.AppendBytes(HexStringToByteArray(PublicViewKey)); // Append buffer checksum to buffer Buffer = Buffer.AppendBytes(Keccak.KeccakHash(Buffer, 4)); /* Now we have to encode our address in base58 - but we do it in * a bit of an odd way, in blocks. We take 8 bytes at a time, * and convert it to base58. Then, if the block converts to less * than 11 base58 chars, we pad it with ones (1 is 0 in Base58) * * The final block however is not padded to 11 chars, rather it * is padded to the length of the hex string modulo 8. * * This ensures addresses are always the same length. */ // Split buffer into chunks of 8 var Chunks = Buffer.ChunkBy(8); // Create an output string for our address string Output = ""; // The size of the remainder after chunking into groups of 8 int LastChunkSize = Buffer.Length % 8; // Loop through all chunks for (int i = 0; i < Chunks.Count; i++) { // Encode the chunk into a base58 string string AddrChunk = Base58.Encode(Chunks[i]); // Pad to 11 chars with ones, i.e. 0 in base58 - we pad at the beginning if (i < Chunks.Count - 1) { AddrChunk = AddrChunk.PadLeft(11, LeadingChar); } // Last iteration, we do different padding else { AddrChunk = AddrChunk.PadLeft(LastChunkSize, LeadingChar); } // Add address chunk to output string Output += AddrChunk; } // Return resulting address string return(Output); }
private static string GetKey(byte[] content) { RIPEMD160Managed ripemd160Managed = new RIPEMD160Managed(); var part1 = ripemd160Managed.ComputeHash(content); var part2 = SHA1.Create().ComputeHash(content); return(Base58.Encode(part1.Concat(part2).ToArray())); }
public string GetSignature(byte[] bytes) { if (privateKey == null) { throw new KeyError("Cannot sign the context. No private key in account."); } return(Base58.Encode(cipher.calculateSignature(this.privateKey, bytes))); }
public void Java() { var input = "QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB"; var output = Base58.Decode(input); var encoded = Base58.Encode(output); Assert.Equal(input, encoded); }
public static void EncodeDoesNotModifyArray() { var b1 = new byte[] { 0, 1, 2, 3, 4, 5 }; var b2 = new byte[] { 0, 1, 2, 3, 4, 5 }; Base58.Encode(b1); Assert.Equal(b1, b2); }