public void TestAddressBulk()
{
for (int i = 0; i < 1024; i++)
{
var pub = new cipher_PubKey();
var sec = new cipher_SecKey();
var b = new GoSlice();
var err = SKY_cipher_RandByte(32, b);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_GenerateDeterministicKeyPair(b, pub, sec);
Assert.AreEqual(err, SKY_OK);
var a = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(pub, a);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_Address_Verify(a, pub);
Assert.AreEqual(err, SKY_OK);
var s = new _GoString_();
err = SKY_cipher_Address_String(a, s);
Assert.AreEqual(err, SKY_OK);
var a2 = new cipher__Address();
err = SKY_cipher_DecodeBase58Address(s.p, a2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(a2.isEqual(a), 1);
}
}
public void TestCreateUnspents()
{
var a = new cipher__Address();
var p = new cipher_PubKey();
var s = new cipher_SecKey();
var err = SKY_cipher_GenerateKeyPair(p, s);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
var h = new cipher_SHA256();
var txn = new_Transaction__Handlep();
makeEmptyTransaction(txn);
err = SKY_coin_Transaction_PushOutput(txn, a, (ulong)11e6, 255);
Assert.AreEqual(err, SKY_OK);
var bh = new coin__BlockHeader();
bh.Time = 0;
bh.BkSeq = 1;
var uxouts = new coin_UxOutArray();
err = SKY_coin_CreateUnspents(bh, txn, uxouts);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(uxouts.count, 1);
}
public void TestAddressRoundtrip()
{
// Tests encode and decode
var p = new cipher_PubKey();
var s = new cipher_SecKey();
var err = SKY_cipher_GenerateKeyPair(p, s);
Assert.AreEqual(err, SKY_OK);
var a = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
var b = new GoSlice();
err = SKY_cipher_Address_Bytes(a, b);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_AddressFromBytes(b, a);
Assert.AreEqual(err, SKY_OK);
var a2 = new cipher__Address();
err = SKY_cipher_AddressFromBytes(b, a2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(a.isEqual(a2), 1);
var str = new _GoString_();
var str2 = new _GoString_();
err = SKY_cipher_Address_String(a, str);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_Address_String(a2, str2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(str.p == str2.p, true);
}
public void TestAddressFromBytes()
{
var s = new cipher_SecKey();
var p = new cipher_PubKey();
uint err = SKY_cipher_GenerateKeyPair(p, s);
Assert.AreEqual(err, SKY_OK);
var a = new cipher__Address();
var a2 = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
var b = new GoSlice();
var b2 = new GoSlice();
err = SKY_cipher_Address_Bytes(a, b);
err = SKY_cipher_Address_Bytes(a, b2);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_AddressFromBytes(b2, a2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(a2.isEqual(a), 1);
// Invalid number of bytes
long len_b = b.len;
b.len = b.len - 2;
err = SKY_cipher_AddressFromBytes(b, a2);
Assert.AreEqual(SKY_ErrAddressInvalidLength, err, "Failed SKY_cipher_AddressFromBytes 2");
b.len = len_b;
a.setVersion('2');
err = SKY_cipher_Address_Bytes(a, b);
Assert.AreEqual(err, SKY_OK, "SKY_cipher_Address_Bytes SKY_ErrAddressInvalidVersion");
err = SKY_cipher_AddressFromBytes(b, a);
Assert.AreEqual(SKY_ErrAddressInvalidVersion, err);
}
public void TestAddressVerify()
{
var p = new cipher_PubKey();
var s = new cipher_SecKey();
var err = SKY_cipher_GenerateKeyPair(p, s);
Assert.AreEqual(err, SKY_OK);
var a = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
// Valid pubkey+address
err = SKY_cipher_Address_Verify(a, p);
Assert.AreEqual(err, SKY_OK);
// Invalid pubkey
err = SKY_cipher_Address_Verify(a, new cipher_PubKey());
Assert.AreEqual(err, SKY_ErrAddressInvalidPubKey);
var p2 = new cipher_PubKey();
var s2 = new cipher_SecKey();
err = SKY_cipher_GenerateKeyPair(p2, s2);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_Address_Verify(a, p2);
Assert.AreEqual(err, SKY_ErrAddressInvalidPubKey);
// Bad version
a.setVersion('1');
err = SKY_cipher_Address_Verify(a, p);
Assert.AreEqual(err, SKY_ErrAddressInvalidVersion);
}
public void TestAddressUxOutsFlatten()
{
var empty = new coin_UxOutArray();
makeUxArray(empty, 0);
var up = new_AddressUxOuts__HandlePtr();
var err = SKY_coin_NewAddressUxOuts(empty, up);
Assert.AreEqual(err, SKY_OK);
var uxs = new coin_UxOutArray();
makeUxArray(uxs, 3);
var uxo = uxs.getAt(2);
uxo.Body.Address = uxs.getAt(1).Body.Address;
uxs.setAt(0, uxo);
var emptyAddr = new cipher__Address();
makeAddress(emptyAddr);
// An empty array
err = SKY_coin_AddressUxOuts_Set(up, emptyAddr, empty);
Assert.AreEqual(err, SKY_OK);
// 1 element array
var arg = new coin_UxOutArray();
arg.release();
arg.allocate(1);
arg.setAt(0, uxs.getAt(0));
err = SKY_coin_AddressUxOuts_Set(up, uxs.getAt(0).Body.Address, arg);
Assert.AreEqual(err, SKY_OK);
arg.release();
arg.allocate(2);
arg.setAt(0, uxs.getAt(1));
arg.setAt(1, uxs.getAt(2));
err = SKY_coin_AddressUxOuts_Set(up, uxs.getAt(1).Body.Address, arg);
Assert.AreEqual(err, SKY_OK);
var flat = new coin_UxOutArray();
err = SKY_coin_AddressUxOuts_Flatten(up, flat);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(flat.count, 2);
for (int i = 0; i < flat.count; i++)
{
var ux = flat.getAt(i);
Assert.AreNotEqual(ux.Body.Address.isEqual(emptyAddr), 1, "Is equal " + i.ToString());
}
if (flat.getAt(0).Body.Address.isEqual(uxs.getAt(0).Body.Address) == 1)
{
Assert.AreEqual(flat.getAt(0).isEqual(uxs.getAt(0)), 0);
Assert.AreEqual(flat.getAt(0).Body.Address.isEqual(uxs.getAt(0).Body.Address), 1);
Assert.AreEqual(flat.getAt(0 + 1).Body.Address.isEqual(uxs.getAt(0 + 1).Body.Address), 1);
Assert.AreEqual(flat.getAt(0 + 1).isEqual(uxs.getAt(1)), 0);
}
}
public cipher__Address makeAddress()
{
var pubkey = new cipher_PubKey();
var seckey = new cipher_SecKey();
var addr = new cipher__Address();
var result = skycoin.skycoin.SKY_cipher_GenerateKeyPair(pubkey, seckey);
Assert.AreEqual(result, skycoin.skycoin.SKY_OK);
result = skycoin.skycoin.SKY_cipher_AddressFromPubKey(pubkey, addr);
return(addr);
}
public void TestAddressNull()
{
var a = new cipher__Address();
Assert.AreEqual(a.isEqual(new cipher__Address()), 1);
var p = new cipher_PubKey();
var s = new cipher_SecKey();
var err = SKY_cipher_GenerateKeyPair(p, s);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(a.isEqual(new cipher__Address()), 0);
}
public void TestCreateUnspent()
{
var p = new cipher_PubKey();
var s = new cipher_SecKey();
var a = new cipher__Address();
var err = SKY_cipher_GenerateKeyPair(p, s);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
var h = new cipher_SHA256();
var handle = new_Transaction__Handlep();
makeEmptyTransaction(handle);
err = SKY_coin_Transaction_PushOutput(handle, a, 11000000, 255);
Assert.AreEqual(err, SKY_OK);
var bh = new coin__BlockHeader();
bh.Time = 0;
bh.BkSeq = 1;
testcase[] t = new testcase[2];
var tc = new testcase();
tc.index = 0;
tc.failure = SKY_OK;
t[0] = tc;
tc = new testcase();
tc.failure = SKY_ERROR;
tc.index = 10;
t[1] = tc;
var ux = new coin__UxOut();
var tests_count = t.Length;
for (int i = 0; i < tests_count; i++)
{
err = SKY_coin_CreateUnspent(bh, handle, t[i].index, ux);
if (t[i].failure == SKY_ERROR)
{
continue;
}
Assert.AreEqual(bh.Time, ux.Head.Time);
Assert.AreEqual(bh.BkSeq, ux.Head.BkSeq);
}
}
public void TestDecodeBase58Address()
{
uint err = 0;
var s = new cipher_SecKey();
var p = new cipher_PubKey();
Assert.AreEqual(SKY_cipher_GenerateKeyPair(p, s), SKY_OK, "Failed SKY_cipher_GenerateKeyPair");
err = SKY_cipher_SecKey_Verify(s);
Assert.AreEqual(err, SKY_OK, "Failed SKY_cipher_SecKey_Verify ");
err = SKY_cipher_PubKey_Verify(p);
Assert.AreEqual(err, SKY_OK, "Failed SKY_cipher_PubKey_Verify");
var a = new cipher__Address();
var a1 = new cipher__Address();
var a2 = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK, "Failed SKY_cipher_AddressFromPubKey");
Assert.AreEqual(err, SKY_OK, "Failed SKY_cipher_AddressFromPubKey");
err = SKY_cipher_Address_Verify(a, p);
Assert.AreEqual(err, SKY_OK, " Failed SKY_cipher_Address_Verify");
err = SKY_cipher_DecodeBase58Address("", a1);
Assert.AreEqual(err, SKY_ERROR, "Failed SKY_cipher_DecodeBase58Address 1");
err = SKY_cipher_DecodeBase58Address("asa", a1);
Assert.AreEqual(err, SKY_ErrAddressInvalidLength, "Failed SKY_cipher_DecodeBase58Address 2");
var addrStr = new _GoString_();
err = SKY_cipher_Address_String(a, addrStr);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_DecodeBase58Address(addrStr.p, a2);
Assert.AreEqual(err, SKY_OK, "Failed SKY_cipher_DecodeBase58Address");
Assert.IsTrue(a.isEqual(a2) == 1);
var as2 = " " + addrStr.p;
err = SKY_cipher_DecodeBase58Address(as2, a1);
Assert.AreEqual(err, SKY_ERROR, "Failed SKY_cipher_DecodeBase58Address 31");
as2 = "000" + addrStr.p;
err = SKY_cipher_DecodeBase58Address(as2, a1);
Assert.AreEqual(err, SKY_ERROR, "Failed SKY_cipher_DecodeBase58Address 3");
as2 = addrStr.p + "000";
err = SKY_cipher_DecodeBase58Address(as2, a1);
Assert.AreEqual(err, SKY_ERROR, "Failed SKY_cipher_DecodeBase58Address 30");
}
public void TestPubKeyToAddress()
{
var p = new cipher_PubKey();
var s = new cipher_SecKey();
var addr = new cipher__Address();
var addr1 = new cipher__Address();
var err = SKY_cipher_GenerateKeyPair(p, s);
err = SKY_cipher_AddressFromPubKey(p, addr);
err = SKY_cipher_Address_Verify(addr, p);
Assert.AreEqual(err, SKY_OK);
var addrStr = new _GoString_();
err = SKY_cipher_Address_String(addr, addrStr);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_DecodeBase58Address(addrStr.p, addr1);
Assert.AreEqual(err, SKY_OK);
}
public void makeUxBodyWithSecret(coin__UxBody uxBody, cipher_SecKey secKey)
{
var p = new cipher_PubKey();
skycoin.skycoin.SKY_cipher_GenerateKeyPair(p, secKey);
var b = new GoSlice();
skycoin.skycoin.SKY_cipher_RandByte(128, b);
var h = new cipher_SHA256();
skycoin.skycoin.SKY_cipher_SumSHA256(b, h);
uxBody.SetSrcTransaction(h);
var a = new cipher__Address();
skycoin.skycoin.SKY_cipher_AddressFromPubKey(p, a);
uxBody.Address = a;
uxBody.Coins = (ulong)(1e6);
uxBody.Hours = 100;
}
public void TestSignHash()
{
var p = new cipher_PubKey();
var s = new cipher_SecKey();
var a = new cipher__Address();
SKY_cipher_GenerateKeyPair(p, s);
var err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
var b_temp = new GoSlice();
SKY_cipher_RandByte(256, b_temp);
var h = new cipher_SHA256();
SKY_cipher_SumSHA256(b_temp, h);
var sig = new cipher_Sig();
SKY_cipher_SignHash(h, s, sig);
Assert.AreEqual(sig.isEqual(new cipher_Sig()), 0);
}
public void TestNewGenesisBlock()
{
var pubkey = new cipher_PubKey();
var seckey = new cipher_SecKey();
ulong genTime = 1000;
ulong genCoins = (ulong)1000e6;
var err = SKY_cipher_GenerateKeyPair(pubkey, seckey);
Assert.AreEqual(err, SKY_OK);
var addr = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(pubkey, addr);
Assert.AreEqual(err, SKY_OK);
var block = new_Block__HandlePtr();
err = SKY_coin_NewGenesisBlock(addr, genCoins, genTime, block);
Assert.AreEqual(err, SKY_OK);
var pBlockPP = new_coin__BlockPtr();
err = SKY_coin_GetBlockObject(block, pBlockPP);
var pBlock = coin__BlockPtr_value(pBlockPP);
Assert.AreEqual(err, SKY_OK);
var nullHash = new cipher_SHA256();
var Head = new GoSlice();
err = SKY_coin_BlockHeader_Bytes(pBlock.Head, Head);
Assert.AreEqual(err, SKY_OK);
var strnullHash = nullHash.getStr();
var strHead = new _GoString_();
Head.getString(strHead);
Assert.AreEqual(strnullHash.p, strHead.p);
Assert.AreEqual(genTime, pBlock.Head.Time);
Assert.AreEqual(0, pBlock.Head.BkSeq);
Assert.AreEqual(0, pBlock.Head.Version);
Assert.AreEqual(0, pBlock.Head.Fee);
}
public void TestVerifyTransactionFee()
{
FullburnFactor2verifyTxFeeTestCase();
var empty = transutils.makeEmptyTransaction();
var hours = new_GoUint64p();
var err = SKY_coin_Transaction_OutputHours(empty, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), 0);
// A txn with no outputs hours and no coinhours burn fee is valid
err = SKY_fee_VerifyTransactionFee(empty, 0, 2);
Assert.AreEqual(err, SKY_ErrTxnNoFee);
// A txn with no outputs hours but with a coinhours burn fee is valid
err = SKY_fee_VerifyTransactionFee(empty, 100, 2);
Assert.AreEqual(err, SKY_OK);
var txn = transutils.makeEmptyTransaction();
var addr = new cipher__Address();
addr = transutils.makeAddress();
Assert.AreEqual(err, 0);
err = SKY_coin_Transaction_PushOutput(txn, addr, 0, 1000000);
Assert.AreEqual(err, SKY_OK);
err = SKY_coin_Transaction_PushOutput(txn, addr, 0, 3000000);
Assert.AreEqual(err, SKY_OK);
err = SKY_coin_Transaction_OutputHours(txn, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), 4000000);
// A txn with insufficient net coinhours burn fee is invalid
err = SKY_fee_VerifyTransactionFee(txn, 0, 2);
Assert.AreEqual(err, SKY_ErrTxnNoFee);
err = SKY_fee_VerifyTransactionFee(txn, 1, 2);
Assert.AreEqual(err, SKY_ErrTxnInsufficientFee);
// A txn with sufficient net coinhours burn fee is valid
err = SKY_coin_Transaction_OutputHours(txn, hours);
Assert.AreEqual(err, SKY_OK);
err = SKY_fee_VerifyTransactionFee(txn, GoUint64p_value(hours), 2);
Assert.AreEqual(err, SKY_OK);
err = SKY_coin_Transaction_OutputHours(txn, hours);
Assert.AreEqual(err, SKY_OK);
err = SKY_fee_VerifyTransactionFee(txn, ((ulong)(GoUint64p_value(hours) * 10)), 2);
Assert.AreEqual(err, SKY_OK);
// fee + hours overflows
err = SKY_fee_VerifyTransactionFee(txn, ((ulong.MaxValue - 3000000)), 2);
Assert.AreEqual(err, SKY_ERROR);
// txn has overflowing output hours
err = SKY_coin_Transaction_PushOutput(txn, addr, 0,
(ulong.MaxValue - 1000000 - 3000000 + 1));
Assert.AreEqual(err, SKY_OK, "txn has overflowing output hours");
err = SKY_fee_VerifyTransactionFee(txn, 10, 2);
Assert.AreEqual(err, SKY_ERROR, "SKY_fee_VerifyTransactionFee failed");
int len = burnFactor2verifyTxFeeTestCase.Length;
for (int i = 0; i < len; i++)
{
txn = new_Transaction__Handlep();
txn = transutils.makeEmptyTransaction();
verifyTxFeeTestCase tc = burnFactor2verifyTxFeeTestCase[i];
err = SKY_coin_Transaction_PushOutput(txn, addr, 0, tc.ouputHours);
Assert.AreEqual(err, SKY_OK);
Assert.IsTrue(tc.inputHours >= tc.ouputHours);
err = SKY_fee_VerifyTransactionFee(txn, (ulong)(tc.inputHours - tc.ouputHours), 2);
Assert.AreEqual(tc.err, err, "Iter " + i.ToString() + " is " + tc.err.ToString() + " != " + err.ToString());;
}
}
public void TestTransactionSignInputs()
{
var handle = transutils.makeEmptyTransaction();
// Panics if txns already signed
var sig = new cipher_Sig();
var err = SKY_coin_Transaction_PushSignature(handle, sig);
Assert.AreEqual(err, SKY_OK);
var seckeys = new cipher_SecKeys();
seckeys.allocate(1);
seckeys.setAt(0, new cipher_SecKey());
// Panics if not enough keys
handle = transutils.makeEmptyTransaction();
var s = new cipher_SecKey();
var s2 = new cipher_SecKey();
var ux = new coin__UxOut();
var ux2 = new coin__UxOut();
makeUxOutWithSecret(ux, s);
var h = new cipher_SHA256();
err = SKY_coin_UxOut_Hash(ux, h);
Assert.AreEqual(err, SKY_OK);
var r = new uint();
r = SKY_coin_Transaction_PushInput(handle, h);
Assert.AreEqual(r, SKY_OK);
makeUxOutWithSecret(ux2, s2);
err = SKY_coin_UxOut_Hash(ux2, h);
Assert.AreEqual(err, SKY_OK);
r = SKY_coin_Transaction_PushInput(handle, h);
Assert.AreEqual(r, SKY_OK);
err = SKY_coin_Transaction_PushOutput(handle, transutils.makeAddress(), 40, 80);
Assert.AreEqual(err, SKY_OK);
var count = new_Gointp();
err = SKY_coin_Transaction_GetSignaturesCount(handle, count);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(Gointp_value(count), 0);
// Valid signing
h = new cipher_SHA256();
SKY_coin_Transaction_HashInner(handle, h);
seckeys = new cipher_SecKeys();
seckeys.allocate(2);
seckeys.setAt(0, s);
seckeys.setAt(1, s2);
err = SKY_coin_Transaction_SignInputs(handle, seckeys);
Assert.AreEqual(err, SKY_OK);
err = SKY_coin_Transaction_GetSignaturesCount(handle, count);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(Gointp_value(count), 2);
var h2 = new cipher_SHA256();
err = SKY_coin_Transaction_HashInner(handle, h2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(h.isEqual(h2), 1);
var p = new cipher_PubKey();
err = SKY_cipher_PubKeyFromSecKey(s, p);
Assert.AreEqual(err, SKY_OK);
var a = new cipher__Address();
var a2 = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_PubKeyFromSecKey(s2, p);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_AddressFromPubKey(p, a2);
Assert.AreEqual(err, SKY_OK);
var sha1 = new cipher_SHA256();
var sha2 = new cipher_SHA256();
var txin0 = new cipher_SHA256();
var txin1 = new cipher_SHA256();
err = SKY_coin_Transaction_GetInputAt(handle, 0, txin0);
Assert.AreEqual(err, SKY_OK);
err = SKY_coin_Transaction_GetInputAt(handle, 1, txin1);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_AddSHA256(h, txin0, sha1);
Assert.AreEqual(err, SKY_OK);
err = SKY_cipher_AddSHA256(h, txin1, sha2);
Assert.AreEqual(err, SKY_OK);
var txsig0 = new cipher_Sig();
var txsig1 = new cipher_Sig();
err = SKY_coin_Transaction_GetSignatureAt(handle, 0, txsig0);
Assert.AreEqual(err, SKY_OK);
err = SKY_coin_Transaction_GetSignatureAt(handle, 1, txsig1);
Assert.AreEqual(err, SKY_OK);
}
public void TestUxOutCoinHours()
{
var p = new cipher_PubKey();
var s = new cipher_SecKey();
SKY_cipher_GenerateKeyPair(p, s);
var uxb = new coin__UxBody();
var b = new GoSlice();
SKY_cipher_RandByte(128, b);
var h = new cipher_SHA256();
var err = SKY_cipher_SumSHA256(b, h);
Assert.AreEqual(err, SKY_OK);
uxb.SetSrcTransaction(h);
var a = new cipher__Address();
SKY_cipher_AddressFromPubKey(p, a);
uxb.Address = a;
uxb.Coins = (ulong)1e6;
uxb.Hours = 100;
var uxo = new coin__UxOut();
var uxh = new coin__UxHead();
uxh.Time = 100;
uxh.BkSeq = 2;
uxo.Head = uxh;
uxo.Body = uxb;
// Less than an hour passed
var now = uxh.Time + 100;
var hours = new_GoUint64p();
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(uxh.Time, GoUint64p_value(hours), "Less than an hour passed");
// 1 hours passed
now = uxh.Time + 3600;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxh.Time + (uxb.Coins / 1000000), "1 hours passed");
// 6 hours passed
now = uxh.Time + 3600 * 6;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxh.Time + (uxb.Coins / 1000000) * 6, "1 hours passed");
// Time is backwards (treated as no hours passed)
now = uxh.Time / 2;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxh.Time);
// 1 hour has passed, output has 1.5 coins, should gain 1 coinhour
uxb.Coins = 1500000;
now = uxh.Time + 3600;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxb.Hours + 1);
// 2 hours have passed, output has 1.5 coins, should gain 3 coin hours
uxb.Coins = 1500000;
uxo.Body = uxb;
now = uxh.Time + 3600 * 2;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
// 1 second has passed, output has 3600 coins, should gain 1 coin hour
uxb.Coins = 3600000000;
uxo.Body = uxb;
now = uxh.Time + 1;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxb.Hours + 1);
// 1000000 hours minus 1 second have passed, output has 1 droplet, should gain 0 coin hour
uxb.Coins = 1;
uxo.Body = uxb;
now = (ulong)(uxh.Time + (ulong)Convert.ToInt64(1e6 * 3600) - 1);
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxb.Hours);
// 1000000 hours have passed, output has 1 droplet, should gain 1 coin hour
uxb.Coins = 1;
uxo.Body = uxb;
now = uxh.Time + Convert.ToUInt64(10e5 * 3600);
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxb.Hours + 1);
// No hours passed, using initial coin hours
uxb.Coins = (ulong)10e8;
uxb.Hours = 1000 * 1000;
uxo.Body = uxb;
now = uxh.Time;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxb.Hours);
// One hour passed, using initial coin hours
now = uxh.Time + 3600;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), uxb.Hours + (10e8 / 10e5));
// No hours passed and no hours to begin with 0
uxb.Hours = 0;
uxo.Body = uxb;
now = uxh.Time;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(GoUint64p_value(hours), 0);
// Centuries have passed, time-based calculation overflows uint64 when calculating the whole coin seconds
uxb.Coins = (ulong)20e5;
uxo.Body = uxb;
now = 0xFFFFFFFFFFFFFFFF;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_ERROR);
// Centuries have passed, time-based calculation overflows uint64 when calculating the droplet seconds
uxb.Coins = (ulong)15e5;
uxo.Body = uxb;
now = 0xFFFFFFFFFFFFFFFF;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_ERROR);
// Output would overflow if given more hours, has reached its limit
uxb.Coins = (ulong)36e8;
uxo.Body = uxb;
now = 0xFFFFFFFFFFFFFFFF;
err = SKY_coin_UxOut_CoinHours(uxo, now, hours);
Assert.AreEqual(err, SKY_ERROR);
}
public void TestUxOutSnapshotHash()
{
var p = new cipher_PubKey();
var s = new cipher_SecKey();
var err = SKY_cipher_GenerateKeyPair(p, s);
Assert.AreEqual(err, SKY_OK);
var uxb = new coin__UxBody();
var b = new GoSlice();
err = SKY_cipher_RandByte(128, b);
Assert.AreEqual(err, SKY_OK);
var h = new cipher_SHA256();
err = SKY_cipher_SumSHA256(b, h);
Assert.AreEqual(err, SKY_OK);
uxb.SetSrcTransaction(h);
var a = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(p, a);
Assert.AreEqual(err, SKY_OK);
uxb.Address = a;
uxb.Coins = (ulong)1e6;
uxb.Hours = (ulong)100;
var uxo = new coin__UxOut();
var uxh = new coin__UxHead();
uxh.Time = 100;
uxh.BkSeq = 2;
uxo.Head = uxh;
uxo.Body = uxb;
var hn = new cipher_SHA256();
err = SKY_coin_UxOut_SnapshotHash(uxo, hn);
Assert.AreEqual(err, SKY_OK);
// snapshot hash should be dependent on every field in body and head
// Head Time
var uxo_2 = uxo;
uxh.Time = 20;
uxo_2.Head = uxh;
var hn_2 = new cipher_SHA256();
err = SKY_coin_UxOut_SnapshotHash(uxo_2, hn_2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(hn.isEqual(hn_2), 0);
// Head BkSeq
uxo_2 = uxo;
uxh.BkSeq = 4;
uxo_2.Head = uxh;
hn_2 = new cipher_SHA256();
err = SKY_coin_UxOut_SnapshotHash(uxo_2, hn_2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(hn.isEqual(hn_2), 0);
// Body SetSrcTransaction
uxo_2 = uxo;
uxb = new coin__UxBody();
err = SKY_cipher_RandByte(128, b);
Assert.AreEqual(err, SKY_OK);
h = new cipher_SHA256();
err = SKY_cipher_SumSHA256(b, h);
Assert.AreEqual(err, SKY_OK);
uxb.SetSrcTransaction(h);
uxo_2.Body = uxb;
hn_2 = new cipher_SHA256();
err = SKY_coin_UxOut_SnapshotHash(uxo_2, hn_2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(hn.isEqual(hn_2), 0);
// Body Address
var p_2 = new cipher_PubKey();
var s_2 = new cipher_SecKey();
err = SKY_cipher_GenerateKeyPair(p_2, s_2);
Assert.AreEqual(err, SKY_OK);
var a_2 = new cipher__Address();
err = SKY_cipher_AddressFromPubKey(p_2, a_2);
Assert.AreEqual(err, SKY_OK);
uxo_2 = uxo;
uxb = new coin__UxBody();
uxb.Address = a_2;
uxo_2.Body = uxb;
hn_2 = new cipher_SHA256();
err = SKY_coin_UxOut_SnapshotHash(uxo_2, hn_2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(hn.isEqual(hn_2), 0);
// Body Coins
uxo_2 = uxo;
uxb = new coin__UxBody();
uxb.Coins = 2;
uxo_2.Body = uxb;
hn_2 = new cipher_SHA256();
err = SKY_coin_UxOut_SnapshotHash(uxo_2, hn_2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(hn.isEqual(hn_2), 0);
// Body Hours
uxo_2 = uxo;
uxb = new coin__UxBody();
uxb.Hours = 2;
uxo_2.Body = uxb;
hn_2 = new cipher_SHA256();
err = SKY_coin_UxOut_SnapshotHash(uxo_2, hn_2);
Assert.AreEqual(err, SKY_OK);
Assert.AreEqual(hn.isEqual(hn_2), 0);
}
