def test_TestAddressUxOutsFlatten():
uxa = utils.makeUxArray(3)
empty = utils.makeUxArray(0)
err, uxH = skycoin.SKY_coin_NewAddressUxOuts(empty)
assert err == skycoin.SKY_OK
uxa[2].Body.Address = uxa[1].Body.Address
emptyAddr = skycoin.cipher__Address()
err = skycoin.SKY_coin_AddressUxOuts_Set(uxH, emptyAddr, empty)
assert err == skycoin.SKY_OK
ux_1 = [uxa[0]]
err = skycoin.SKY_coin_AddressUxOuts_Set(uxH, uxa[0].Body.Address, ux_1)
assert err == skycoin.SKY_OK
ux_2 = uxa[1:]
err = skycoin.SKY_coin_AddressUxOuts_Set(uxH, uxa[1].Body.Address, ux_2)
assert err == skycoin.SKY_OK
err, flatArray = skycoin.SKY_coin_AddressUxOuts_Flatten(uxH)
assert err == skycoin.SKY_OK
assert len(flatArray) == 3
for x in flatArray:
assert x.Body.Address != emptyAddr
if flatArray[0].Body.Address == uxa[0].Body.Address:
assert flatArray[0] == uxa[0]
assert flatArray[0].Body.Address == uxa[0].Body.Address
assert flatArray[1] == uxa[1]
assert flatArray[1].Body.Address == uxa[1].Body.Address
assert flatArray[2] == uxa[2]
assert flatArray[2].Body.Address == uxa[2].Body.Address
else:
assert flatArray[0] == uxa[1]
assert flatArray[0].Body.Address == uxa[1].Body.Address
assert flatArray[1] == uxa[2]
assert flatArray[1].Body.Address == uxa[2].Body.Address
assert flatArray[2] == uxa[0]
assert flatArray[2].Body.Address == uxa[0].Body.Address
def test_TestNewAddressUxOuts():
uxa = utils.makeUxArray(6)
uxa[1].Body.Address = uxa[0].Body.Address
uxa[3].Body.Address = uxa[2].Body.Address
uxa[4].Body.Address = uxa[2].Body.Address
err, uxH = skycoin.SKY_coin_NewAddressUxOuts(uxa)
assert err == skycoin.SKY_OK
# length
err, length = skycoin.SKY_coin_AddressUxOuts_Length(uxH)
assert err == skycoin.SKY_OK
assert length == 3
err, ux_2 = skycoin.SKY_coin_AddressUxOuts_Get(uxH, uxa[0].Body.Address)
assert err == skycoin.SKY_OK
assert len(ux_2) == 2
assert ux_2[0] == uxa[0]
assert ux_2[1] == uxa[1]
err, ux_2 = skycoin.SKY_coin_AddressUxOuts_Get(uxH, uxa[3].Body.Address)
assert err == skycoin.SKY_OK
assert len(ux_2) == 3
assert ux_2[0] == uxa[2]
assert ux_2[1] == uxa[3]
assert ux_2[2] == uxa[4]
err, ux_2 = skycoin.SKY_coin_AddressUxOuts_Get(uxH, uxa[5].Body.Address)
assert err == skycoin.SKY_OK
assert len(ux_2) == 1
assert ux_2[0] == uxa[5]
def test_TestUxArrayLess():
uxa = utils.makeUxArray(2)
err, hasha = skycoin.SKY_coin_UxArray_Hashes(uxa)
assert err == skycoin.SKY_OK and len(hasha) == len(uxa)
err, _ = skycoin.SKY_coin_UxArray_Less(uxa, 0, 1)
assert err == skycoin.SKY_OK
err, _ = skycoin.SKY_coin_UxArray_Less(uxa, 1, 0)
assert err == skycoin.SKY_OK
def test_TestUxArrayHasDupes():
uxa = utils.makeUxArray(4)
err, hasDupes = skycoin.SKY_coin_UxArray_HasDupes(uxa)
assert err == skycoin.SKY_OK
assert hasDupes == 0
uxa[0] = uxa[1]
err, hasDupes = skycoin.SKY_coin_UxArray_HasDupes(uxa)
assert err == skycoin.SKY_OK
assert hasDupes == 1
def test_TestUxArrayCoins():
uxa = utils.makeUxArray(4)
for x in uxa:
x.Body.Coins = utils.Million
err, coins = skycoin.SKY_coin_UxArray_Coins(uxa)
assert coins == int(4e6)
assert err == skycoin.SKY_OK
uxa[2].Body.Coins = int(utils.MaxUint64 - int(1e6))
err, _ = skycoin.SKY_coin_UxArray_Coins(uxa)
assert err == skycoin.SKY_ERROR
def test_TestAddressUxOutsKeys():
uxa = utils.makeUxArray(3)
err, uxH = skycoin.SKY_coin_NewAddressUxOuts(uxa)
assert err == skycoin.SKY_OK
# keys = []
err, keys = skycoin.SKY_coin_AddressUxOuts_Keys(uxH)
assert err == skycoin.SKY_OK
assert len(keys) == 3
for k in keys:
assert k == uxa[0].Body.Address or k == uxa[
1].Body.Address or k == uxa[2].Body.Address
def test_TestUxArraySub():
uxa = utils.makeUxArray(4)
uxb = utils.makeUxArray(4)
uxc = uxa[:1]
for ux in uxb:
uxc.append(ux)
for ux in uxa[1:2]:
uxc.append(ux)
err, uxd = skycoin.SKY_coin_UxArray_Sub(uxc, uxa)
assert err == skycoin.SKY_OK
assert len(uxd) == len(uxb)
err, uxd = skycoin.SKY_coin_UxArray_Sub(uxc, uxb)
assert err == skycoin.SKY_OK
assert len(uxd) == 2
assert uxd == uxa[:2]
# No intersection
err, uxd = skycoin.SKY_coin_UxArray_Sub(uxa, uxb)
assert uxd == uxa
err, uxd = skycoin.SKY_coin_UxArray_Sub(uxb, uxa)
assert uxd == uxb
def test_TestUxArrayHashArray():
uxa = utils.makeUxArray(4)
sha = skycoin.cipher_SHA256()
err, hashs = skycoin.SKY_coin_UxArray_Hashes(uxa)
assert err == skycoin.SKY_OK
assert len(hashs) == len(uxa)
skycoin.SKY_coin_UxOut_Hash(uxa[0], sha)
print(sha)
print(uxa[0])
assert hashs[0] == sha
for i in range(len(hashs)):
assert skycoin.SKY_coin_UxOut_Hash(uxa[i], sha) == 0
assert sha == hashs[i]
def test_TestUxArraySwap():
uxa = utils.makeUxArray(2)
uxx = utils.make_UxOut()
uxy = utils.make_UxOut()
uxa[0] = uxx
uxa[1] = uxy
err = skycoin.SKY_coin_UxArray_Swap(uxa, 0, 1)
assert err == skycoin.SKY_OK
uxa[0] = uxy
uxa[1] = uxx
err = skycoin.SKY_coin_UxArray_Swap(uxa, 0, 1)
assert err == skycoin.SKY_OK
uxa[0] = uxx
uxa[1] = uxy
err = skycoin.SKY_coin_UxArray_Swap(uxa, 0, 1)
assert err == skycoin.SKY_OK
uxa[1] = uxx
uxa[0] = uxy
def test_TestTransactionFee():
addr = utils.makeAddress()
for j in range(len(cases)):
tc = cases[j]
tx = utils.makeEmptyTransaction()
for h in tc.out:
err = skycoin.SKY_coin_Transaction_PushOutput(tx, addr, 0, h)
assert err == skycoin.SKY_OK
inUxs = utils.makeUxArray(len(tc.ins))
for i in range(len(tc.ins)):
b = tc.ins[i]
inUxs[i].Head.Time = b.time
inUxs[i].Body.Coins = int(b.coins)
inUxs[i].Body.Hours = int(b.hours)
err, fee = skycoin.SKY_fee_TransactionFee(tx, int(tc.headTime), inUxs)
assert err == tc.err
assert tc.fee == fee
def test_TestUxArrayCoinHours():
uxa = utils.makeUxArray(4)
assert skycoin.SKY_coin_UxArray_CoinHours(uxa, 0)[1] == 400
# 1 hour later
assert skycoin.SKY_coin_UxArray_CoinHours(uxa, uxa[0].Head.Time +
3600)[1] == 404
# 1.5 hours later
assert skycoin.SKY_coin_UxArray_CoinHours(uxa, uxa[0].Head.Time + 3600 +
1800)[1] == 404
# 2 hour later
assert skycoin.SKY_coin_UxArray_CoinHours(uxa, uxa[0].Head.Time + 3600 +
4600)[1] == 408
uxa[2].Head.Time = utils.MaxUint64 - 100
# assert skycoin.SKY_coin_UxArray_CoinHours(uxa, utils.MaxUint64 - 100)[1] == skycoin.SKY_OK
value = skycoin.SKY_coin_UxArray_CoinHours(uxa, uxa[2].Head.Time)[1]
assert utils.err_CoinHours_Overflow(
value) == skycoin.SKY_ErrAddEarnedCoinHoursAdditionOverflow
value = skycoin.SKY_coin_UxArray_CoinHours(uxa, 1000000000000)[1]
assert utils.err_CoinHours_Overflow(
value) == skycoin.SKY_ErrAddEarnedCoinHoursAdditionOverflow
def test_TestAddressUxOutsAdd():
uxa = utils.makeUxArray(4)
empty = utils.makeUxArray(0)
err, uxH_1 = skycoin.SKY_coin_NewAddressUxOuts(empty)
assert err == skycoin.SKY_OK
err, uxH_2 = skycoin.SKY_coin_NewAddressUxOuts(empty)
assert err == skycoin.SKY_OK
uxa[1].Body.Address = uxa[0].Body.Address
ux_2 = [uxa[0]]
err = skycoin.SKY_coin_AddressUxOuts_Set(uxH_1, uxa[0].Body.Address, ux_2)
assert err == skycoin.SKY_OK
ux_3 = [uxa[2]]
err = skycoin.SKY_coin_AddressUxOuts_Set(uxH_1, uxa[2].Body.Address, ux_3)
assert err == skycoin.SKY_OK
ux_4 = [uxa[3]]
err = skycoin.SKY_coin_AddressUxOuts_Set(uxH_1, uxa[3].Body.Address, ux_4)
assert err == skycoin.SKY_OK
ux_5 = [uxa[0]]
err = skycoin.SKY_coin_AddressUxOuts_Set(uxH_2, uxa[0].Body.Address, ux_5)
assert err == skycoin.SKY_OK
ux_6 = [uxa[2]]
err = skycoin.SKY_coin_AddressUxOuts_Set(uxH_2, uxa[2].Body.Address, ux_6)
assert err == skycoin.SKY_OK
err, uxH_3 = skycoin.SKY_coin_AddressUxOuts_Add(uxH_1, uxH_2)
assert err == skycoin.SKY_OK
# length
err, length = skycoin.SKY_coin_AddressUxOuts_Length(uxH_3)
assert err == skycoin.SKY_OK
assert length == 3
err, length = skycoin.SKY_coin_AddressUxOuts_GetOutputLength(
uxH_3, uxa[0].Body.Address)
assert err == skycoin.SKY_OK
# assert length == 2
err, ux_2 = skycoin.SKY_coin_AddressUxOuts_Get(uxH_3, uxa[0].Body.Address)
assert err == skycoin.SKY_OK
# assert len(ux_2) == 2
assert ux_2[0] == uxa[0]
# assert ux_2[1] == uxa[1]
err, ux_2 = skycoin.SKY_coin_AddressUxOuts_Get(uxH_3, uxa[2].Body.Address)
assert err == skycoin.SKY_OK
assert len(ux_2) == 1
assert ux_2[0] == uxa[2]
err, ux_2 = skycoin.SKY_coin_AddressUxOuts_Get(uxH_3, uxa[3].Body.Address)
assert err == skycoin.SKY_OK
assert len(ux_2) == 1
assert ux_2[0] == uxa[3]
err, ux_2 = skycoin.SKY_coin_AddressUxOuts_Get(uxH_3, uxa[1].Body.Address)
assert err == skycoin.SKY_OK
# assert len(ux_2) == 2
assert ux_2[0] == uxa[0]
# assert ux_2[1] == uxa[1]
# Originals should be unmodified
err, length = skycoin.SKY_coin_AddressUxOuts_Length(uxH_1)
assert err == skycoin.SKY_OK
assert length == 3
err, length = skycoin.SKY_coin_AddressUxOuts_GetOutputLength(
uxH_1, uxa[0].Body.Address)
assert err == skycoin.SKY_OK
assert length == 1
err, length = skycoin.SKY_coin_AddressUxOuts_GetOutputLength(
uxH_1, uxa[2].Body.Address)
assert err == skycoin.SKY_OK
assert length == 1
err, length = skycoin.SKY_coin_AddressUxOuts_GetOutputLength(
uxH_1, uxa[3].Body.Address)
assert err == skycoin.SKY_OK
assert length == 1
err, length = skycoin.SKY_coin_AddressUxOuts_Length(uxH_2)
assert err == skycoin.SKY_OK
assert length == 2
err, length = skycoin.SKY_coin_AddressUxOuts_GetOutputLength(
uxH_2, uxa[0].Body.Address)
assert err == skycoin.SKY_OK
assert length == 1
err, length = skycoin.SKY_coin_AddressUxOuts_GetOutputLength(
uxH_2, uxa[2].Body.Address)
assert err == skycoin.SKY_OK
assert length == 1
def test_TestUxArrayLen():
uxa = utils.makeUxArray(4)
assert len(uxa) == 4
def test_TestTransactionFee():
headTime = int(1000)
nextTime = int(headTime + 3600) # 1 hour later
cases = []
# Test case with one output, one input
case1 = tmpstruct()
case1.fee = 5
case1.headTime = 1000
case1.out = [5]
case1.ins.append(uxInput(headTime, 10e6, 10))
cases.append(case1)
# Test case with multiple outputs, multiple inputs
case2 = tmpstruct()
case2.fee = 0
case2.headTime = 1000
case2.out = [5, 7, 3]
case2.ins.append(uxInput(headTime, int(10e6), 10))
case2.ins.append(uxInput(headTime, int(10e6), 5))
cases.append(case2)
# # Test case with multiple outputs, multiple inputs, and some inputs have more CoinHours once adjusted for HeadTime
case3 = tmpstruct()
case3.fee = 8
case3.headTime = 1000
case3.out.append(5)
case3.out.append(10)
case3.ins.append(uxInput(nextTime, 10e6, 10))
case3.ins.append(uxInput(nextTime, 8e6, 5))
# Test case with insufficient coin hours
case4 = tmpstruct()
case4.err = skycoin.SKY_ErrTxnInsufficientCoinHours
case4.out.append(5)
case4.out.append(10)
case4.out.append(1)
case4.ins.append(uxInput(headTime, 10e6, 10))
case4.ins.append(uxInput(headTime, 8e6, 5))
# Test case with overflowing input hours
case5 = tmpstruct()
case5.err = skycoin.SKY_ERROR
case5.out.append(0)
case5.ins.append(uxInput(headTime, 10e6, 10))
case5.ins.append(uxInput(headTime, 10e6, utils.MaxUint64 - 9))
case5.headTime = 1000
# Test case with overflowing output hours
case6 = tmpstruct()
case6.err = skycoin.SKY_ERROR
case6.out.append(0)
case6.out.append(10)
case6.out.append(utils.MaxUint64 - 9)
case6.ins.append(uxInput(headTime, 10e6, 10))
case6.ins.append(uxInput(headTime, 10e6, 100))
case6.headTime = 1000
addr = utils.makeAddress()
for j in range(len(cases)):
tc = cases[j]
tx = utils.makeEmptyTransaction()
for h in tc.out:
err = skycoin.SKY_coin_Transaction_PushOutput(tx, addr, 0, h)
assert err == skycoin.SKY_OK
inUxs = utils.makeUxArray(len(tc.ins))
for i in range(len(tc.ins)):
b = tc.ins[i]
inUxs[i].Head.Time = b.time
inUxs[i].Body.Coins = int(b.coins)
inUxs[i].Body.Hours = int(b.hours)
err, fee = skycoin.SKY_fee_TransactionFee(tx, int(tc.headTime), inUxs)
assert err == tc.err
assert tc.fee == fee
