logos-storage/nim-nitro
1
0
Fork 0
mirror of https://github.com/logos-storage/nim-nitro.git synced 2026-01-02 13:43:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update to questionable 0.7.0

Browse Source
This commit is contained in:
Mark Spanbroek 2021-04-19 16:11:30 +02:00
parent 56f6fac21e
commit 50d59ce48a
7 changed files with 62 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
nitro.nimble
View File

@ -1,11 +1,11 @@
version = "0.3.0"
version = "0.4.0"
author = "Nim Nitro developers"
license = "MIT"
description = "Nitro state channels"
requires "nim >= 1.2.6 & < 2.0.0"
requires "nimcrypto >= 0.5.4 & < 0.6.0"
requires "questionable >= 0.6.3 & < 0.7.0"
requires "questionable >= 0.7.0 & < 0.8.0"
requires "upraises >= 0.1.0 & < 0.2.0"
requires "secp256k1"
requires "stint"

4
nitro/wallet/wallet.nim
View File

@ -159,7 +159,7 @@ func pay*(wallet: var Wallet,
?balances.move(wallet.destination, receiver, amount)
state.outcome.update(asset, balances)
wallet.updateChannel(SignedState(state: state))
success wallet.channels.?[channel].get
success !wallet.latestSignedState(channel)
func pay*(wallet: var Wallet,
channel: ChannelId,
@ -195,7 +195,7 @@ func acceptPayment*(wallet: var Wallet,
without updatedBalances =? payment.state.outcome.balances(asset):
return failure "payment misses balances for asset"
var expectedState: State = wallet.channels.?[channel].?state.get
var expectedState: State = !wallet.state(channel)
expectedState.outcome.update(asset, updatedBalances)
if payment.state != expectedState:
return failure "payment has unexpected changes in state"

6
tests/nitro/protocol/testChannel.nim
View File

@ -22,10 +22,10 @@ suite "channel definition":
chainId: 9001.u256,
nonce: 1,
participants: @[
EthAddress.parse("24b905Dcc8A11C0FE57C2592f3D25f0447402C10").get()
!EthAddress.parse("24b905Dcc8A11C0FE57C2592f3D25f0447402C10")
]
)
let expected = Destination.parse(
let expected = !Destination.parse(
"4f8cce57e9fe88edaab05234972eaf0c2d183e4f6b175aff293375fbe4d5d7cc"
).get()
)
check getChannelId(channel) == expected

20
tests/nitro/protocol/testOutcome.nim
View File

@ -90,31 +90,31 @@ suite "outcome":
let outcome = Outcome(@[
AssetOutcome(
kind: allocationType,
assetHolder: EthAddress.parse(
assetHolder: !EthAddress.parse(
"1E90B49563da16D2537CA1Ddd9b1285279103D93"
).get(),
),
allocation: Allocation(@[
(
destination: Destination.parse(
destination: !Destination.parse(
"f1918e8562236eb17adc8502332f4c9c82bc14e19bfc0aa10ab674ff75b3d2f3"
).get(),
),
amount: 0x05.u256
)
])
),
AssetOutcome(
kind: guaranteeType,
assetHolder: EthAddress.parse(
assetHolder: !EthAddress.parse(
"1E90B49563da16D2537CA1Ddd9b1285279103D93"
).get(),
),
guarantee: Guarantee(
targetChannelId: Destination.parse(
targetChannelId: !Destination.parse(
"cac1bb71f0a97c8ac94ca9546b43178a9ad254c7b757ac07433aa6df35cd8089"
).get(),
),
destinations: @[
Destination.parse(
!Destination.parse(
"f1918e8562236eb17adc8502332f4c9c82bc14e19bfc0aa10ab674ff75b3d2f3"
).get()
)
]
)
)

10
tests/nitro/protocol/testSignature.nim
View File

@ -40,7 +40,7 @@ suite "signature":
chainId: 0x1.u256,
nonce: 1,
participants: @[
EthAddress.parse("0x8a64E10FF40Bc9C90EA5750313dB5e036495c10E").get()
!EthAddress.parse("0x8a64E10FF40Bc9C90EA5750313dB5e036495c10E")
]
),
outcome: Outcome(@[]),
@ -50,12 +50,12 @@ suite "signature":
appDefinition: EthAddress.default,
challengeDuration: 5
)
let seckey = EthPrivateKey.parse(
let seckey = !EthPrivateKey.parse(
"41b0f5f91967dded8af487277874f95116094cc6004ac2b2169b5b6a87608f3e"
).get()
let expected = Signature.parse(
)
let expected = !Signature.parse(
"9b966cf0065586d59c8b9eb475ac763c96ad8316b81061238f32968a631f9e21" &
"251363c193c78c89b3eb2fec23f0ea5c3c72acff7d1f27430cfb84b9da9831fb" &
"1c"
).get()
)
check seckey.sign(state) == expected

2
tests/nitro/protocol/testState.nim
View File

@ -52,7 +52,7 @@ suite "state":
chainId: 0x1.u256,
nonce: 1,
participants: @[
EthAddress.parse("DBE821484648c73C1996Da25f2355342B9803eBD").get()
!EthAddress.parse("DBE821484648c73C1996Da25f2355342B9803eBD")
]
),
outcome: Outcome(@[]),

78
tests/nitro/testWallet.nim
View File

@ -23,32 +23,32 @@ suite "wallet: opening ledger channel":
setup:
wallet = Wallet.init(key)
channel = wallet.openLedgerChannel(hub, chainId, nonce, asset, amount).get
channel = !wallet.openLedgerChannel(hub, chainId, nonce, asset, amount)
test "sets correct channel definition":
let definition = wallet.state(channel).get.channel
let definition = (!wallet.state(channel)).channel
check definition.chainId == chainId
check definition.nonce == nonce
check definition.participants == @[wallet.address, hub]
test "uses consecutive nonces when none is provided":
channel = wallet.openLedgerChannel(hub, chainId, asset, amount).get
check wallet.state(channel).get.channel.nonce == nonce + 1
channel = wallet.openLedgerChannel(hub, chainId, asset, amount).get
check wallet.state(channel).get.channel.nonce == nonce + 2
channel = !wallet.openLedgerChannel(hub, chainId, asset, amount)
check (!wallet.state(channel)).channel.nonce == nonce + 1
channel = !wallet.openLedgerChannel(hub, chainId, asset, amount)
check (!wallet.state(channel)).channel.nonce == nonce + 2
test "provides correct outcome":
let outcome = wallet.state(channel).get.outcome
let outcome = (!wallet.state(channel)).outcome
check outcome == Outcome.init(asset, {wallet.destination: amount})
test "signs the state":
let state = wallet.state(channel).get
let signatures = wallet.signatures(channel).get
let state = !wallet.state(channel)
let signatures = !wallet.signatures(channel)
check signatures == @[key.sign(state)]
test "sets app definition and app data to zero":
check wallet.state(channel).get.appDefinition == EthAddress.zero
check wallet.state(channel).get.appData.len == 0
check (!wallet.state(channel)).appDefinition == EthAddress.zero
check (!wallet.state(channel)).appData.len == 0
test "does not allow opening a channel that already exists":
check wallet.openLedgerChannel(hub, chainId, nonce, asset, amount).isFailure
@ -65,13 +65,13 @@ suite "wallet: accepting incoming channel":
signed.state.channel.participants &= @[wallet.address]
test "returns the new channel id":
let channel = wallet.acceptChannel(signed).get
check wallet.state(channel).get == signed.state
let channel = !wallet.acceptChannel(signed)
check !wallet.state(channel) == signed.state
test "signs the channel state":
let channel = wallet.acceptChannel(signed).get
let channel = !wallet.acceptChannel(signed)
let expectedSignatures = @[key.sign(signed.state)]
check wallet.signatures(channel).get == expectedSignatures
check !wallet.signatures(channel) == expectedSignatures
test "fails when wallet address is not a participant":
let wrongParticipants = seq[EthAddress].example
@ -99,7 +99,7 @@ suite "wallet: making payments":
test "paying updates the channel state":
wallet = Wallet.init(key)
channel = wallet.openLedgerChannel(hub, chainId, nonce, asset, 100.u256).get
channel = !wallet.openLedgerChannel(hub, chainId, nonce, asset, 100.u256)
check wallet.pay(channel, asset, hub, 1.u256).isSuccess
check wallet.balance(channel, asset) == 99.u256
@ -111,14 +111,14 @@ suite "wallet: making payments":
test "paying updates signatures":
wallet = Wallet.init(key)
channel = wallet.openLedgerChannel(hub, chainId, nonce, asset, 100.u256).get
channel = !wallet.openLedgerChannel(hub, chainId, nonce, asset, 100.u256)
check wallet.pay(channel, asset, hub, 1.u256).isSuccess
let expectedSignature = key.sign(wallet.state(channel).get)
let expectedSignature = key.sign(!wallet.state(channel))
check wallet.signature(channel, wallet.address) == expectedSignature.some
test "pay returns the updated signed state":
wallet = Wallet.init(key)
channel = wallet.openLedgerChannel(hub, chainId, nonce, asset, 42.u256).get
channel = !wallet.openLedgerChannel(hub, chainId, nonce, asset, 42.u256)
let updated = wallet.pay(channel, asset, hub, 1.u256).option
check updated.?state == wallet.state(channel)
check updated.?signatures == wallet.signatures(channel)
@ -131,7 +131,7 @@ suite "wallet: making payments":
wallet = Wallet.init(key)
var state = State.example
state.channel.participants &= wallet.address
channel = wallet.acceptChannel(SignedState(state: state)).get
channel = !wallet.acceptChannel(SignedState(state: state))
check wallet.pay(channel, asset, hub, 1.u256).isFailure
test "payment fails when payer has no allocation":
@ -139,12 +139,12 @@ suite "wallet: making payments":
var state: State
state.channel = ChannelDefinition(participants: @[wallet.address])
state.outcome = Outcome.init(asset, @[])
channel = wallet.acceptChannel(SignedState(state: state)).get
channel = !wallet.acceptChannel(SignedState(state: state))
check wallet.pay(channel, asset, hub, 1.u256).isFailure
test "payment fails when payer has insufficient funds":
wallet = Wallet.init(key)
channel = wallet.openLedgerChannel(hub, chainId, nonce, asset, 1.u256).get
channel = !wallet.openLedgerChannel(hub, chainId, nonce, asset, 1.u256)
check wallet.pay(channel, asset, hub, 1.u256).isSuccess
check wallet.pay(channel, asset, hub, 1.u256).isFailure
@ -161,55 +161,55 @@ suite "wallet: accepting payments":
setup:
payer = Wallet.init(payerKey)
receiver = Wallet.init(receiverKey)
channel = payer.openLedgerChannel(
receiver.address, chainId, nonce, asset, 100.u256).get
let update = payer.latestSignedState(channel).get
channel = !payer.openLedgerChannel(
receiver.address, chainId, nonce, asset, 100.u256)
let update = !payer.latestSignedState(channel)
discard receiver.acceptChannel(update)
test "updates channel state":
let payment = payer.pay(channel, asset, receiver.address, 42.u256).get
let payment = !payer.pay(channel, asset, receiver.address, 42.u256)
check receiver.acceptPayment(channel, asset, payer.address, payment).isSuccess
check receiver.balance(channel, asset) == 42.u256
test "fails when receiver balance is decreased":
let payment1 = payer.pay(channel, asset, receiver.address, 10.u256).get
let payment2 = payer.pay(channel, asset, receiver.address, 10.u256).get
let payment1 = !payer.pay(channel, asset, receiver.address, 10.u256)
let payment2 = !payer.pay(channel, asset, receiver.address, 10.u256)
check receiver.acceptPayment(channel, asset, payer.address, payment1).isSuccess
check receiver.acceptPayment(channel, asset, payer.address, payment2).isSuccess
check receiver.acceptPayment(channel, asset, payer.address, payment1).isFailure
check receiver.balance(channel, asset) == 20
test "fails when the total supply of the asset changes":
var payment = payer.pay(channel, asset, receiver.address, 10.u256).get
var balances = payment.state.outcome.balances(asset).get
var payment = !payer.pay(channel, asset, receiver.address, 10.u256)
var balances = !payment.state.outcome.balances(asset)
balances[payer.destination] += 10.u256
payment.state.outcome.update(asset, balances)
check receiver.acceptPayment(channel, asset, payer.address, payment).isFailure
test "fails without a signature":
var payment = payer.pay(channel, asset, receiver.address, 10.u256).get
var payment = !payer.pay(channel, asset, receiver.address, 10.u256)
payment.signatures = @[]
check receiver.acceptPayment(channel, asset, payer.address, payment).isFailure
test "fails with an incorrect signature":
var payment = payer.pay(channel, asset, receiver.address, 10.u256).get
var payment = !payer.pay(channel, asset, receiver.address, 10.u256)
payment.signatures = @[Signature.example]
check receiver.acceptPayment(channel, asset, payer.address, payment).isFailure
test "fails when channel is unknown":
let newChannel = payer.openLedgerChannel(
receiver.address, chainId, nonce + 1, asset, 100.u256).get
let payment = payer.pay(newChannel, asset, receiver.address, 10.u256).get
let newChannel = !payer.openLedgerChannel(
receiver.address, chainId, nonce + 1, asset, 100.u256)
let payment = !payer.pay(newChannel, asset, receiver.address, 10.u256)
check receiver.acceptPayment(newChannel, asset, payer.address, payment).isFailure
test "fails when payment does not match channel":
let newChannel = payer.openLedgerChannel(
receiver.address, chainId, nonce + 1, asset, 100.u256).get
let payment = payer.pay(newChannel, asset, receiver.address, 10.u256).get
let newChannel = !payer.openLedgerChannel(
receiver.address, chainId, nonce + 1, asset, 100.u256)
let payment = !payer.pay(newChannel, asset, receiver.address, 10.u256)
check receiver.acceptPayment(channel, asset, payer.address, payment).isFailure
test "fails when state is updated in unrelated areas":
var payment = payer.pay(channel, asset, receiver.address, 10.u256).get
var payment = !payer.pay(channel, asset, receiver.address, 10.u256)
payment.state.appDefinition = EthAddress.example
payment.signatures = @[payerKey.sign(payment.state)]
check receiver.acceptPayment(channel, asset, payer.address, payment).isFailure