public string ToPtsAddy()
{
var buffer = ToBuffer(true);
var firstHash = SHA256.Create().HashAndDispose(buffer);
buffer.Clear();
var secondHash = RIPEMD160.Create().HashAndDispose(firstHash);
firstHash.Clear();
var hash = new byte[] { 0x38 }.Concat(secondHash); // version 56(decimal)
secondHash.Clear();
var firstChecksum = SHA256.Create().HashAndDispose(hash);
var secondChecksum = SHA256.Create().HashAndDispose(firstChecksum);
firstChecksum.Clear();
var checksum = secondChecksum.Slice(0, 4);
secondChecksum.Clear();
buffer = hash.Concat(checksum);
checksum.Clear();
hash.Clear();
var result = Base58CheckEncoding.EncodePlain(buffer);
buffer.Clear();
return(result);
}
public static void Do()
{
for (var i = 0; i < 100; i++)
{
BigInteger randomBigInt = i;
var randomBytes = new byte[] { 0x00, 0x00, 0x00, 0x00 };
var bigIntByteArray = randomBigInt.ToByteArray();
if (bigIntByteArray.Length == 1)
{
randomBytes[3] = bigIntByteArray[0];
}
if (bigIntByteArray.Length == 2)
{
randomBytes[3] = bigIntByteArray[0];
randomBytes[2] = bigIntByteArray[1];
}
if (bigIntByteArray.Length == 3)
{
randomBytes[3] = bigIntByteArray[0];
randomBytes[2] = bigIntByteArray[1];
randomBytes[1] = bigIntByteArray[2];
}
var base58String = Base58CheckEncoding.EncodePlain(randomBytes);
Console.WriteLine($"Bytes: {string.Concat(randomBytes.Select(b => b.ToString("X2")))} Byte length: {bigIntByteArray.Length}, {base58String}");
}
}
public API_History_4_3(SealedTransaction T)
{
id = ConvertTransactionId(T.Id);
source = Base58CheckEncoding.EncodePlain(T.Trxn.Source);
target = Base58CheckEncoding.EncodePlain(T.Trxn.Target);
amount = BcToDouble(T.Trxn.Amount);
fee = BcFeeConvert(T.Trxn.Fee.Commission);
timeCreation = new DateTime(T.Trxn.TimeCreation);
userFields = T.Trxn.UserFields;
type = (API_TransactionType)T.Trxn.Type;
if (T.Trxn.ExtraFee != null)
{
extraFee = T.Trxn.ExtraFee.Select(m => (API_ExtraFee) new API_ExtraFee_4_3(m)).ToList();
}
if (T.Trxn.SmartContract != null)
{
smartContract = new API_SmartContract_4_3(T.Trxn.SmartContract);
}
if (T.Trxn.SmartInfo != null)
{
smartInfo = new API_SmartTransInfo_4_3(T.Trxn.SmartInfo);
}
}
public string ToAddressString(string addressPrefix = null)
{
if (addressPrefix.IsNull())
{
addressPrefix = ChainConfig.AddressPrefix;
}
var buffer = ToBuffer(true);
var hash = SHA512.Create().HashAndDispose(buffer);
buffer.Clear();
var firstChecksum = RIPEMD160.Create().HashAndDispose(hash);
hash.Clear();
var secondChecksum = RIPEMD160.Create().HashAndDispose(firstChecksum);
var checksum = secondChecksum.Slice(0, 4);
secondChecksum.Clear();
buffer = firstChecksum.Concat(checksum);
firstChecksum.Clear();
checksum.Clear();
var result = addressPrefix + Base58CheckEncoding.EncodePlain(buffer);
buffer.Clear();
return(result);
}
public static void Do2()
{
var lengths = new Dictionary <int, List <string> >();
for (var i = 0; i < 100; i++)
{
var b = ByteUtils.RandomBytes(4);
Console.WriteLine(BitConverter.ToString(b).Replace("-", string.Empty));
var byteString = Base58CheckEncoding.EncodePlain(b);
var length = byteString.Length;
// Console.WriteLine(byteString);
if (lengths.ContainsKey(length))
{
lengths[length].Append(byteString);
}
else
{
lengths.Add(length, new List <string> {
byteString
});
}
}
foreach (var v in lengths.Keys)
{
Console.WriteLine($"{v}: {lengths[v][0]}");
}
foreach (var length in lengths)
{
Console.WriteLine($"Kvp - [length, occurrences] {length}.");
}
}
/// <inheritdoc/>
public async Task <byte[]> DownloadBytesAsync(byte[] address)
{
if (downloadClient != null)
{
byte[] bytes = new byte[digestSize + 2];
bytes[0] = fnCode;
bytes[1] = digestSize;
address.CopyTo(bytes, 2);
//Encoding.Unicode.GetBytes(address, 0, address.Length, bytes, 2);
string hash = Base58CheckEncoding.EncodePlain(bytes);
RestRequest downloadRequest = new RestRequest("/ipfs/" + hash, Method.GET);
downloadRequest.AddDecompressionMethod(System.Net.DecompressionMethods.None);
IRestResponse response = await downloadClient.ExecuteGetTaskAsync(downloadRequest);
if (response.ErrorException != null)
{
// TODO: throw some kind of custom exception on unsuccessful upload
throw new Exception();
}
return(response.RawBytes);
}
return(null);
}
public BalanceToken BalanceTokenModel(TokenBalance model)
{
return(new BalanceToken
{
Code = model.Code,
Token = Base58CheckEncoding.EncodePlain(model.Token),
Balance = model.Balance
});
}
public API_TokenTransferTransInfo_4_3(TokenTransferTransInfo I)
{
Code = I.Code;
Sender = Base58CheckEncoding.EncodePlain(I.Sender);
Receiver = Base58CheckEncoding.EncodePlain(I.Receiver);
Amount = I.Amount;
State = (API_SmartOperationState)I.State;
StateTransaction = ConvertTransactionId(I.StateTransaction);
TransferSuccess = I.TransferSuccess;
}
public void EncodePlan_And_DecodePlain_ByteString()
{
var bs = ByteString.CopyFromUtf8("test byte string");
var encodeMessage = Base58CheckEncoding.EncodePlain(bs);
var decodeMessage = Base58CheckEncoding.DecodePlain(encodeMessage);
var bs1 = ByteString.CopyFrom(decodeMessage);
bs.ShouldBe(bs1);
}
public void Encode()
{
foreach (var tuple in _testCases)
{
var bytes = tuple.Item2;
var expectedText = tuple.Item1;
var actualText = Base58CheckEncoding.EncodePlain(bytes);
Assert.AreEqual(expectedText, actualText);
}
}
public API_TokenTransfer_4_3(TokenTransfer tt)
{
Token = Base58CheckEncoding.EncodePlain(tt.Token);
Code = tt.Code;
Sender = Base58CheckEncoding.EncodePlain(tt.Sender);
Receiver = Base58CheckEncoding.EncodePlain(tt.Receiver);
Amount = tt.Amount;
Initiator = Base58CheckEncoding.EncodePlain(tt.Initiator);
Transaction = ConvertTransactionId(tt.Transaction);
Time = tt.Time;
}
/// <summary>
/// Encode a publicKey into miniLock format.
/// </summary>
/// <param name="publicKey">A 32 byte publicKey.</param>
/// <exception cref="Sodium.Exceptions.KeyOutOfRangeException"></exception>
/// <returns>A Base58 encoded publicKey.</returns>
public static string EncodeMiniLockPublicKey(byte[] publicKey)
{
if (publicKey == null || publicKey.Length != PublicKeyBytes)
{
throw new KeyOutOfRangeException("publicKey", (publicKey == null) ? 0 : publicKey.Length,
string.Format("key must be {0} bytes in length.", PublicKeyBytes));
}
var final = ArrayHelper.ConcatArrays(publicKey, Blake2S.Hash(publicKey, (byte[])null, 1));
return(Base58CheckEncoding.EncodePlain(final));
}
public void EncodePlain_And_DecodePlain_Address()
{
var address = Address.Generate();
var data = address.DumpByteArray();
var enCode = Base58CheckEncoding.EncodePlain(data);
enCode.ShouldNotBe(string.Empty);
var deCode = Base58CheckEncoding.DecodePlain(enCode);
deCode.ShouldBe(data);
}
/// <summary>
/// Encode a publicKey into bytejail format.
/// </summary>
/// <param name="publicKey">A 32 byte publicKey.</param>
/// <exception cref="KeyOutOfRangeException"></exception>
/// <returns>A Base58 encoded publicKey.</returns>
public static string EncodeBytejailPublicKey(byte[] publicKey)
{
if (publicKey == null || publicKey.Length != PublicKeyBytes)
{
throw new KeyOutOfRangeException("publicKey", (publicKey == null) ? 0 : publicKey.Length,
string.Format("key must be {0} bytes in length.", PublicKeyBytes));
}
var final = ArrayHelper.ConcatArrays(new[] { BytejailVersionPrefix }, publicKey, CalculateBytejailChecksum(new[] { BytejailVersionPrefix }, publicKey));
return(Base58CheckEncoding.EncodePlain(final));
}
public void EncodePlain_And_DecodePlain_Address()
{
var address = Address.FromBase58("2DZER7qHVwv3PUMFsHuQaQbE4wDFsCRzJsxLwYEk8rgM3HVn1S");
var data = address.ToByteArray();
var enCode = Base58CheckEncoding.EncodePlain(data);
enCode.ShouldNotBe(string.Empty);
var deCode = Base58CheckEncoding.DecodePlain(enCode);
deCode.ShouldBe(data);
}
public string ToPublicKeyString(string addressPrefix = null)
{
if (addressPrefix.IsNull())
{
addressPrefix = ChainConfig.AddressPrefix;
}
var buffer = ToBuffer();
var result = addressPrefix + Base58CheckEncoding.EncodePlain(buffer);
buffer.Clear();
return(result);
}
public void Encode(byte[] value, string fileName)
{
string newValue = Base58CheckEncoding.EncodePlain(value);
var result = new FileStream(fileName + Extension, FileMode.Create);
using (var writer = new StreamWriter(result))
{
writer.Write(newValue);
}
result.Close();
}
public void TestInvalidChecksum()
{
byte[] expected_result = UTF8Encoding.UTF8.GetBytes("hello world");
string header = "header-part ";
string footer = " footer part.";
string encoded = header + Base58CheckEncoding.EncodePlain(expected_result) + footer;
SimplePack packer = new SimplePack(header, footer);
try{
packer.decode(encoded);
}
catch (System.FormatException) { return; }
Assert.Fail(); // Did not catch no checksum, fail
}
public static void Do3()
{
for (var i = 0; i < 10000; i++)
{
var random = new Random();
BigInteger randomBigInt = random.Next(195112, 11316495);
var randomBytes = new byte[3];
var bigIntByteArray = randomBigInt.ToByteArray();
randomBytes[0] = bigIntByteArray[2];
randomBytes[1] = bigIntByteArray[1];
randomBytes[2] = bigIntByteArray[0];
var base58String = Base58CheckEncoding.EncodePlain(randomBytes);
Console.WriteLine($"Bytes: {string.Concat(randomBytes.Select(b => b.ToString("X2")))} Byte length: {randomBytes.Length}, {base58String}");
}
}
public static void Do4()
{
for (var i = 195112; i < 11316496; i++)
{
BigInteger randomBigInt = i;
var randomBytes = new byte[3];
var bigIntByteArray = randomBigInt.ToByteArray();
randomBytes[0] = bigIntByteArray[2];
randomBytes[1] = bigIntByteArray[1];
randomBytes[2] = bigIntByteArray[0];
var base58String = Base58CheckEncoding.EncodePlain(randomBytes);
if (base58String.Length != 4)
{
Console.WriteLine($"Bytes: {string.Concat(randomBytes.Select(b => b.ToString("X2")))} Byte length: {randomBytes.Length}, {base58String}");
}
}
}
public void EncodePlain_And_DecodePlain_Hash()
{
var hash = HashHelper.ComputeFrom("hash");
var data = hash.ToByteArray();
var bytes = new byte[] { 0 };
var enCode = Base58CheckEncoding.EncodePlain(data);
enCode.ShouldNotBe(string.Empty);
var deCode = Base58CheckEncoding.DecodePlain(enCode);
deCode.ShouldBe(data);
Base58CheckEncoding.EncodePlain(bytes).ShouldBe("1");
Should.Throw <FormatException>(() => {
Base58CheckEncoding.DecodePlain(bytes.ToString());
});
Should.Throw <FormatException>(() => { Base58CheckEncoding.Decode(enCode); });
}
public List <WalletAllBalance> Balance(byte[] PublicKey)
{
List <WalletAllBalance> Res = new List <WalletAllBalance>();
WalletBalanceGetResult CS_Bal = CS_Balance(PublicKey);
if (CS_Bal.Status.Code > 0)
{
throw new Exception(CS_Bal.Status.Message);
}
TokenBalancesResult Token_Balance = TokenBalance(PublicKey);
if (Token_Balance.Status.Code > 0)
{
throw new Exception(Token_Balance.Status.Message);
}
Res.Add(WalletAllBalance.Create(BcToDouble(CS_Bal.Balance)));
foreach (TokenBalance item in Token_Balance.Balances)
{
//Delete trycatch block
try
{
Res.Add(WalletAllBalance.Create(
Convert.ToDouble(item.Balance),
Base58CheckEncoding.EncodePlain(item.Token),
item.Code,
item.Name)
);
}
catch (Exception)
{
Console.WriteLine("");
}
}
return(Res);
}
public string ToWif()
{
var key = ToBuffer();
var buffer = new byte[] { 0x80 }.Concat(key);
key.Clear();
var firstChecksum = SHA256.Create().HashAndDispose(buffer);
var secondChecksum = SHA256.Create().HashAndDispose(firstChecksum);
firstChecksum.Clear();
var checksum = secondChecksum.Slice(0, 4);
secondChecksum.Clear();
var fullBuffer = buffer.Concat(checksum);
buffer.Clear();
checksum.Clear();
var wif = Base58CheckEncoding.EncodePlain(fullBuffer);
fullBuffer.Clear();
return(wif);
}
// /**
// * Construct an empty Transaction
// */
// constructor(opts?: TransactionCtorFields)
// {
// opts && Object.assign(this, opts);
// }
// /**
// * Add one or more instructions to this Transaction
// */
// add(
// ...items: Array<
// Transaction | TransactionInstruction | TransactionInstructionCtorFields
// >
// ) : Transaction {
// if (items.length === 0) {
// throw new Error('No instructions');
// }
// items.forEach((item: any) => {
// if ('instructions' in item) {
// this.instructions = this.instructions.concat(item.instructions);
// } else if ('data' in item && 'programId' in item && 'keys' in item) {
// this.instructions.push(item);
// } else {
// this.instructions.push(new TransactionInstruction(item));
// }
// });
//return this;
// }
/// <summary>
/// Compile transaction data
/// </summary>
/// <returns></returns>
public Message compileMessage()
{
var nonceInfo = this.nonceInfo;
if (nonceInfo != null && this.instructions[0] != nonceInfo.nonceInstruction)
{
this.recentBlockhash = nonceInfo.nonce;
this.instructions.Insert(0, nonceInfo.nonceInstruction);
}
var recentBlockhash = this.recentBlockhash;
if (recentBlockhash.Length < 1)
{
throw new Exception("Transaction recentBlockhash required");
}
if (this.instructions.Count < 1)
{
throw new Exception("No instructions provided");
}
PublicKey feePayer;
if (this.feePayer != null)
{
feePayer = this.feePayer;
}
else if (signatures.Count > 0 && signatures[0].publicKey != null)
{
// Use implicit fee payer
feePayer = this.signatures[0].publicKey;
}
else
{
throw new Exception("Transaction fee payer required");
}
for (var i = 0; i < this.instructions.Count(); i++)
{
if (this.instructions[i].programId == null)
{
throw new Exception(string.Format("Transaction instruction index {0} has undefined program id", i));
}
}
List <string> programIds = new List <string>();
List <AccountMeta> accountMetas = new List <AccountMeta>();
this.instructions.ForEach(instruction => {
instruction.keys.ForEach(accountMeta =>
{
accountMetas.Add(accountMeta);
});
var programId = instruction.programId.ToString();
if (!programIds.Contains(programId))
{
programIds.Add(programId);
}
});
// Append programID account metas
programIds.ForEach(programId => {
accountMetas.Add(new AccountMeta()
{
pubkey = new PublicKey(programId),
isSigner = false,
isWritable = false,
});
});
// Sort. Prioritizing first by signer, then by writable
accountMetas.Sort((x, y) => {
var checkSigner = x.isSigner == y.isSigner ? 0 : x.isSigner ? -1 : 1;
var checkWritable = x.isWritable == y.isWritable ? 0 : x.isWritable ? -1 : 1;
return(Convert.ToBoolean(checkSigner) ? checkSigner : checkWritable);
});
// Cull duplicate account metas
List <AccountMeta> uniqueMetas = new List <AccountMeta>();
accountMetas.ForEach(accountMeta =>
{
var pubkeyString = accountMeta.pubkey.ToString();
var uniqueIndex = uniqueMetas.FindIndex(x =>
{
return(x.pubkey.ToString() == pubkeyString);
});
if (uniqueIndex > -1)
{
var meta = uniqueMetas[uniqueIndex];
meta.isWritable = meta.isWritable || accountMeta.isWritable;
uniqueMetas[uniqueIndex] = meta;
}
else
{
uniqueMetas.Add(accountMeta);
}
});
// Move fee payer to the front
var feePayerIndex = uniqueMetas.FindIndex(x =>
{
return(x.pubkey.Equals(feePayer));
});
if (feePayerIndex > -1)
{
var payerMeta = uniqueMetas[feePayerIndex];
payerMeta.isSigner = true;
payerMeta.isWritable = true;
uniqueMetas.Insert(0, payerMeta);
}
else
{
uniqueMetas.Insert(0, new AccountMeta()
{
pubkey = feePayer,
isSigner = true,
isWritable = true,
});
}
// Disallow unknown signers
foreach (var signature in this.signatures)
{
var uniqueIndex = uniqueMetas.FindIndex(x =>
{
return(x.pubkey.Equals(signature.publicKey));
});
if (uniqueIndex > -1)
{
if (!uniqueMetas[uniqueIndex].isSigner)
{
var meta = uniqueMetas[uniqueIndex];
meta.isSigner = true;
uniqueMetas[uniqueIndex] = meta;
//console.warn(
// 'Transaction references a signature that is unnecessary, ' +
// 'only the fee payer and instruction signer accounts should sign a transaction. ' +
// 'This behavior is deprecated and will throw an error in the next major version release.',
//);
}
}
else
{
throw new Exception(string.Format("unknown signer: {0}", signature.publicKey.ToString()));
}
}
var numRequiredSignatures = 0;
var numReadonlySignedAccounts = 0;
var numReadonlyUnsignedAccounts = 0;
// Split out signing from non-signing keys and count header values
List <string> signedKeys = new List <string>();
List <string> unsignedKeys = new List <string>();
uniqueMetas.ForEach(meta => {
if (meta.isSigner)
{
signedKeys.Add(meta.pubkey.ToString());
numRequiredSignatures += 1;
if (!meta.isWritable)
{
numReadonlySignedAccounts += 1;
}
}
else
{
unsignedKeys.Add(meta.pubkey.ToString());
if (!meta.isWritable)
{
numReadonlyUnsignedAccounts += 1;
}
}
});
signedKeys.AddRange(unsignedKeys);
var accountKeys = signedKeys;
var instructions = this.instructions.Select(
instruction =>
{
var data = instruction.data;
var programId = instruction.programId;
//const { data, programId} = instruction;
var cin = new CompiledInstruction();
cin.programIdIndex = accountKeys.IndexOf(programId.ToString());
cin.accounts = instruction.keys.Select(meta => accountKeys.IndexOf(meta.pubkey.ToString())).ToArray();
cin.data = Base58CheckEncoding.EncodePlain(data);
return(cin);
}).ToList();
instructions.ForEach(instruction =>
{
if (!(instruction.programIdIndex >= 0))
{
throw new Exception("instruction.programIdIndex error");
}
foreach (var keyIndex in instruction.accounts)
{
if (keyIndex < 0)
{
throw new Exception("instruction.accounts error");
}
}
});
var args = new MessageArgs()
{
header = new MessageHeader()
{
numRequiredSignatures = numRequiredSignatures,
numReadonlySignedAccounts = numReadonlySignedAccounts,
numReadonlyUnsignedAccounts = numReadonlyUnsignedAccounts
},
accountKeys = accountKeys.ToArray(),
recentBlockhash = recentBlockhash,
instructions = instructions.ToArray()
};
return(new Message(args));
}
public override string ToString()
{
return(Base58CheckEncoding.EncodePlain(bytes));
}