diff --git a/nitro.nimble b/nitro.nimble
index 854228d..1ebd15a 100644
--- a/nitro.nimble
+++ b/nitro.nimble
@@ -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"
diff --git a/nitro/wallet/wallet.nim b/nitro/wallet/wallet.nim
index 8d698ed..47ee2fb 100644
--- a/nitro/wallet/wallet.nim
+++ b/nitro/wallet/wallet.nim
@@ -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"
diff --git a/tests/nitro/protocol/testChannel.nim b/tests/nitro/protocol/testChannel.nim
index 46502f5..ae7a402 100644
--- a/tests/nitro/protocol/testChannel.nim
+++ b/tests/nitro/protocol/testChannel.nim
@@ -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
diff --git a/tests/nitro/protocol/testOutcome.nim b/tests/nitro/protocol/testOutcome.nim
index e1a065d..41e08d3 100644
--- a/tests/nitro/protocol/testOutcome.nim
+++ b/tests/nitro/protocol/testOutcome.nim
@@ -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()
+            )
           ]
         )
       )
diff --git a/tests/nitro/protocol/testSignature.nim b/tests/nitro/protocol/testSignature.nim
index 91d3a64..1686cd3 100644
--- a/tests/nitro/protocol/testSignature.nim
+++ b/tests/nitro/protocol/testSignature.nim
@@ -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
diff --git a/tests/nitro/protocol/testState.nim b/tests/nitro/protocol/testState.nim
index 25164a1..3832ce5 100644
--- a/tests/nitro/protocol/testState.nim
+++ b/tests/nitro/protocol/testState.nim
@@ -52,7 +52,7 @@ suite "state":
         chainId: 0x1.u256,
         nonce: 1,
         participants: @[
-          EthAddress.parse("DBE821484648c73C1996Da25f2355342B9803eBD").get()
+          !EthAddress.parse("DBE821484648c73C1996Da25f2355342B9803eBD")
         ]
       ),
       outcome: Outcome(@[]),
diff --git a/tests/nitro/testWallet.nim b/tests/nitro/testWallet.nim
index 2704d8d..c544cb5 100644
--- a/tests/nitro/testWallet.nim
+++ b/tests/nitro/testWallet.nim
@@ -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