Port latest changes from go-nitro till commit 64c4ee9 on November 15

DEVELOPMENT.md

@@ -0,0 +1,54 @@
+# Development
+
+## Skipped go-nitro Commits / Features
+
+* Usage of bearer auth tokens
+  * <https://github.com/statechannels/go-nitro/pull/1351> | <https://github.com/cerc-io/go-nitro/commit/903239959d2ffce936060932fca5476f50430668>
+* Kademlia-dht peer discovery
+  * <https://github.com/statechannels/go-nitro/pull/1462>
+  * Use libp2p notifications
+    * <https://github.com/statechannels/go-nitro/pull/1488/files>
+    * Skipping `libp2p.NATPortMap()`
+* Implement a basic reverse payment proxy
+  * <https://github.com/statechannels/go-nitro/pull/1483>
+
+## Known issues (ts-nitro)
+
+* Metamask caching issue after chain restart
+  * Error occurs during direct fund transfer in mobymask-ui when the Nitro Node makes an eth_call to the Nitro Adjudicator contract
+
+    ```bash
+    Received invalid block tag 1270. Latest block number is 99
+    ```
+
+  * <https://ethereum.stackexchange.com/questions/109625/received-invalid-block-tag-87-latest-block-number-is-0>
+
+  * To resolve this issue, attempt changing the network in Metamask and then switch back to the network you're using to connect to the local node
+
+## Known issues (go-nitro)
+
+* Error is thrown when trying to fund virtual channels with amounts more than their ledger channel supports
+
+    ```bash
+    panic: error updating ledger funding: error proposing ledger update: propose could not add new state vars: insufficient funds
+    goroutine 88 [running]:
+    github.com/statechannels/go-nitro/node/engine.(*Engine).checkError(0x748a4ac48e62a6aa?, {0x1e60900, 0xc00048c940})
+    go-nitro/node/engine/engine.go:867 +0x139
+    github.com/statechannels/go-nitro/node/engine.(*Engine).run(0xc000306500, {0x1e6f948, 0xc0006a09b0})
+    go-nitro/node/engine/engine.go:211 +0x852
+    created by github.com/statechannels/go-nitro/node/engine.New in goroutine 1
+    go-nitro/node/engine/engine.go:164 +0x54b
+    ```
+
+* Error is thrown when conducting direct defund while virtual channel is running
+
+    ```bash
+    panic: handleAPIEvent: Could not create directdefund objective for {ChannelId:0xecb0d8f2cdd9222b56dc24daa6b10fc2143f7b8861695071e260417d4ad289f6 objectiveStarted:0xc000743da0}: ledger channel has running guarantees
+    goroutine 200 [running]:
+    github.com/statechannels/go-nitro/node/engine.(*Engine).checkError(0x0?, {0x1e60900, 0xc000b8a240})
+    go-nitro/node/engine/engine.go:867 +0x139
+    github.com/statechannels/go-nitro/node/engine.(*Engine).run(0xc0009800a0, {0x1e6f948, 0xc000984000})
+    go-nitro/node/engine/engine.go:211 +0x852
+    created by github.com/statechannels/go-nitro/node/engine.New in goroutine 1
+    go-nitro/node/engine/engine.go:164 +0x54b
+    ```

README.md

@@ -182,3 +182,7 @@ Run relay node using v2 watcher
     ```bash
     clearNodeStorage()
     ```
+
+### Development
+
+* [README](./DEVELOPMENT.md)

packages/nitro-node/package.json

@@ -61,7 +61,7 @@
     "@libp2p/crypto": "^1.0.4",
     "@libp2p/tcp": "^6.0.0",
     "@multiformats/multiaddr": "^11.1.4",
-    "@statechannels/nitro-protocol": "^2.0.1-alpha.5",
+    "@statechannels/nitro-protocol": "^2.0.1-alpha.6",
     "assert": "^2.0.0",
     "async-mutex": "^0.4.0",
     "debug": "^4.3.4",

packages/nitro-node/src/channel/channel.ts

@@ -4,7 +4,7 @@ import { Buffer } from 'buffer';
 import { ethers } from 'ethers';
 
 import {
-  fromJSON, toJSON, FieldDescription, Uint, Uint64, NitroSigner,
+  fromJSON, toJSON, FieldDescription, Uint, Uint64, NitroSigner, WrappedError,
 } from '@cerc-io/nitro-util';
 import { Bytes32 } from '@statechannels/nitro-protocol';
 
@@ -124,7 +124,7 @@ export class Channel extends FixedPart {
     try {
       props = fromJSON(this.jsonEncodingMap, data);
     } catch (err) {
-      throw new Error(`error unmarshaling channel data: ${err}`);
+      throw new WrappedError('error unmarshaling channel data', err as Error);
     }
 
     return new Channel(props);
@@ -389,14 +389,14 @@ export class Channel extends FixedPart {
     try {
       sig = await s.sign(signer);
     } catch (err) {
-      throw new Error(`Could not sign prefund ${err}`);
+      throw new WrappedError('Could not sign prefund', err as Error);
     }
 
     const ss = SignedState.newSignedState(s);
     try {
       ss.addSignature(sig);
     } catch (err) {
-      throw new Error(`could not add own signature ${err}`);
+      throw new WrappedError('could not add own signature', err as Error);
     }
 
     const ok = this.addSignedState(ss);

packages/nitro-node/src/channel/consensus-channel/consensus-channel.ts

@@ -6,7 +6,7 @@ import { Buffer } from 'buffer';
 import { ethers } from 'ethers';
 
 import {
-  FieldDescription, NitroSigner, Uint, Uint64, fromJSON, toJSON,
+  FieldDescription, NitroSigner, Uint, Uint64, fromJSON, toJSON, WrappedError,
 } from '@cerc-io/nitro-util';
 import { Bytes32 } from '@statechannels/nitro-protocol';
 
@@ -979,7 +979,7 @@ export class ConsensusChannel {
         throw new Error(`Follower did not sign initial state: ${followerAddr}, ${fp.participants![Number(Follower)]}`);
       }
     } catch (err) {
-      throw new Error(`could not verify sig: ${err}`);
+      throw new WrappedError('could not verify sig', err as Error);
     }
 
     const current = new SignedVars({
@@ -1266,7 +1266,7 @@ export class ConsensusChannel {
         try {
           signer = consensusCandidate.asState(this.fp).recoverSigner(countersigned.signature);
         } catch (err) {
-          throw new Error(`unable to recover signer: ${err}`);
+          throw new WrappedError('unable to recover signer', err as Error);
         }
 
         if (signer !== this.fp.participants![Number(Follower)]) {
@@ -1303,28 +1303,28 @@ export class ConsensusChannel {
     try {
       vars = this.latestProposedVars();
     } catch (err) {
-      throw new Error(`unable to construct latest proposed vars: ${err}`);
+      throw new WrappedError('unable to construct latest proposed vars', err as Error);
     }
 
     try {
       vars.handleProposal(proposal);
     } catch (err) {
-      throw new Error(`propose could not add new state vars: ${err}`);
+      throw new WrappedError('propose could not add new state vars', err as Error);
     }
 
     let signature: Signature;
     try {
       signature = await this.sign(vars, signer);
     } catch (err) {
-      throw new Error(`unable to sign state update: ${err}`);
+      throw new Error('unable to sign state update');
     }
 
     const signed = new SignedProposal({ proposal, signature, turnNum: vars.turnNum });
 
     try {
       this.appendToProposalQueue(signed);
     } catch (err) {
-      throw new Error(`could not append to proposal queue: ${err}`);
+      throw new WrappedError('could not append to proposal queue', err as Error);
     }
 
     return signed;
@@ -1358,7 +1358,7 @@ export class ConsensusChannel {
       // Get the latest proposal vars we have
       vars = this.latestProposedVars();
     } catch (err) {
-      throw new Error(`could not generate the current proposal: ${err}`);
+      throw new WrappedError('could not generate the current proposal', err as Error);
     }
 
     if (p.turnNum !== vars.turnNum + BigInt(1)) {
@@ -1369,15 +1369,15 @@ export class ConsensusChannel {
     try {
       vars.handleProposal(p.proposal);
     } catch (err) {
-      throw new Error(`receive could not add new state vars: ${err}`);
+      throw new WrappedError('receive could not add new state vars', err as Error);
     }
 
     // Validate the signature
     let signer: Address;
     try {
       signer = this.recoverSigner(vars, p.signature);
     } catch (err) {
-      throw new Error(`receive could not recover signature: ${err}`);
+      throw new WrappedError('receive could not recover signature', err as Error);
     }
 
     if (signer !== this.leader()) {

packages/nitro-node/src/channel/state/signedstate.ts

@@ -2,7 +2,7 @@ import _ from 'lodash';
 import { Buffer } from 'buffer';
 
 import {
-  FieldDescription, Uint, Uint64, fromJSON, toJSON,
+  FieldDescription, Uint, Uint64, fromJSON, toJSON, WrappedError,
 } from '@cerc-io/nitro-util';
 
 import { Signature } from '../../crypto/signatures';
@@ -55,7 +55,7 @@ export class SignedState {
     try {
       signer = this.state().recoverSigner(sig);
     } catch (err) {
-      throw new Error('AddSignature failed to recover signer');
+      throw new WrappedError('AddSignature failed to recover signer', err as Error);
     }
 
     for (let i = 0; i < (this.state().participants ?? []).length; i += 1) {

packages/nitro-node/src/node/engine/chainservice/eth-chainservice.ts

@@ -352,7 +352,7 @@ export class EthChainService implements ChainService {
                   newBlockUnsubscribe = this.chain.subscribeNewHead(newBlockChan);
                 } catch (subErr) {
                   errorChan.push(new WrappedError(
-                    `subscribeNewHead failed to resubscribe: ${subErr}`,
+                    'subscribeNewHead failed to resubscribe',
                     subErr as Error,
                   ));
 
@@ -389,7 +389,7 @@ export class EthChainService implements ChainService {
                   // eslint-disable-next-line no-await-in-loop
                   await this.checkForMissedEvents(latestBlockNum);
                 } catch (checkErr) {
-                  errorChan.push(new Error(`subscribeFilterLogs failed during checkForMissedEvents: ${checkErr}`));
+                  errorChan.push(new WrappedError('subscribeFilterLogs failed during checkForMissedEvents', checkErr as Error));
                   return;
                 }
 
@@ -532,7 +532,7 @@ export class EthChainService implements ChainService {
             );
             await this.out.push(event);
           } catch (err) {
-            throw new Error(`error in ParseDeposited: ${err}`);
+            throw new WrappedError('error in ParseDeposited', err as Error);
           }
           break;
         }
@@ -542,7 +542,7 @@ export class EthChainService implements ChainService {
           try {
             au = this.na.interface.parseLog(l).args as unknown as AllocationUpdatedEventObject;
           } catch (err) {
-            throw new Error(`error in ParseAllocationUpdated: ${err}`);
+            throw new WrappedError('error in ParseAllocationUpdated', err as Error);
           }
 
           let tx;
@@ -553,7 +553,7 @@ export class EthChainService implements ChainService {
               throw new Error('Expected transaction to be part of the chain, but the transaction is pending');
             }
           } catch (err) {
-            throw new Error(`error in TransactionByHash: ${err}`);
+            throw new WrappedError('error in TransactionByHash', err as Error);
           }
 
           assert(tx !== undefined);
@@ -563,7 +563,7 @@ export class EthChainService implements ChainService {
             assetAddress = assetAddressForIndex(this.na, tx, au.assetIndex.toBigInt());
           } catch (err) {
             throw new WrappedError(
-              `error in assetAddressForIndex: ${err}`,
+              'error in assetAddressForIndex',
               err as Error,
             );
           }
@@ -590,7 +590,7 @@ export class EthChainService implements ChainService {
             const event = new ConcludedEvent({ _channelID: new Destination(ce.channelId), _blockNum: BigInt(l.blockNumber) });
             await this.out.push(event);
           } catch (err) {
-            throw new Error(`error in ParseConcluded: ${err}`);
+            throw new WrappedError('error in ParseConcluded', err as Error);
           }
           break;
         }
@@ -613,7 +613,7 @@ export class EthChainService implements ChainService {
 
             this.out.push(event);
           } catch (err) {
-            throw new Error(`error in ParseChallengeRegistered: ${err}`);
+            throw new WrappedError('error in ParseChallengeRegistered', err as Error);
           }
           break;
         }
@@ -772,7 +772,7 @@ export class EthChainService implements ChainService {
       await this.dispatchChainEvents(eventsToDispatch);
     } catch (err) {
       await errorChan.push(new WrappedError(
-        `failed dispatchChainEvents: ${err}`,
+        'failed dispatchChainEvents',
         err as Error,
       ));
     }
@@ -798,7 +798,7 @@ export class EthChainService implements ChainService {
     try {
       eventUnsubscribe = this.chain.subscribeFilterLogs(eventQuery, eventChan);
     } catch (err) {
-      throw new WrappedError(`subscribeFilterLogs failed: ${err}`, err as Error);
+      throw new WrappedError('subscribeFilterLogs failed', err as Error);
     }
     this.eventUnsubscribe = eventUnsubscribe.bind(this.chain);
 
@@ -810,7 +810,7 @@ export class EthChainService implements ChainService {
     try {
       newBlockUnsubscribe = this.chain.subscribeNewHead(newBlockChan);
     } catch (err) {
-      throw new WrappedError(`subscribeNewHead failed: ${err}`, err as Error);
+      throw new WrappedError('subscribeNewHead failed', err as Error);
     }
     this.newBlockUnsubscribe = newBlockUnsubscribe.bind(this.chain);