logos-storage/nim-nitro
1
0
Fork 0
mirror of https://github.com/logos-storage/nim-nitro.git synced 2026-01-07 16:13:09 +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" author = "Nim Nitro developers"
license = "MIT" license = "MIT"
description = "Nitro state channels" description = "Nitro state channels"
requires "nim >= 1.2.6 & < 2.0.0" requires "nim >= 1.2.6 & < 2.0.0"
requires "nimcrypto >= 0.5.4 & < 0.6.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 "upraises >= 0.1.0 & < 0.2.0"
requires "secp256k1" requires "secp256k1"
requires "stint" requires "stint"

4
nitro/wallet/wallet.nim
View File

@ -159,7 +159,7 @@ func pay*(wallet: var Wallet,
?balances.move(wallet.destination, receiver, amount) ?balances.move(wallet.destination, receiver, amount)
state.outcome.update(asset, balances) state.outcome.update(asset, balances)
wallet.updateChannel(SignedState(state: state)) wallet.updateChannel(SignedState(state: state))
success wallet.channels.?[channel].get success !wallet.latestSignedState(channel)
func pay*(wallet: var Wallet, func pay*(wallet: var Wallet,
channel: ChannelId, channel: ChannelId,
@ -195,7 +195,7 @@ func acceptPayment*(wallet: var Wallet,
without updatedBalances =? payment.state.outcome.balances(asset): without updatedBalances =? payment.state.outcome.balances(asset):
return failure "payment misses balances for 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) expectedState.outcome.update(asset, updatedBalances)
if payment.state != expectedState: if payment.state != expectedState:
return failure "payment has unexpected changes in state" 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, chainId: 9001.u256,
nonce: 1, nonce: 1,
participants: @[ participants: @[
EthAddress.parse("24b905Dcc8A11C0FE57C2592f3D25f0447402C10").get() !EthAddress.parse("24b905Dcc8A11C0FE57C2592f3D25f0447402C10")
] ]
) )
let expected = Destination.parse( let expected = !Destination.parse(
"4f8cce57e9fe88edaab05234972eaf0c2d183e4f6b175aff293375fbe4d5d7cc" "4f8cce57e9fe88edaab05234972eaf0c2d183e4f6b175aff293375fbe4d5d7cc"
).get() )
check getChannelId(channel) == expected check getChannelId(channel) == expected

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

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

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

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

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

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

78
tests/nitro/testWallet.nim
View File

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