/// <summary>
/// check that the words we'rent modified
/// </summary>
static Wordlist()
{
if (!Mnemonic.Checksum(Encoding.ASCII.GetBytes(JavaHelper <string> .ArrayToString(RAW))).Equals(RAW_CHECKSUM))
{
throw new Exception("cannot initialize passphrase library: wordlist corrupted");
}
}
static int CheckIntConstBlock(byte[] program, int pc)
{
int size = 1;
VarintResult result = Uvarint.GetUvarint(JavaHelper <byte> .ArrayCopyRange(program, pc + size, program.Length));
if (result.length <= 0)
{
throw new ArgumentException(string.Format("could not decode int const block at pc=%d", pc));
}
else
{
size = size + result.length;
int numInts = result.value;
for (int i = 0; i < numInts; ++i)
{
if (pc + size >= program.Length)
{
throw new ArgumentException("int const block exceeds program length");
}
result = Uvarint.GetUvarint(JavaHelper <byte> .ArrayCopyRange(program, pc + size, program.Length));
if (result.length <= 0)
{
throw new ArgumentException(string.Format("could not decode int const[%d] block at pc=%d", i, pc + size));
}
size += result.length;
}
return(size);
}
}
/// <summary>
/// toKey converts a mnemonic generated using this library into the source
/// key used to create it. It returns an error if the passed mnemonic has an
/// incorrect checksum, if the number of words is unexpected, or if one
/// of the passed words is not found in the words list.
/// </summary>
/// <param name="mnemonicStr">words delimited by MNEMONIC_DELIM</param>
/// <returns>32 byte array key</returns>
public static byte[] ToKey(string mnemonicStr)
{
if (mnemonicStr is null)
{
throw new ArgumentException("mnemonic must not be null");
}
//Objects.requireNonNull(mnemonicStr, "mnemonic must not be null");
string[] mnemonic = mnemonicStr.Split(MNEMONIC_DELIM);
if (mnemonic.Length != MNEM_LEN_WORDS)
{
throw new ArgumentException("mnemonic does not have enough words");
}
// convert to uint11
int numWords = MNEM_LEN_WORDS - CHECKSUM_LEN_WORDS;
int[] uint11Arr = new int[numWords];
for (int i = 0; i < numWords; i++)
{
uint11Arr[i] = -1;
}
for (int w = 0; w < Wordlist.RAW.Length; w++)
{
for (int i = 0; i < numWords; i++)
{
if (Wordlist.RAW[w].Equals(mnemonic[i]))
{
uint11Arr[i] = w;
}
}
}
for (int i = 0; i < numWords; i++)
{
if (uint11Arr[i] == -1)
{
throw new ArgumentException("mnemonic contains word that is not in word list");
}
}
byte[] b = ToByteArray(uint11Arr);
// chop the last byte. The last byte was 3 bits, padded with 8 bits to create the 24th word.
// Those last padded 8 bits is an extra zero byte.
if (b.Length != KEY_LEN_BYTES + 1)
{
throw new ArgumentException("wrong key length");
}
if (b[KEY_LEN_BYTES] != (byte)0)
{
throw new ArgumentException("unexpected byte from key");
}
//byte[] bCopy = new byte[KEY_LEN_BYTES];
byte[] bCopy = JavaHelper <byte> .ArrayCopyOf(b, KEY_LEN_BYTES);
string chkWord = Checksum(bCopy);
if (!chkWord.Equals(mnemonic[MNEM_LEN_WORDS - CHECKSUM_LEN_WORDS]))
{
throw new ArgumentException("checksum failed to validate");
}
return(JavaHelper <byte> .ArrayCopyOf(b, KEY_LEN_BYTES));
}
public SignedBid(Bid bid, Signature sig, MultisigSignature mSig)
{
this.bid = JavaHelper <Bid> .RequireNotNull(bid, "tx must not be null");
this.mSig = JavaHelper <MultisigSignature> .RequireNotNull(mSig, "mSig must not be null");
this.sig = JavaHelper <Signature> .RequireNotNull(sig, "sig must not be null");
}
/// <summary>
/// Return encoded representation of the transaction with a prefix suitable for signing
/// </summary>
/// <returns>bytes</returns>
private byte[] BytesToSign()
{
byte[] encodedTx = Encoder.EncodeToMsgPack(this);
byte[] prefixEncodedTx = JavaHelper <byte> .ArrayCopyOf(TG_PREFIX, TG_PREFIX.Length + encodedTx.Length);
JavaHelper <byte> .SyatemArrayCopy(encodedTx, 0, prefixEncodedTx, TG_PREFIX.Length, encodedTx.Length);
return(prefixEncodedTx);
}
public MultisigSubsig(Ed25519PublicKeyParameters key, Signature sig = null)
{
this.key = JavaHelper <Ed25519PublicKeyParameters> .RequireNotNull(key, "public key cannot be null");
if (sig is null)
{
this.sig = new Signature();
}
else
{
this.sig = sig;
}
}
public TEALProgram(byte[] program)
{
if (program == null)
{
return;
}
try
{
Logic.ReadProgram(program, null);
}
catch (Exception e)
{
throw new ArgumentException(e.Message);
}
this.program = JavaHelper <byte> .ArrayCopyOf(program, program.Length);
}
public override void NextBytes(byte[] bytes)
{
if (this.index >= this.fixedValue.Length)
{
// no more data to copy
return;
}
int len = bytes.Length;
if (len > this.fixedValue.Length - this.index)
{
len = this.fixedValue.Length - this.index;
}
JavaHelper <byte> .SyatemArrayCopy(this.fixedValue, this.index, bytes, 0, len);
this.index += bytes.Length;
}
public static ByteConstBlock ReadByteConstBlock(byte[] program, int pc)
{
List <byte[]> results = new List <byte[]>();
int size = 1;
VarintResult result = GetUVarint(program, pc + size);
if (result.length <= 0)
{
throw new ArgumentException(
string.Format("could not decode byte[] const block at pc=%d", pc)
);
}
size += result.length;
int numInts = result.value;
for (int i = 0; i < numInts; i++)
{
if (pc + size >= program.Length)
{
throw new ArgumentException("byte[] const block exceeds program length");
}
result = GetUVarint(program, pc + size);
if (result.length <= 0)
{
throw new ArgumentException(
string.Format("could not decode byte[] const[%d] block at pc=%d", i, pc + size)
);
}
size += result.length;
if (pc + size >= program.Length)
{
throw new ArgumentException("byte[] const block exceeds program length");
}
byte[] buff = new byte[result.value];
JavaHelper <byte> .SyatemArrayCopy(program, pc + size, buff, 0, result.value);
results.Add(buff);
size += result.value;
}
return(new ByteConstBlock(size, results));
}
public LogicsigSignature(
[JsonProperty("l")] byte[] logic,
[JsonProperty("arg")] List <byte[]> args = null,
[JsonProperty("sig")] byte[] sig = null,
[JsonProperty("msig")] MultisigSignature msig = null)
{
this.logic = JavaHelper <byte[]> .RequireNotNull(logic, "program must not be null");
this.args = args;
if (!Logic.CheckProgram(this.logic, this.args))
{
throw new Exception("program verified failed!");
}
if (sig != null)
{
this.sig = new Signature(sig);
}
this.msig = msig;
}
private byte[] GetAdressBytes(string encodedAddr)
{
byte[] checksumAddr = Base32.DecodeFromString(encodedAddr);
return(JavaHelper <byte> .ArrayCopyOf(checksumAddr, LEN_BYTES));
}