chore: testing ledger entry query

.github/actions/install-vega-binaries/action.yml

@@ -0,0 +1,31 @@
+inputs:
+  all:
+    description: 'Install all binaries'
+    default: false
+  version:
+    description: 'Vega version'
+  gobin:
+    description: 'GOBIN path'
+    default: '/home/runner/go/bin'
+runs:
+  using: 'composite'
+  steps:
+    - name: Install Vega binaries
+      if: ${{ inputs.all }}
+      shell: bash
+      run: |
+        wget 'https://github.com/vegaprotocol/vega/releases/download/${{ env.VEGA_VERSION }}/vega-linux-amd64.zip' -q
+        unzip vega-linux-amd64.zip -d ${{ inputs.gobin }}
+
+    - name: Install date-node binaries
+      if: ${{ inputs.all  }}
+      shell: bash
+      run: |
+        wget 'https://github.com/vegaprotocol/vega/releases/download/${{ env.VEGA_VERSION }}/data-node-linux-amd64.zip' -q
+        unzip data-node-linux-amd64.zip -d ${{ inputs.gobin }}
+
+    - name: Install Vega wallet binaries
+      shell: bash
+      run: |
+        wget 'https://github.com/vegaprotocol/vega/releases/download/${{ env.VEGA_VERSION }}/vegawallet-linux-amd64.zip' -q
+        unzip vegawallet-linux-amd64.zip -d ${{ inputs.gobin }}

.github/actions/run-vegacapsule/action.yml

@@ -1,6 +1,26 @@
+inputs:
+  github-token:
+    description: 'github token'
 runs:
   using: 'composite'
   steps:
+    - name: Checkout capsule
+      uses: actions/checkout@v2
+      with:
+        repository: vegaprotocol/vegacapsule
+        ref: main
+        token: ${{ inputs.github-token }}
+        path: './capsule'
+
+    - name: Build capsule
+      run: go install
+      shell: bash
+      working-directory: capsule
+
+    - name: Login to docker
+      shell: bash
+      run: echo -n ${{ inputs.github-token }} | docker login https://ghcr.io -u vega-ci-bot --password-stdin
+
     - name: Start nomad
       shell: bash
       run: vegacapsule nomad &

.github/actions/setup-vegawallet-docker/action.yml

@@ -1,38 +0,0 @@
-inputs:
-  passphrase:
-    description: 'Wallet password'
-outputs:
-  token:
-    description: 'api-token of wallet'
-    value: ${{ steps.generate-api-token.outputs.api-token }}
-runs:
-  using: 'composite'
-  steps:
-    - name: Initialize wallet
-      shell: bash
-      run: vega wallet init -f --home ~/.vegacapsule/testnet/wallet
-
-    - name: Import wallet
-      shell: bash
-      run: vega wallet import -w capsule_wallet --recovery-phrase-file ./frontend-monorepo/vegacapsule/recovery -p ./frontend-monorepo/vegacapsule/passphrase --home ~/.vegacapsule/testnet/wallet
-
-    - name: Generate second public key
-      shell: bash
-      run: vega wallet key generate -w capsule_wallet -p ./frontend-monorepo/vegacapsule/passphrase --home ~/.vegacapsule/testnet/wallet
-
-    - name: Import network
-      shell: bash
-      run: vega wallet network import --force --from-file ./frontend-monorepo/vegacapsule/wallet-config.toml --home ~/.vegacapsule/testnet/wallet
-
-    - name: Init api-token
-      shell: bash
-      run: vega wallet api-token init --home ~/.vegacapsule/testnet/wallet --passphrase-file ./frontend-monorepo/vegacapsule/passphrase
-
-    - name: Generate api-token
-      id: generate-api-token
-      shell: bash
-      run: echo api-token=$(vega wallet api-token generate --wallet-name capsule_wallet --tokens-passphrase-file ./frontend-monorepo/vegacapsule/passphrase  --wallet-passphrase-file ./frontend-monorepo/vegacapsule/passphrase --home ~/.vegacapsule/testnet/wallet | grep -Eo '[a-zA-Z0-9]{64}') >> $GITHUB_OUTPUT
-
-    - name: Start service using capsule network
-      shell: bash
-      run: vega wallet service run -n DV --load-tokens --tokens-passphrase-file ./frontend-monorepo/vegacapsule/passphrase --no-version-check --automatic-consent --home ~/.vegacapsule/testnet/wallet &

.github/actions/setup-vegawallet/action.yml

@@ -3,10 +3,9 @@ inputs:
     description: 'Recovery phrase'
   passphrase:
     description: 'Wallet password'
-outputs:
-  token:
-    description: 'api-token of wallet'
-    value: ${{ steps.generate-api-token.outputs.api-token }}
+  capsule:
+    description: 'Is Capsule network used'
+    default: false
 runs:
   using: 'composite'
   steps:
@@ -20,29 +19,27 @@ runs:
 
     - name: Initialize wallet
       shell: bash
-      run: vega wallet init -f --home ~/.vegacapsule/testnet/wallet
+      run: vegawallet init -f --home ~/.vegacapsule/testnet/wallet
 
     - name: Import wallet
       shell: bash
-      run: vega wallet import -w UI_Trading_Test --recovery-phrase-file ./recovery -p ./passphrase --home ~/.vegacapsule/testnet/wallet
+      run: vegawallet import -w UI_Trading_Test --recovery-phrase-file ./recovery -p ./passphrase --home ~/.vegacapsule/testnet/wallet
 
     - name: Create public key 2
       shell: bash
-      run: vega wallet key generate -w UI_Trading_Test -p ./passphrase --home ~/.vegacapsule/testnet/wallet
+      run: vegawallet key generate -w UI_Trading_Test -p ./passphrase --home ~/.vegacapsule/testnet/wallet
 
-    - name: Import network
+    - name: Import fairground network
       shell: bash
-      run: vega wallet network import --from-url="https://raw.githubusercontent.com/vegaprotocol/networks-internal/main/stagnet3/vegawallet-stagnet3.toml" --force --home ~/.vegacapsule/testnet/wallet
+      if: ${{ inputs.capsule==false }}
+      run: vegawallet network import --from-url="https://raw.githubusercontent.com/vegaprotocol/networks-internal/master/stagnet3/stagnet3.toml" --force --home ~/.vegacapsule/testnet/wallet
 
-    - name: Init api-token
+    - name: Start service using fairground network
       shell: bash
-      run: vega wallet api-token init --home ~/.vegacapsule/testnet/wallet --passphrase-file passphrase
+      if: ${{ inputs.capsule==false }}
+      run: vegawallet service run --network stagnet3 --automatic-consent --no-version-check --home ~/.vegacapsule/testnet/wallet &
 
-    - name: Generate api-token
-      id: generate-api-token
+    - name: Start service using capsule network
       shell: bash
-      run: echo api-token=$(vega wallet api-token generate --wallet-name UI_Trading_Test --tokens-passphrase-file passphrase  --wallet-passphrase-file passphrase --home ~/.vegacapsule/testnet/wallet | grep -Eo '[a-zA-Z0-9]{64}') >> $GITHUB_OUTPUT
-
-    - name: Start service using stagnet3 network
-      shell: bash
-      run: vega wallet service run -n stagnet3 --load-tokens --tokens-passphrase-file passphrase --no-version-check --automatic-consent --home ~/.vegacapsule/testnet/wallet &
+      if: ${{ inputs.capsule==true }}
+      run: vegawallet service run --network DV --automatic-consent  --home ~/.vegacapsule/testnet/wallet &

.github/workflows/add_issue_new_projects.yml

@@ -1,27 +1,25 @@
 ---
-name: 'Add Issues To Project Board'
+name: Auto Assign Issue to New Project
 
 'on':
   issues:
-    types:
-      - opened
-env:
-  GH_TOKEN: ${{ secrets.GH_NEW_CARD_TO_PROJECT }}
-  PROJECT_ID: ${{ secrets.FRONT_END_PROJECT_ID }}
-  ISSUE_ID: ${{ github.event.issue.node_id }}
-  USER: ${{ github.actor }}
+    types: [opened]
 
 jobs:
   add_issue:
     runs-on: ubuntu-latest
     steps:
-      - name: 'Add issue to project board'
+      - name: Add Issue to New Front End Project Board
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_NEW_CARD_TO_PROJECT }}
+          PROJECT_ID: ${{ secrets.FRONT_END_PROJECT_ID }}
+          ISSUE_ID: ${{ github.event.issue.node_id }}
         run: |
           gh api graphql -f query='
-            mutation($user:String!, $project:ID!, $issue:ID!) {
-              addProjectV2ItemById(input: {clientMutationId: $user, projectId: $project, contentId: $issue}) {
-                item {
+            mutation($project:ID!, $issue:ID!) {
+              addProjectNextItem(input: {projectId: $project, contentId: $issue}) {
+                projectNextItem {
                   id
                 }
               }
-            }' -f project=$PROJECT_ID -f issue=$ISSUE_ID -f user=$USER
+            }' -f project=$PROJECT_ID -f issue=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id'

.github/workflows/capsule-cypress-manual-trigger.yml

@@ -10,43 +10,150 @@ on:
         required: true
         type: choice
         options:
-          - console-lite-e2e
           - explorer-e2e
-          - liquidity-provision-dashboard-e2e
+          - console-lite-e2e
           - stats-e2e
           - token-e2e
           - trading-e2e
-      tags:
-        description: 'Test tags to run'
+      smokeOnly:
+        description: 'Run only smoke tests?'
         required: true
-        type: string
-        default: '@smoke, @regression, @slow'
+        type: boolean
+        default: false
       skip-nx-cache:
         description: 'Add --skip-nx-cache to cypress test'
         required: false
         type: boolean
         default: false
+
 jobs:
   manual:
     name: Run Cypress tests -- manual trigger
-    runs-on: ubuntu-latest
+    runs-on: self-hosted
+    env:
+      GO111MODULE: 'on'
+      GOBIN: /home/runner/go/bin
+      VEGA_VERSION: 'v0.58.0'
     steps:
-      - name: Set tags
-        run: echo TAGS="--env.grepTags '[ ${{ github.event.inputs.tags }} ]'" >> $GITHUB_ENV
+      #######
+      ## Setup flags
+      #######
+
+      - name: Set smoke tag
+        if: ${{ github.event.inputs.smokeOnly == 'true' }}
+        run: echo TAGS="--env.grepTags @smoke" >> $GITHUB_ENV
 
       - name: Set --skip-nx-cache flag
         if: ${{ github.event.inputs.skip-nx-cache == 'true' }}
         run: echo SKIP_NX_CACHE="--skip-nx-cache" >> $GITHUB_ENV
 
-    outputs:
-      skip-cache: ${{env.SKIP_NX_CACHE}}
-      tags: ${{env.TAGS}}
+      # See if we capsule is needed for this project
+      - name: Set capsule flag
+        if: ${{  github.event.inputs.project == 'explorer-e2e' || github.event.inputs.project == 'token-e2e'}}
+        run: echo RUN_CAPSULE=true >> $GITHUB_ENV
 
-  dispatch:
-    needs: manual
-    uses: ./.github/workflows/tests-dispatcher.yml
-    secrets: inherit
-    with:
-      project: ${{ inputs.project }}
-      skip-cache: ${{needs.manual.outputs.skip-cache}}
-      tags: ${{needs.manual.outputs.tags}}
+      #######
+      ## Setup langs
+      #######
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        id: go
+        with:
+          go-version: 1.19
+
+      - name: Set up Node 16
+        uses: actions/setup-node@v2
+        id: npm
+        with:
+          node-version: 16
+
+      #######
+      ## Install Yarn
+      #######
+      - name: Setup yarn
+        run: npm install -g yarn
+
+      #######
+      ## Checkout repos
+      #######
+
+      # Checkout front ends
+      - name: Checkout frontend mono repo
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+          path: './frontend-monorepo'
+
+      # Restore node_modules from cache if possible
+      - name: Restore node_modules from cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            frontend-monorepo/node_modules
+            /home/runner/.cache/Cypress
+          key: node_modules_cypress-${{ hashFiles('frontend-monorepo/yarn.lock') }}
+
+      # Install frontend dependencies
+      - name: Install root dependencies
+        run: yarn install --frozen-lockfile
+        working-directory: frontend-monorepo
+
+      #######
+      ## Build and run Vegacapsule network
+      #######
+
+      - name: Install Vega binaries
+        uses: ./frontend-monorepo/.github/actions/install-vega-binaries
+        with:
+          all: ${{ env.RUN_CAPSULE }}
+          version: ${{ env.VEGA_VERSION }}
+          gobin: ${{ env.GOBIN }}
+
+      - name: Build and run Vegacapsule network
+        if: ${{ env.RUN_CAPSULE }}
+        uses: ./frontend-monorepo/.github/actions/run-vegacapsule
+        with:
+          github-token: ${{ secrets.VEGA_CI_BOT_GITHUB_TOKEN }}
+
+      ######
+      ## Setup a Vega wallet for our user
+      ######
+
+      - name: Set up Vegawallet
+        uses: ./frontend-monorepo/.github/actions/setup-vegawallet
+        with:
+          recovery: ${{ secrets.TRADING_TEST_VEGA_WALLET_RECOVERY }}
+          passphrase: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
+          capsule: ${{ env.RUN_CAPSULE }}
+
+      ######
+      ## Run some tests
+      ######
+
+      # To make sure that all Cypress binaries are installed properly
+      - name: Install cypress bins
+        run: yarn cypress install
+        working-directory: frontend-monorepo
+
+      - name: Run Cypress tests
+        run: yarn nx run ${{ github.event.inputs.project }}:e2e ${{ env.SKIP_NX_CACHE }} --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --browser chrome ${{ env.TAGS }}
+        working-directory: frontend-monorepo
+        env:
+          CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
+          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}
+          CYPRESS_ETH_WALLET_MNEMONIC: ${{ secrets.CYPRESS_ETH_WALLET_MNEMONIC }}
+          CYPRESS_TEARDOWN_NETWORK_AFTER_FLOWS: false
+
+      ######
+      ## Upload logs
+      ######
+
+      - name: Logs
+        if: ${{ env.RUN_CAPSULE }}
+        run: vegacapsule network logs > vega-capsule-logs.txt
+
+      - uses: actions/upload-artifact@v2
+        if: ${{ env.RUN_CAPSULE }}
+        with:
+          name: logs
+          path: ./vega-capsule-logs.txt

.github/workflows/capsule-cypress-night-run.yml

@@ -9,9 +9,115 @@ on:
 
 jobs:
   nightly:
-    uses: ./.github/workflows/tests-dispatcher.yml
-    secrets: inherit
-    with:
-      project: '[console-lite-e2e, explorer-e2e, liquidity-provision-dashboard-e2e, stats-e2e, token-e2e, trading-e2e]'
-      tags: --env.grepTags '[ @smoke, @regression, @slow ]'
-      night-run: true
+    name: Run Cypress tests -- nightly
+    runs-on: self-hosted
+    timeout-minutes: 60
+    env:
+      GO111MODULE: 'on'
+      GOBIN: /home/runner/go/bin
+      VEGA_VERSION: 'v0.58.0'
+      RUN_CAPSULE: true
+    steps:
+      #######
+      ## Setup langs
+      #######
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        id: go
+        with:
+          go-version: 1.19
+      - name: Set up Node 16
+        uses: actions/setup-node@v2
+        id: npm
+        with:
+          node-version: 16
+
+      #######
+      ## Install Yarn
+      #######
+      - name: Setup yarn
+        run: npm install -g yarn
+
+      #######
+      ## Checkout repos
+      #######
+
+      # Checkout front ends
+      - name: Checkout frontend mono repo
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+          path: './frontend-monorepo'
+
+      # Restore node_modules from cache if possible
+      - name: Restore node_modules from cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            frontend-monorepo/node_modules
+            /home/runner/.cache/Cypress
+          key: node_modules_cypress-${{ hashFiles('frontend-monorepo/yarn.lock') }}
+
+      # Install frontend dependencies
+      - name: Install root dependencies
+        run: yarn install --frozen-lockfile
+        working-directory: frontend-monorepo
+
+      #######
+      ## Build and run Vegacapsule network
+      #######
+
+      - name: Install Vega binaries
+        uses: ./frontend-monorepo/.github/actions/install-vega-binaries
+        with:
+          all: ${{ env.RUN_CAPSULE }}
+          version: ${{ env.VEGA_VERSION }}
+          gobin: ${{ env.GOBIN }}
+
+      - name: Build and run Vegacapsule network
+        if: ${{ env.RUN_CAPSULE }}
+        uses: ./frontend-monorepo/.github/actions/run-vegacapsule
+        with:
+          github-token: ${{ secrets.VEGA_CI_BOT_GITHUB_TOKEN }}
+
+      ######
+      ## Setup a Vega wallet for our user
+      ######
+
+      - name: Set up Vegawallet
+        uses: ./frontend-monorepo/.github/actions/setup-vegawallet
+        with:
+          recovery: ${{ secrets.TRADING_TEST_VEGA_WALLET_RECOVERY }}
+          passphrase: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
+          capsule: ${{ env.RUN_CAPSULE }}
+
+      ######
+      ## Run some tests
+      ######
+
+      # To make sure that all Cypress binaries are installed properly
+      - name: Install cypress bins
+        run: yarn cypress install
+        working-directory: frontend-monorepo
+
+      - name: Run Cypress tests
+        run: yarn nx run-many --skip-nx-cache --target=e2e --all --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --browser chrome --parallel=1
+        working-directory: frontend-monorepo
+        env:
+          CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
+          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}
+          CYPRESS_ETH_WALLET_MNEMONIC: ${{ secrets.CYPRESS_ETH_WALLET_MNEMONIC }}
+          CYPRESS_NIGHTLY_RUN: true
+          CYPRESS_TEARDOWN_NETWORK_AFTER_FLOWS: true
+
+      ######
+      ## Upload logs
+      ######
+
+      - name: Logs
+        run: vegacapsule network logs > vega-capsule-logs.txt
+
+      - uses: actions/upload-artifact@v2
+        with:
+          name: logs
+          path: ./vega-capsule-logs.txt

.github/workflows/capsule-cypress.yml

@@ -1,4 +1,4 @@
-name: Cypress tests - PR
+name: Cypress tests
 
 on:
   push:
@@ -11,10 +11,42 @@ on:
       - reopened
       - synchronize
       - ready_for_review
+
 jobs:
   pr:
-    runs-on: ubuntu-latest
+    name: Run Cypress tests - PR
+    runs-on: self-hosted
+    timeout-minutes: 30
+    env:
+      GO111MODULE: 'on'
+      GOBIN: /home/runner/go/bin
+      VEGA_VERSION: 'v0.58.0'
     steps:
+      #######
+      ## Setup langs
+      #######
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        id: go
+        with:
+          go-version: 1.19
+
+      - name: Set up Node 16
+        uses: actions/setup-node@v2
+        id: npm
+        with:
+          node-version: 16
+
+      #######
+      ## Install Yarn
+      #######
+      - name: Setup yarn
+        run: npm install -g yarn
+
+      #######
+      ## Checkout repos
+      #######
+
       # Checkout front ends
       - name: Checkout frontend mono repo
         uses: actions/checkout@v2
@@ -44,18 +76,71 @@ jobs:
           main-branch-name: ${{ github.base_ref || github.ref_name }}
           set-environment-variables-for-job: true
 
-      # See affected projects
+      # See if we capsule is needed for this project
       - name: See affected apps
         run: echo AFFECTED=$(yarn nx print-affected --base=${{ env.NX_BASE }} --head=${{ env.NX_HEAD }} --select=projects) >> $GITHUB_ENV
         working-directory: frontend-monorepo
 
-    outputs:
-      projects: ${{ env.AFFECTED }}
+      - name: See if capsule is necessary
+        if: ${{ contains(env.AFFECTED, 'token') || contains(env.AFFECTED, 'token-e2e') || contains(env.AFFECTED, 'explorer') || contains(env.AFFECTED, 'explorer-e2e') }}
+        run: echo RUN_CAPSULE=true >> $GITHUB_ENV
 
-  dispatch:
-    needs: pr
-    uses: ./.github/workflows/tests-dispatcher.yml
-    secrets: inherit
-    with:
-      project: ${{ needs.pr.outputs.projects }}
-      tags: "--env.grepTags='[ @smoke, @regression ]'"
+      #######
+      ## Build and run Vegacapsule network
+      #######
+
+      - name: Install Vega binaries
+        uses: ./frontend-monorepo/.github/actions/install-vega-binaries
+        with:
+          all: ${{ env.RUN_CAPSULE }}
+          version: ${{ env.VEGA_VERSION }}
+          gobin: ${{ env.GOBIN }}
+
+      - name: Build and run Vegacapsule network
+        if: ${{ env.RUN_CAPSULE }}
+        uses: ./frontend-monorepo/.github/actions/run-vegacapsule
+        with:
+          github-token: ${{ secrets.VEGA_CI_BOT_GITHUB_TOKEN }}
+
+      ######
+      ## Setup a Vega wallet for our user
+      ######
+
+      - name: Set up Vegawallet
+        uses: ./frontend-monorepo/.github/actions/setup-vegawallet
+        with:
+          recovery: ${{ secrets.TRADING_TEST_VEGA_WALLET_RECOVERY }}
+          passphrase: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
+          capsule: ${{ env.RUN_CAPSULE }}
+
+      ######
+      ## Run some tests
+      ######
+
+      # To make sure that all Cypress binaries are installed properly
+      - name: Install cypress bins
+        run: yarn cypress install
+        working-directory: frontend-monorepo
+
+      - name: Run Cypress tests
+        run: npx nx affected:e2e --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --env.grepTags='@smoke' --browser chrome
+        working-directory: frontend-monorepo
+        env:
+          CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
+          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}
+          CYPRESS_ETH_WALLET_MNEMONIC: ${{ secrets.CYPRESS_ETH_WALLET_MNEMONIC }}
+          CYPRESS_TEARDOWN_NETWORK_AFTER_FLOWS: false
+
+      ######
+      ## Upload logs
+      ######
+
+      - name: Logs
+        if: ${{ env.RUN_CAPSULE }}
+        run: vegacapsule network logs > vega-capsule-logs.txt
+
+      - uses: actions/upload-artifact@v2
+        if: ${{ env.RUN_CAPSULE }}
+        with:
+          name: logs
+          path: ./vega-capsule-logs.txt

.github/workflows/cypress-console-lite-e2e.yml

@@ -1,69 +0,0 @@
-name: Cypress - console-lite
-
-on:
-  workflow_call:
-    inputs:
-      trigger:
-        required: true
-        type: string
-        default: 'false'
-      skip-cache:
-        required: false
-        type: string
-      tags:
-        required: false
-        type: string
-
-jobs:
-  console-lite-e2e:
-    if: ${{ inputs.trigger == 'true' }}
-    runs-on: self-hosted
-    steps:
-      - name: Vega version
-        run: vega version
-
-      # Checkout front ends
-      - name: Checkout frontend mono repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          path: './frontend-monorepo'
-
-      # Restore node_modules from cache if possible
-      - name: Restore node_modules from cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            frontend-monorepo/node_modules
-            /home/runner/.cache/Cypress
-          key: node_modules_cypress-${{ hashFiles('frontend-monorepo/yarn.lock') }}
-
-      # Install frontend dependencies
-      - name: Install root dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: frontend-monorepo
-
-      ######
-      ## Setup a Vega wallet for our user
-      ######
-
-      - name: Set up Vegawallet
-        id: setup-vega
-        uses: ./frontend-monorepo/.github/actions/setup-vegawallet
-        with:
-          recovery: ${{ secrets.TRADING_TEST_VEGA_WALLET_RECOVERY }}
-          passphrase: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
-
-      # To make sure that all Cypress binaries are installed properly
-      - name: Install cypress bins
-        run: yarn cypress install
-        working-directory: frontend-monorepo
-
-      - name: Run Cypress tests
-        run: npx nx run console-lite-e2e:e2e ${{ inputs.skip-cache }} --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --browser chrome ${{ inputs.tags }}
-        working-directory: frontend-monorepo
-        env:
-          CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
-          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}
-          CYPRESS_ETH_WALLET_MNEMONIC: ${{ secrets.CYPRESS_ETH_WALLET_MNEMONIC }}
-          CYPRESS_VEGA_WALLET_API_TOKEN: ${{ steps.setup-vega.outputs.token }}

.github/workflows/cypress-explorer-e2e.yml

@@ -1,106 +0,0 @@
-name: Cypress - explorer
-
-on:
-  workflow_call:
-    inputs:
-      trigger:
-        required: true
-        type: string
-        default: 'false'
-      skip-cache:
-        required: false
-        type: string
-      tags:
-        required: false
-        type: string
-      night-run:
-        required: false
-        type: boolean
-        default: false
-
-jobs:
-  explorer-e2e:
-    if: ${{ inputs.trigger == 'true' }}
-    runs-on: self-hosted
-    timeout-minutes: 30
-    steps:
-      - name: Vega version
-        run: vega version
-
-      - name: Vegacapsule version
-        run: vegacapsule version
-
-      # Checkout front ends
-      - name: Checkout frontend mono repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          path: './frontend-monorepo'
-
-      # Restore node_modules from cache if possible
-      - name: Restore node_modules from cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            frontend-monorepo/node_modules
-            /home/runner/.cache/Cypress
-          key: node_modules_cypress-${{ hashFiles('frontend-monorepo/yarn.lock') }}
-
-      # Install frontend dependencies
-      - name: Install root dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: frontend-monorepo
-
-      #######
-      ## Build and run Vegacapsule network
-      #######
-
-      - name: Build and run Vegacapsule network
-        uses: ./frontend-monorepo/.github/actions/run-vegacapsule
-
-      ######
-      ## Setup a Vega wallet for our user
-      ######
-
-      - name: Set up Vegawallet for docker
-        id: setup-vega
-        uses: ./frontend-monorepo/.github/actions/setup-vegawallet-docker
-        with:
-          passphrase: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
-
-      ######
-      ## Run some tests
-      ######
-
-      # To make sure that all Cypress binaries are installed properly
-      - name: Install cypress bins
-        run: yarn cypress install
-        working-directory: frontend-monorepo
-
-      - name: Run Cypress tests
-        run: npx nx run explorer-e2e:e2e ${{ inputs.skip-cache }} --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --browser chrome ${{ inputs.tags }}
-        working-directory: frontend-monorepo
-        env:
-          CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
-          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}
-          CYPRESS_ETH_WALLET_MNEMONIC: ${{ secrets.CYPRESS_ETH_WALLET_MNEMONIC }}
-          CYPRESS_NIGHTLY_RUN: ${{ inputs.night-run }}
-          CYPRESS_VEGA_WALLET_API_TOKEN: ${{ steps.setup-vega.outputs.token }}
-
-      ######
-      ## Upload logs
-      ######
-
-      # Artifact path is not valid: /ganache-1/capsule-logscolletor.stderr-2022-12-22T10:20:30Z.log. Contains the following character:  Colon :
-      - name: Rename files to allow archive
-        if: ${{ always() }}
-        run: |
-          while read -r file; do
-            mv "${file}" "$(echo ${file} | sed 's|:|-|g')"
-          done< <(find /home/runner/.vegacapsule/testnet/logs -type f)
-
-      - uses: actions/upload-artifact@v2
-        if: ${{ always() }}
-        with:
-          name: logs
-          path: /home/runner/.vegacapsule/testnet/logs

.github/workflows/cypress-liquidity-provision-dashboard-e2e.yml

@@ -1,47 +0,0 @@
-name: Cypress - liquidity provision dashboard
-
-on:
-  workflow_call:
-    inputs:
-      trigger:
-        required: true
-        type: string
-        default: 'false'
-
-jobs:
-  liquidity-provision-dashboard-e2e:
-    timeout-minutes: 10
-    if: ${{ inputs.trigger == 'true' }}
-    runs-on: self-hosted
-    steps:
-      # Checkout front ends
-      - name: Checkout frontend mono repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          path: './frontend-monorepo'
-
-      # Restore node_modules from cache if possible
-      - name: Restore node_modules from cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            frontend-monorepo/node_modules
-            /home/runner/.cache/Cypress
-          key: node_modules_cypress-${{ hashFiles('frontend-monorepo/yarn.lock') }}
-
-      # Install frontend dependencies
-      - name: Install root dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: frontend-monorepo
-
-      # To make sure that all Cypress binaries are installed properly
-      - name: Install cypress bins
-        run: yarn cypress install
-        working-directory: frontend-monorepo
-
-      - name: Run Cypress tests
-        run: npx nx run liquidity-provision-dashboard-e2e:e2e --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --browser chrome
-        working-directory: frontend-monorepo
-        env:
-          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}

.github/workflows/cypress-live-test.yml

@@ -1,31 +0,0 @@
-name: Cypress Console tests -- live environment
-
-# This workflow runs using provided url
-
-on:
-  workflow_dispatch:
-    inputs:
-      url:
-        description: 'Url'
-        required: true
-        type: string
-
-jobs:
-  cypress-run:
-    name: Run Cypress Trading tests -- live environment
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Run Cypress tests
-        uses: cypress-io/github-action@v4
-        with:
-          browser: chrome
-          record: true
-          project: ./apps/trading-e2e
-          config: baseUrl=${{ github.event.inputs.url }}
-          env: grepTags=@live
-        env:
-          CYPRESS_RECORD_KEY: ${{ secrets.CYPRESS_RECORD_KEY }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/cypress-stats-e2e.yml

@@ -1,47 +0,0 @@
-name: Cypress - stats
-
-on:
-  workflow_call:
-    inputs:
-      trigger:
-        required: true
-        type: string
-        default: 'false'
-
-jobs:
-  stats-e2e:
-    runs-on: self-hosted
-    if: ${{ inputs.trigger == 'true' }}
-    timeout-minutes: 10
-    steps:
-      # Checkout front ends
-      - name: Checkout frontend mono repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          path: './frontend-monorepo'
-
-      # Restore node_modules from cache if possible
-      - name: Restore node_modules from cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            frontend-monorepo/node_modules
-            /home/runner/.cache/Cypress
-          key: node_modules_cypress-${{ hashFiles('frontend-monorepo/yarn.lock') }}
-
-      # Install frontend dependencies
-      - name: Install root dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: frontend-monorepo
-
-      # To make sure that all Cypress binaries are installed properly
-      - name: Install cypress bins
-        run: yarn cypress install
-        working-directory: frontend-monorepo
-
-      - name: Run Cypress tests
-        run: npx nx run stats-e2e:e2e --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --browser chrome
-        working-directory: frontend-monorepo
-        env:
-          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}

.github/workflows/cypress-token-e2e.yml

@@ -1,101 +0,0 @@
-name: Cypress - token
-
-on:
-  workflow_call:
-    inputs:
-      trigger:
-        required: true
-        type: string
-        default: 'false'
-      skip-cache:
-        required: false
-        type: string
-      tags:
-        required: false
-        type: string
-
-jobs:
-  token-e2e:
-    if: ${{ inputs.trigger == 'true' }}
-    runs-on: self-hosted
-    timeout-minutes: 60
-    steps:
-      - name: Vega version
-        run: vega version
-
-      - name: Vegacapsule version
-        run: vegacapsule version
-
-      # Checkout front ends
-      - name: Checkout frontend mono repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          path: './frontend-monorepo'
-
-      # Restore node_modules from cache if possible
-      - name: Restore node_modules from cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            frontend-monorepo/node_modules
-            /home/runner/.cache/Cypress
-          key: node_modules_cypress-${{ hashFiles('frontend-monorepo/yarn.lock') }}
-
-      # Install frontend dependencies
-      - name: Install root dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: frontend-monorepo
-
-      #######
-      ## Build and run Vegacapsule network
-      #######
-
-      - name: Build and run Vegacapsule network
-        uses: ./frontend-monorepo/.github/actions/run-vegacapsule
-
-      ######
-      ## Setup a Vega wallet for our user
-      ######
-
-      - name: Set up Vegawallet for docker
-        id: setup-vega
-        uses: ./frontend-monorepo/.github/actions/setup-vegawallet-docker
-        with:
-          passphrase: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
-
-      ######
-      ## Run some tests
-      ######
-
-      # To make sure that all Cypress binaries are installed properly
-      - name: Install cypress bins
-        run: yarn cypress install
-        working-directory: frontend-monorepo
-
-      - name: Run Cypress tests
-        run: npx nx run token-e2e:e2e ${{ inputs.skip-cache }} --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --browser chrome ${{ inputs.tags }}
-        working-directory: frontend-monorepo
-        env:
-          CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
-          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}
-          CYPRESS_ETH_WALLET_MNEMONIC: ${{ secrets.CYPRESS_ETH_WALLET_MNEMONIC }}
-          CYPRESS_VEGA_WALLET_API_TOKEN: ${{ steps.setup-vega.outputs.token }}
-
-      ######
-      ## Upload logs
-      ######
-
-      # Artifact path is not valid: /ganache-1/capsule-logscolletor.stderr-2022-12-22T10:20:30Z.log. Contains the following character:  Colon :
-      - name: Rename files to allow archive
-        if: ${{ always() }}
-        run: |
-          while read -r file; do
-            mv "${file}" "$(echo ${file} | sed 's|:|-|g')"
-          done< <(find /home/runner/.vegacapsule/testnet/logs -type f)
-
-      - uses: actions/upload-artifact@v2
-        if: ${{ always() }}
-        with:
-          name: logs
-          path: /home/runner/.vegacapsule/testnet/logs

.github/workflows/cypress-trading-e2e.yml

@@ -1,70 +0,0 @@
-name: Cypress - trading
-
-on:
-  workflow_call:
-    inputs:
-      trigger:
-        required: true
-        type: string
-        default: 'false'
-      skip-cache:
-        required: false
-        type: string
-      tags:
-        required: false
-        type: string
-
-jobs:
-  trading-e2e:
-    if: ${{ inputs.trigger == 'true' }}
-    timeout-minutes: 30
-    runs-on: self-hosted
-    steps:
-      - name: Vega version
-        run: vega version
-
-      # Checkout front ends
-      - name: Checkout frontend mono repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          path: './frontend-monorepo'
-
-      # Restore node_modules from cache if possible
-      - name: Restore node_modules from cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            frontend-monorepo/node_modules
-            /home/runner/.cache/Cypress
-          key: node_modules_cypress-${{ hashFiles('frontend-monorepo/yarn.lock') }}
-
-      # Install frontend dependencies
-      - name: Install root dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: frontend-monorepo
-
-      ######
-      ## Setup a Vega wallet for our user
-      ######
-
-      - name: Set up Vegawallet
-        id: setup-vega
-        uses: ./frontend-monorepo/.github/actions/setup-vegawallet
-        with:
-          recovery: ${{ secrets.TRADING_TEST_VEGA_WALLET_RECOVERY }}
-          passphrase: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
-
-      # To make sure that all Cypress binaries are installed properly
-      - name: Install cypress bins
-        run: yarn cypress install
-        working-directory: frontend-monorepo
-
-      - name: Run Cypress tests
-        run: npx nx run trading-e2e:e2e ${{ inputs.skip-cache }} --record --key ${{ secrets.CYPRESS_RECORD_KEY }} --browser chrome ${{ inputs.tags }}
-        working-directory: frontend-monorepo
-        env:
-          CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE: ${{ secrets.CYPRESS_TRADING_TEST_VEGA_WALLET_PASSPHRASE }}
-          CYPRESS_SLACK_WEBHOOK: ${{ secrets.CYPRESS_SLACK_WEBHOOK }}
-          CYPRESS_ETH_WALLET_MNEMONIC: ${{ secrets.CYPRESS_ETH_WALLET_MNEMONIC }}
-          CYPRESS_VEGA_WALLET_API_TOKEN: ${{ steps.setup-vega.outputs.token }}

.github/workflows/lint_pr.yml

@@ -1,21 +0,0 @@
----
-name: Verify PR title
-
-on:
-  pull_request:
-    types: [opened, ready_for_review, reopened, edited, synchronize]
-jobs:
-  lint_pr:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Use Node.js 16
-        id: Node
-        uses: actions/setup-node@v2
-        with:
-          node-version: 16.14.0
-      - name: Install commitlint cli and config
-        run: npm install @commitlint/cli @commitlint/config-conventional
-      - name: Create config
-        run: echo "module.exports = {extends:['@commitlint/config-conventional']};" > commitlint.config.js
-      - name: Check PR title
-        run: echo "${{ github.event.pull_request.title }}" | npx commitlint

.github/workflows/publish-docker-containers.yml

@@ -4,7 +4,7 @@ name: Publish docker containers
   push:
     tags:
       - 'v[0-9]+.[0-9]+.[0-9]+'
-      - 'v[0-9]+.[0-9]+.[0-9]+-*'
+      - 'v[0-9]+.[0-9]+.[0-9]+-pre[0-9]+'
 
   workflow_dispatch:
     inputs:

.github/workflows/tests-dispatcher.yml

@@ -1,61 +0,0 @@
-on:
-  workflow_call:
-    inputs:
-      project:
-        required: true
-        type: string
-      skip-cache:
-        required: false
-        type: string
-      tags:
-        required: false
-        type: string
-      night-run:
-        required: false
-        type: boolean
-
-jobs:
-  run-console-lite-e2e:
-    uses: ./.github/workflows/cypress-console-lite-e2e.yml
-    secrets: inherit
-    with:
-      trigger: ${{ contains(inputs.project, 'console-lite-e2e') || contains(inputs.project, 'console-lite') }}
-      skip-cache: ${{ inputs.skip-cache }}
-      tags: ${{ inputs.tags }}
-
-  run-explorer-e2e:
-    uses: ./.github/workflows/cypress-explorer-e2e.yml
-    secrets: inherit
-    with:
-      trigger: ${{ contains(inputs.project, 'explorer-e2e') || contains(inputs.project, 'explorer') }}
-      skip-cache: ${{ inputs.skip-cache }}
-      tags: ${{ inputs.tags }}
-      night-run: ${{ inputs.night-run }}
-
-  run-liquidity-e2e:
-    uses: ./.github/workflows/cypress-liquidity-provision-dashboard-e2e.yml
-    secrets: inherit
-    with:
-      trigger: ${{ contains(inputs.project, 'liquidity-provision-dashboard-e2e') || contains(inputs.project, 'liquidity-provision-dashboard') }}
-
-  run-stats-e2e:
-    uses: ./.github/workflows/cypress-stats-e2e.yml
-    secrets: inherit
-    with:
-      trigger: ${{ contains(inputs.project, 'stats-e2e') || contains(inputs.project, 'stats') }}
-
-  run-token-e2e:
-    uses: ./.github/workflows/cypress-token-e2e.yml
-    secrets: inherit
-    with:
-      trigger: ${{ contains(inputs.project, 'token-e2e') || contains(inputs.project, 'token') }}
-      skip-cache: ${{ inputs.skip-cache }}
-      tags: ${{ inputs.tags }}
-
-  run-trading-e2e:
-    uses: ./.github/workflows/cypress-trading-e2e.yml
-    secrets: inherit
-    with:
-      trigger: ${{ contains(inputs.project, 'trading-e2e') || contains(inputs.project, 'trading') }}
-      skip-cache: ${{ inputs.skip-cache }}
-      tags: ${{ inputs.tags }}

.storybook/main.js

@@ -1,24 +1,6 @@
 module.exports = {
   stories: [],
-  addons: [
-    '@storybook/addon-actions',
-    '@storybook/addon-viewport',
-    {
-      name: '@storybook/addon-docs',
-      options: {
-        configureJSX: true,
-        babelOptions: {},
-        sourceLoaderOptions: null,
-        transcludeMarkdown: true,
-      },
-    },
-    '@storybook/addon-controls',
-    '@storybook/addon-backgrounds',
-    '@storybook/addon-toolbars',
-    '@storybook/addon-measure',
-    '@storybook/addon-outline',
-    '@storybook/addon-a11y',
-  ],
+  addons: ['@storybook/addon-essentials', '@storybook/addon-a11y'],
   // uncomment the property below if you want to apply some webpack config globally
   // webpackFinal: async (config, { configType }) => {
   //   // Make whatever fine-grained changes you need that should apply to all storybook configs

CODEOWNERS

@@ -1,2 +1 @@
 * @vegaprotocol/frontend
-*.graphql @vegaprotocol/core

README.md

@@ -86,14 +86,13 @@ Run `yarn nx run <my-app>-e2e:e2e` to execute the e2e tests with [cypress](https
 
 Run `nx test my-app` to execute the unit tests with [Jest](https://jestjs.io), or `nx affected:test` to execute just unit tests affected by a change. You can also use `--watch` with these test to run jest in watch mode, see [Jest executor](https://nx.dev/packages/jest/executors/jest) for all CLI flags.
 
-### Using wallet
+#### Trading app E2E tests
 
-To run tests locally using your own wallets make sure you have generated at least two public keys and update the following environment variables in `cypress.config.js` to match your wallet.
+To run tests locally using your own wallets you can add the following environment variables to `cypress.json`
 
-1. Set `VEGA_PUBLIC_KEY` and `TRUNCATED_VEGA_PUBLIC_KEY` to your first public key.
-2. Set `VEGA_PUBLIC_KEY2` and `TRUNCATED_VEGA_PUBLIC_KEY2` to your second public key.
-3. Set `TRADING_TEST_VEGA_WALLET_PASSPHRASE` as your wallet passphrase
-4. Add `ETH_WALLET_MNEMONIC` as your Ethereum wallet mnemonic
+1. Change `TRADING_TEST_VEGA_WALLET_NAME` to your Vega wallet name
+2. Add `TRADING_TEST_VEGA_WALLET_PASSPHRASE` as your wallet passphrase
+3. Add `ETH_WALLET_MNEMONIC` as your Ethereum wallet mnemonic
 
 ### Formatting
 
@@ -156,23 +155,6 @@ In order to run the bootstrap command to generate and start a new network, we mu
 vegacapsule network bootstrap --config-path=../frontend-monorepo/vegacapsule/config.hcl
 ```
 
-In order to setup and run vegawallet for e2e capsule tests, in a separate terminal window:
-
-1. cd into `./vegacapsule`
-2. run:
-
-```bash
-bash setup-vegawallet.sh
-```
-
-3. copy generated `api-token` and paste the token into `CYPRESS_VEGA_WALLET_API_TOKEN` environment variable in either `apps/token-e2e/.env` or `apps/explorer-e2e/.env` depending on which project needs testing.
-
-Note: The script is only needed if capsule was built for first time or fresh. To run existing wallet service for capsule:
-
-```bash
-vega wallet service run -n DV --load-tokens --tokens-passphrase-file passphrase --no-version-check --automatic-consent --home ~/.vegacapsule/testnet/wallet
-```
-
 # 📑 License
 
 [MIT](./LICENSE)

apps/console-lite-e2e/.env

@@ -1,10 +1,8 @@
 # App configuration variables
 NX_VEGA_CONFIG_URL=https://static.vega.xyz/assets/stagnet3-network.json
-NX_VEGA_URL=https://api.stagnet3.vega.xyz/graphql
+NX_VEGA_URL=https://api.n01.stagnet3.vega.xyz/graphql
 NX_VEGA_ENV=STAGNET3
 NX_ETHEREUM_PROVIDER_URL=https://sepolia.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8
 NX_ETHERSCAN_URL=https://sepolia.etherscan.io
 NX_VEGA_EXPLORER_URL=https://stagnet3.explorer.vega.xyz
 NX_VEGA_WALLET_URL=http://localhost:1789
-CYPRESS_VEGA_ENV=STAGNET3
-CYPRESS_VEGA_WALLET_API_TOKEN=

apps/console-lite-e2e/cypress.config.js

@@ -4,7 +4,7 @@ module.exports = defineConfig({
 
   e2e: {
     setupNodeEvents(on, config) {
-      require('@cypress/grep/src/plugin')(config);
+      require('cypress-grep/src/plugin')(config);
       return config;
     },
     baseUrl: 'http://localhost:4200',
@@ -23,6 +23,7 @@ module.exports = defineConfig({
     viewportHeight: 900,
   },
   env: {
+    TRADING_TEST_VEGA_WALLET_NAME: 'UI_Trading_Test',
     ETHEREUM_PROVIDER_URL:
       'https://sepolia.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8',
     VEGA_PUBLIC_KEY:

apps/console-lite-e2e/index.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="cypress" />
-
-declare namespace Cypress {
-  // specify additional properties in the TestConfig object
-  // in our case we will add "tags" property
-  interface SuiteConfigOverrides {
-    /**
-     * List of tags for this test
-     * @example a single tag
-     *  it('logs in', { tags: '@smoke' }, () => { ... })
-     * @example multiple tags
-     *  it('works', { tags: ['@smoke', '@slow'] }, () => { ... })
-     */
-    tags?: string | string[];
-  }
-
-  interface Cypress {
-    grep?: (grep?: string, tags?: string, burn?: string) => void;
-  }
-}

apps/console-lite-e2e/src/integration/app.test.ts

@@ -1,6 +1,15 @@
+import { aliasQuery } from '@vegaprotocol/cypress';
+import {
+  generateSimpleMarkets,
+  generateMarketsCandles,
+} from '../support/mocks/generate-markets';
+
 describe('simple trading app', { tags: '@smoke' }, () => {
   beforeEach(() => {
-    cy.mockConsole();
+    cy.mockGQL((req) => {
+      aliasQuery(req, 'Markets', generateSimpleMarkets());
+      aliasQuery(req, 'MarketsCandles', generateMarketsCandles());
+    });
     cy.visit('/');
   });
 

apps/console-lite-e2e/src/integration/market-list.test.ts

@@ -1,11 +1,18 @@
-import { aliasGQLQuery } from '@vegaprotocol/cypress';
+import { aliasQuery } from '@vegaprotocol/cypress';
 import type { MarketsQuery } from '@vegaprotocol/market-list';
-import { marketCandlesQuery, marketsQuery } from '@vegaprotocol/mock';
+import {
+  generateLongListMarkets,
+  generateSimpleMarkets,
+  generateMarketsCandles,
+} from '../support/mocks/generate-markets';
 
 describe('market list', { tags: '@smoke' }, () => {
   describe('simple url', () => {
     beforeEach(() => {
-      cy.mockConsole();
+      cy.mockGQL((req) => {
+        aliasQuery(req, 'Markets', generateSimpleMarkets());
+        aliasQuery(req, 'MarketsCandles', generateMarketsCandles());
+      });
       cy.visit('/markets');
     });
 
@@ -57,7 +64,10 @@ describe('market list', { tags: '@smoke' }, () => {
 
   describe('url params should select filters', () => {
     beforeEach(() => {
-      cy.mockConsole();
+      cy.mockGQL((req) => {
+        aliasQuery(req, 'Markets', generateSimpleMarkets());
+        aliasQuery(req, 'MarketsCandles', generateMarketsCandles());
+      });
     });
 
     it('suspended status', () => {
@@ -90,26 +100,14 @@ describe('market list', { tags: '@smoke' }, () => {
   });
 
   describe('long list of results should be handled properly', () => {
-    beforeEach(() => {
-      cy.mockConsole();
+    it('handles 1000 markets', () => {
       cy.viewport(1440, 900);
-      const market = marketsQuery().marketsConnection?.edges[0];
-      const edges = new Array(1000)
-        .fill('')
-        .map(() => Object.assign({}, market));
       cy.mockGQL((req) => {
-        aliasGQLQuery(
-          req,
-          'Markets',
-          marketsQuery({ marketsConnection: { edges } })
-        );
-        aliasGQLQuery(req, 'MarketsCandles', marketCandlesQuery());
+        aliasQuery(req, 'Markets', generateLongListMarkets(1000));
+        aliasQuery(req, 'MarketsCandles', generateMarketsCandles());
       });
       performance.mark('start-1k');
       cy.visit('/markets');
-      cy.wait('@Markets');
-    });
-    it('handles 1000 markets', () => {
       cy.get('.ag-center-cols-container', { timeout: 50000 }).then(() => {
         performance.mark('end-1k');
         performance.measure('load-1k', 'start-1k', 'end-1k');

apps/console-lite-e2e/src/integration/market-selector.test.ts

@@ -1,85 +1,148 @@
-const marketId = 'market-0';
-const marketName = 'ACTIVE MARKET';
+import { connectVegaWallet } from '../support/connect-wallet';
+import { aliasQuery } from '@vegaprotocol/cypress';
+import {
+  generateMarketsCandles,
+  generateMarketsData,
+  generateSimpleMarkets,
+} from '../support/mocks/generate-markets';
+import { generateDealTicket } from '../support/mocks/generate-deal-ticket';
+import { generateMarketTags } from '../support/mocks/generate-market-tags';
+import { generateMarketPositions } from '../support/mocks/generate-market-positions';
+import { generateEstimateOrder } from '../support/mocks/generate-estimate-order';
+import { generatePartyBalance } from '../support/mocks/generate-party-balance';
+import { generatePartyMarketData } from '../support/mocks/generate-party-market-data';
+import { generateMarketMarkPrice } from '../support/mocks/generate-market-mark-price';
+import { generateMarketNames } from '../support/mocks/generate-market-names';
+import { generateMarketDepth } from '../support/mocks/generate-market-depth';
+import type { Market, MarketsQuery } from '@vegaprotocol/market-list';
 
 describe('market selector', { tags: '@smoke' }, () => {
+  let markets: Market[];
   beforeEach(() => {
-    cy.mockConsole();
-    cy.visit(`/trading/${marketId}`);
-    cy.connectVegaWallet();
-    cy.wait('@Markets');
+    cy.mockGQL((req) => {
+      aliasQuery(req, 'Markets', generateSimpleMarkets());
+      aliasQuery(req, 'MarketsCandles', generateMarketsCandles());
+      aliasQuery(req, 'MarketsData', generateMarketsData());
+      aliasQuery(req, 'DealTicket', generateDealTicket());
+      aliasQuery(req, 'MarketTags', generateMarketTags());
+      aliasQuery(req, 'MarketPositions', generateMarketPositions());
+      aliasQuery(req, 'EstimateOrder', generateEstimateOrder());
+      aliasQuery(req, 'PartyBalance', generatePartyBalance());
+      aliasQuery(req, 'PartyMarketData', generatePartyMarketData());
+      aliasQuery(req, 'MarketMarkPrice', generateMarketMarkPrice());
+      aliasQuery(req, 'MarketNames', generateMarketNames());
+      aliasQuery(req, 'MarketDepth', generateMarketDepth());
+    });
+
+    cy.visit('/markets');
+    cy.wait('@Markets').then((response) => {
+      const data: MarketsQuery | undefined = response?.response?.body?.data;
+      if (data?.marketsConnection?.edges.length) {
+        markets = data?.marketsConnection?.edges.map((edge) => edge.node);
+      }
+    });
   });
 
   it('should be properly rendered', () => {
-    cy.get('input[placeholder="Search"]').should('have.value', marketName);
-    cy.getByTestId('arrow-button').click();
-    cy.getByTestId('market-pane').should('be.visible');
-    cy.getByTestId('market-pane')
-      .children()
-      .find('[role="button"]')
-      .first()
-      .should('contain.text', marketName);
-    cy.getByTestId('market-pane')
-      .children()
-      .find('[role="button"]')
-      .first()
-      .click();
-    cy.getByTestId('market-pane').should('not.be.visible');
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[0].id}`);
+      connectVegaWallet();
+      cy.get('input[placeholder="Search"]').should(
+        'have.value',
+        markets[0].tradableInstrument.instrument.name
+      );
+      cy.getByTestId('arrow-button').click();
+      cy.getByTestId('market-pane').should('be.visible');
+      cy.getByTestId('market-pane')
+        .children()
+        .find('[role="button"]')
+        .first()
+        .should('contain.text', markets[0].tradableInstrument.instrument.name);
+      cy.getByTestId('market-pane')
+        .children()
+        .find('[role="button"]')
+        .first()
+        .click();
+      cy.getByTestId('market-pane').should('not.be.visible');
+    }
   });
 
   it('typing should change list', () => {
-    cy.get('input[placeholder="Search"]').type('{backspace}');
-    cy.getByTestId('market-pane')
-      .children()
-      .find('[role="button"]')
-      .should('have.length.at.least', 1);
-    cy.get('input[placeholder="Search"]').clear();
-    cy.get('input[placeholder="Search"]').type('ACTIVE');
-    cy.getByTestId('market-pane')
-      .children()
-      .find('[role="button"]')
-      .should('have.length', 1);
-    cy.getByTestId('market-pane')
-      .children()
-      .find('[role="button"]')
-      .last()
-      .click();
-    cy.location('pathname').should('eq', `/trading/${marketId}`);
-    cy.get('input[placeholder="Search"]').should('have.value', marketName);
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[0].id}`);
+      connectVegaWallet();
+      cy.get('input[placeholder="Search"]').type('{backspace}');
+      cy.getByTestId('market-pane')
+        .children()
+        .find('[role="button"]')
+        .should('have.length.at.least', 1);
+      cy.get('input[placeholder="Search"]').clear();
+      cy.get('input[placeholder="Search"]').type('aa');
+      const filtered = markets.filter(
+        (market) =>
+          market.state === 'STATE_ACTIVE' &&
+          market.tradableInstrument.instrument.name.match(/aa/i)
+      );
+      cy.getByTestId('market-pane')
+        .children()
+        .find('[role="button"]')
+        .should('have.length', filtered.length);
+      cy.getByTestId('market-pane')
+        .children()
+        .find('[role="button"]')
+        .last()
+        .click();
+      cy.location('pathname').should(
+        'eq',
+        `/trading/${filtered[filtered.length - 1].id}`
+      );
+      cy.get('input[placeholder="Search"]').should(
+        'have.value',
+        filtered[filtered.length - 1].tradableInstrument.instrument.name
+      );
+    }
   });
   // constantly failing on ci
   it.skip('keyboard navigation should work well', () => {
-    cy.get('input[placeholder="Search"]').type('{backspace}');
-    cy.get('input[placeholder="Search"]').clear();
-    cy.focused().realPress('ArrowDown');
-    cy.focused().should('contain.text', marketName);
-    cy.focused().realPress('ArrowDown');
-    cy.focused().should('contain.text', 'ETHBTC').realPress('Enter');
-    cy.location('pathname').should('eq', '/trading/ethbtc-quaterly');
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[0].id}`);
+      connectVegaWallet();
+      cy.get('input[placeholder="Search"]').type('{backspace}');
+      cy.get('input[placeholder="Search"]').clear();
+      cy.focused().realPress('ArrowDown');
+      cy.focused().should('contain.text', 'AAVEDAI Monthly');
+      cy.focused().realPress('ArrowDown');
+      cy.focused().should('contain.text', 'ETHBTC').realPress('Enter');
+      cy.location('pathname').should('eq', '/trading/ethbtc-quaterly');
 
-    cy.get('input[placeholder="Search"]').type('{backspace}');
-    cy.get('input[placeholder="Search"]').clear();
-    cy.getByTestId('market-pane').should('be.visible');
-    cy.get('body').realPress('ArrowDown');
-    cy.get('body').realPress('Tab');
-    cy.getByTestId('market-pane').should('not.be.visible');
+      cy.get('input[placeholder="Search"]').type('{backspace}');
+      cy.get('input[placeholder="Search"]').clear();
+      cy.getByTestId('market-pane').should('be.visible');
+      cy.get('body').realPress('ArrowDown');
+      cy.get('body').realPress('Tab');
+      cy.getByTestId('market-pane').should('not.be.visible');
+    }
   });
 
   it('mobile view', () => {
-    cy.viewport('iphone-xr');
-    cy.visit(`/trading/${marketId}`);
-    cy.connectVegaWallet();
-    cy.get('[role="dialog"]').should('not.exist');
-    cy.getByTestId('arrow-button').click();
-    cy.get('[role="dialog"]').should('be.visible');
-    cy.get('input[placeholder="Search"]').then((search) => {
-      cy.wrap(search).clear();
-    });
-    cy.getByTestId('market-pane')
-      .children()
-      .find('[role="button"]')
-      .should('have.length', 3);
-    cy.get('div[role="dialog"]').should('have.class', 'w-screen');
-    cy.getByTestId('dialog-close').click();
-    cy.get('input[placeholder="Search"]').should('have.value', marketName);
+    if (markets?.length) {
+      cy.viewport('iphone-xr');
+      cy.visit(`/trading/${markets[0].id}`);
+      connectVegaWallet();
+      cy.get('[role="dialog"]').should('not.exist');
+      cy.getByTestId('arrow-button').click();
+      cy.get('[role="dialog"]').should('be.visible');
+      cy.get('input[placeholder="Search"]').clear();
+      cy.getByTestId('market-pane')
+        .children()
+        .find('[role="button"]')
+        .should('have.length', 9);
+      cy.get('div[role="dialog"]').should('have.class', 'w-screen');
+      cy.getByTestId('dialog-close').click();
+      cy.get('input[placeholder="Search"]').should(
+        'have.value',
+        markets[0].tradableInstrument.instrument.name
+      );
+    }
   });
 });

apps/console-lite-e2e/src/integration/market-trade.test.ts

@@ -1,38 +1,50 @@
-import { aliasGQLQuery } from '@vegaprotocol/cypress';
-import { marketQuery, marketsQuery } from '@vegaprotocol/mock';
+import { aliasQuery } from '@vegaprotocol/cypress';
+import {
+  generateSimpleMarkets,
+  generateMarketsCandles,
+  generateMarketsData,
+  generateMarket,
+} from '../support/mocks/generate-markets';
+import { generateDealTicket } from '../support/mocks/generate-deal-ticket';
+import { generateMarketTags } from '../support/mocks/generate-market-tags';
+import { generateMarketPositions } from '../support/mocks/generate-market-positions';
+import { generateEstimateOrder } from '../support/mocks/generate-estimate-order';
+import { generatePartyBalance } from '../support/mocks/generate-party-balance';
+import { generatePartyMarketData } from '../support/mocks/generate-party-market-data';
+import { generateMarketMarkPrice } from '../support/mocks/generate-market-mark-price';
+import { generateMarketDepth } from '../support/mocks/generate-market-depth';
+import { connectVegaWallet } from '../support/connect-wallet';
+import type { MarketsQuery, Market } from '@vegaprotocol/market-list';
 
-const marketId =
-  marketsQuery().marketsConnection?.edges[1].node.id || 'market-1';
-const marketOverride = {
-  market: {
-    depth: {
-      lastTrade: {
-        price: '9893006',
-      },
-    },
-    id: marketId,
-    tradableInstrument: {
-      instrument: {
-        product: {
-          settlementAsset: {
-            id: 'asset-id-2',
-            name: 'DAI Name',
-            symbol: 'tDAI',
-          },
-        },
-      },
-    },
-  },
-};
-
-describe('Market trade with wallet disconnected', { tags: '@smoke' }, () => {
-  before(() => {
-    cy.mockConsole();
-    cy.visit(`/trading/${marketId}`);
-    cy.wait('@Market');
-    console.log('marketId', marketId);
+describe('Market trade', { tags: '@smoke' }, () => {
+  let markets: Market[];
+  beforeEach(() => {
+    cy.mockGQL((req) => {
+      aliasQuery(req, 'Markets', generateSimpleMarkets());
+      aliasQuery(req, 'MarketsCandles', generateMarketsCandles());
+      aliasQuery(req, 'MarketsData', generateMarketsData());
+      aliasQuery(req, 'SimpleMarkets', generateSimpleMarkets());
+      aliasQuery(req, 'DealTicket', generateDealTicket());
+      aliasQuery(req, 'MarketTags', generateMarketTags());
+      aliasQuery(req, 'MarketPositions', generateMarketPositions());
+      aliasQuery(req, 'EstimateOrder', generateEstimateOrder());
+      aliasQuery(req, 'PartyBalance', generatePartyBalance());
+      aliasQuery(req, 'PartyMarketData', generatePartyMarketData());
+      aliasQuery(req, 'MarketMarkPrice', generateMarketMarkPrice());
+      aliasQuery(req, 'MarketDepth', generateMarketDepth());
+      aliasQuery(req, 'Market', generateMarket());
+    });
+    cy.visit('/markets');
+    cy.wait('@Markets').then((response) => {
+      const data: MarketsQuery | undefined = response?.response?.body?.data;
+      if (data?.marketsConnection?.edges.length) {
+        markets = data?.marketsConnection?.edges.map((edge) => edge.node);
+      }
+    });
   });
-  it('should not display steps', () => {
+
+  it('should not display steps if wallet is disconnected', () => {
+    cy.visit(`/trading/${markets[0].id}`);
     cy.getByTestId('trading-connect-wallet')
       .find('h3')
       .should('have.text', 'Please connect your Vega wallet to make a trade');
@@ -43,236 +55,273 @@ describe('Market trade with wallet disconnected', { tags: '@smoke' }, () => {
       .find('a')
       .should('have.text', 'https://vega.xyz/wallet');
   });
-});
-
-describe('Market trade', { tags: '@regression' }, () => {
-  beforeEach(() => {
-    cy.mockConsole();
-    cy.mockGQL((req) => {
-      aliasGQLQuery(req, 'Market', marketQuery(marketOverride));
-    });
-    cy.visit(`/trading/${marketId}`);
-    cy.connectVegaWallet();
-    cy.wait('@Market');
-  });
 
   it('side selector should work well', () => {
-    cy.get('#step-1-control [aria-label^="Selected value"]').should(
-      'have.text',
-      'Long'
-    );
-    cy.get('#step-1-control [aria-label^="Selected value"]').click();
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('#step-2-control').click();
-    cy.get('#step-1-control [aria-label^="Selected value"]').should(
-      'have.text',
-      'Short'
-    );
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[0].id}`);
+      connectVegaWallet();
+      cy.get('#step-1-control [aria-label^="Selected value"]').should(
+        'have.text',
+        'Long'
+      );
+      cy.get('#step-1-control [aria-label^="Selected value"]').click();
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('#step-2-control').click();
+      cy.get('#step-1-control [aria-label^="Selected value"]').should(
+        'have.text',
+        'Short'
+      );
+    }
   });
 
   it('side selector mobile view should work well', () => {
-    cy.viewport('iphone-xr');
-    cy.getByTestId('next-button').scrollIntoView().click();
+    if (markets?.length) {
+      cy.viewport('iphone-xr');
+      cy.visit(`/trading/${markets[0].id}`);
+      connectVegaWallet();
+      cy.getByTestId('next-button').scrollIntoView().click();
 
-    cy.get('button[aria-label="Open long position"]').should(
-      'have.class',
-      'selected'
-    );
-    cy.get('button[aria-label="Open short position"]').should(
-      'not.have.class',
-      'selected'
-    );
+      cy.get('button[aria-label="Open long position"]').should(
+        'have.class',
+        'selected'
+      );
+      cy.get('button[aria-label="Open short position"]').should(
+        'not.have.class',
+        'selected'
+      );
 
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('button[aria-label="Open long position"]').should(
-      'not.have.class',
-      'selected'
-    );
-    cy.get('button[aria-label="Open short position"]').should(
-      'have.class',
-      'selected'
-    );
-    cy.getByTestId('next-button').scrollIntoView().click();
-    cy.get('#step-1-control').should(
-      'contain.html',
-      'aria-label="Selected value Short"'
-    );
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('button[aria-label="Open long position"]').should(
+        'not.have.class',
+        'selected'
+      );
+      cy.get('button[aria-label="Open short position"]').should(
+        'have.class',
+        'selected'
+      );
+      cy.getByTestId('next-button').scrollIntoView().click();
+      cy.get('#step-1-control').should(
+        'contain.html',
+        'aria-label="Selected value Short"'
+      );
+    }
   });
 
   it('size slider should work well', () => {
-    cy.get('#step-1-control [aria-label^="Selected value"]').click();
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('#step-2-control').click();
-    cy.get('#step-2-panel')
-      .find('dd')
-      .eq(0)
-      .find('button')
-      .should('have.text', '1');
-    cy.get('#step-2-panel').find('[role="slider"]').type('{rightarrow}');
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[1].id}`);
+      connectVegaWallet();
+      cy.get('#step-1-control [aria-label^="Selected value"]').click();
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('#step-2-control').click();
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('button')
+        .should('have.text', '1');
+      cy.get('#step-2-panel').find('[role="slider"]').type('{rightarrow}');
 
-    cy.get('#step-2-panel')
-      .find('dd')
-      .eq(0)
-      .find('button')
-      .should('have.text', '2');
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('button')
+        .should('have.text', '2');
+    }
   });
 
   it('percentage selection should work well', () => {
-    cy.get('#step-1-control [aria-label^="Selected value"]').click();
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('#step-2-control').click();
-    cy.get('#step-2-panel')
-      .find('dd')
-      .eq(0)
-      .find('button')
-      .should('have.text', '1');
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[1].id}`);
+      connectVegaWallet();
+      cy.get('#step-1-control [aria-label^="Selected value"]').click();
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('#step-2-control').click();
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('button')
+        .should('have.text', '1');
 
-    cy.getByTestId('max-label').should('have.text', '10');
+      cy.getByTestId('max-label').should('have.text', '21');
 
-    cy.getByTestId('percentage-selector')
-      .find('button')
-      .contains('Max')
-      .click();
-    cy.get('#step-2-panel')
-      .find('dd')
-      .eq(0)
-      .find('button')
-      .should('have.text', '10');
+      cy.getByTestId('percentage-selector')
+        .find('button')
+        .contains('Max')
+        .click();
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('button')
+        .should('have.text', '21');
+    }
   });
 
   it('size input should work well', () => {
-    cy.get('#step-1-control [aria-label^="Selected value"]').click();
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('#step-2-control').click();
-    cy.get('#step-2-panel')
-      .find('dd')
-      .eq(0)
-      .find('button')
-      .should('have.text', '1');
-    cy.get('#step-2-panel').find('dd').eq(0).find('button').click();
-    cy.get('#step-2-panel').find('dd').eq(0).find('input').type('{backspace}2');
-    cy.get('#step-2-panel').find('dd').eq(0).find('button').click();
-    cy.get('#step-2-panel')
-      .find('dd')
-      .eq(0)
-      .find('button')
-      .should('have.text', '2');
-    cy.get('button').contains('Max').click();
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[1].id}`);
+      connectVegaWallet();
+      cy.get('#step-1-control [aria-label^="Selected value"]').click();
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('#step-2-control').click();
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('button')
+        .should('have.text', '1');
+      cy.get('#step-2-panel').find('dd').eq(0).find('button').click();
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('input')
+        .type('{backspace}2');
+      cy.get('#step-2-panel').find('dd').eq(0).find('button').click();
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('button')
+        .should('have.text', '2');
+      cy.get('button').contains('Max').click();
+    }
   });
 
   it('slippage value should be displayed', () => {
-    cy.get('#step-1-control [aria-label^="Selected value"]').click();
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('#step-2-control').click();
-    cy.get('button').contains('Max').click();
-    cy.get('#step-2-panel')
-      .find('dl')
-      .eq(2)
-      .find('dd')
-      .should('have.text', '0.01%');
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[1].id}`);
+      connectVegaWallet();
+      cy.get('#step-1-control [aria-label^="Selected value"]').click();
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('#step-2-control').click();
+      cy.get('button').contains('Max').click();
+      cy.get('#step-2-panel')
+        .find('dl')
+        .eq(2)
+        .find('dd')
+        .should('have.text', '0.02%');
+    }
   });
 
   it('allow slippage value to be adjusted', () => {
-    cy.get('#step-1-control [aria-label^="Selected value"]').click();
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('#step-2-control').click();
-    cy.get('button').contains('Max').click();
-    cy.get('#step-2-panel')
-      .find('dl')
-      .eq(2)
-      .find('dd')
-      .should('have.text', '0.01%');
-    cy.get('#step-2-panel').find('dl').eq(2).find('button').click();
-    cy.get('#input-order-slippage')
-      .focus()
-      .type('{backspace}{backspace}{backspace}1');
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[1].id}`);
+      connectVegaWallet();
+      cy.get('#step-1-control [aria-label^="Selected value"]').click();
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('#step-2-control').click();
+      cy.get('button').contains('Max').click();
+      cy.get('#step-2-panel')
+        .find('dl')
+        .eq(2)
+        .find('dd')
+        .should('have.text', '0.02%');
+      cy.get('#step-2-panel').find('dl').eq(2).find('button').click();
+      cy.get('#input-order-slippage')
+        .focus()
+        .type('{backspace}{backspace}{backspace}1');
 
-    cy.getByTestId('slippage-dialog').find('button').click();
+      cy.getByTestId('slippage-dialog').find('button').click();
 
-    cy.get('#step-2-panel')
-      .find('dl')
-      .eq(2)
-      .find('dd')
-      .should('have.text', '1%');
+      cy.get('#step-2-panel')
+        .find('dl')
+        .eq(2)
+        .find('dd')
+        .should('have.text', '1%');
+    }
   });
 
   it('notional position size should be present', () => {
-    cy.get('#step-1-control [aria-label^="Selected value"]').click();
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('#step-2-control').click();
-    cy.get('#step-2-panel')
-      .find('dd')
-      .eq(0)
-      .find('button')
-      .should('have.text', '1');
-    cy.get('#step-2-panel').find('dd').eq(0).find('button').click();
-    cy.get('#step-2-panel').find('dd').eq(0).find('input').type('{backspace}2');
-    cy.get('#step-2-panel').find('dd').eq(0).find('button').click();
-    cy.get('#step-2-panel')
-      .find('dt')
-      .eq(2)
-      .should('have.text', 'Est. Position Size (tDAI)');
-    cy.get('#step-2-panel').find('dd').eq(2).should('have.text', '197.86012');
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[1].id}`);
+      connectVegaWallet();
+      cy.get('#step-1-control [aria-label^="Selected value"]').click();
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('#step-2-control').click();
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('button')
+        .should('have.text', '1');
+      cy.get('#step-2-panel').find('dd').eq(0).find('button').click();
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(0)
+        .find('input')
+        .type('{backspace}2');
+      cy.get('#step-2-panel').find('dd').eq(0).find('button').click();
+      cy.get('#step-2-panel')
+        .find('dt')
+        .eq(2)
+        .should('have.text', 'Est. Position Size (tDAI)');
+      cy.get('#step-2-panel').find('dd').eq(2).should('have.text', '197.86012');
+    }
   });
 
   it('total fees should be displayed', () => {
-    cy.get('#step-1-control [aria-label^="Selected value"]').click();
-    cy.get('button[aria-label="Open short position"]').click();
-    cy.get('#step-2-control').click();
-    cy.get('#step-2-panel')
-      .find('dt')
-      .eq(3)
-      .should('have.text', 'Est. Fees (tDAI)');
-    cy.get('#step-2-panel')
-      .find('dd')
-      .eq(3)
-      .should('have.text', '3.00 (3.03%)');
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[1].id}`);
+      connectVegaWallet();
+      cy.get('#step-1-control [aria-label^="Selected value"]').click();
+      cy.get('button[aria-label="Open short position"]').click();
+      cy.get('#step-2-control').click();
+      cy.get('#step-2-panel')
+        .find('dt')
+        .eq(3)
+        .should('have.text', 'Est. Fees (tDAI)');
+      cy.get('#step-2-panel')
+        .find('dd')
+        .eq(3)
+        .should('have.text', '3.00000 (3.03%)');
+    }
   });
 
   it('order review should display proper calculations', () => {
-    cy.get('#step-3-control').click();
+    if (markets?.length) {
+      cy.visit(`/trading/${markets[0].id}`);
+      connectVegaWallet();
+      cy.get('#step-3-control').click();
 
-    cy.getByTestId('review-trade')
-      .get('#contracts_tooltip_trigger')
-      .trigger('click')
-      .realTouch();
+      cy.getByTestId('review-trade')
+        .get('#contracts_tooltip_trigger')
+        .trigger('click')
+        .realTouch();
 
-    cy.get('[data-radix-popper-content-wrapper]').contains(
-      'The number of contracts determines'
-    );
-    cy.get('#step-3-panel').find('dd').eq(1).should('have.text', '1');
+      cy.get('[data-radix-popper-content-wrapper]').contains(
+        'The number of contracts determines'
+      );
+      cy.get('#step-3-panel').find('dd').eq(1).should('have.text', '1');
 
-    cy.get('#step-3-panel').find('dd').eq(2).should('have.text', '98.93006');
+      cy.get('#step-3-panel').find('dd').eq(2).should('have.text', '98.93006');
 
-    cy.get('#step-3-panel')
-      .find('dd')
-      .eq(3)
-      .should('have.text', '3.00 (3.03%)');
+      cy.get('#step-3-panel')
+        .find('dd')
+        .eq(3)
+        .should('have.text', '3.00000 (3.03%)');
 
-    cy.get('#step-3-panel')
-      .find('dd')
-      .eq(4)
-      .should('have.text', '45,126.90058');
+      cy.get('#step-3-panel').find('dd').eq(4).should('have.text', ' - ');
 
-    cy.getByTestId('place-order').should('be.enabled').click();
+      cy.getByTestId('place-order').should('be.enabled').click();
+    }
   });
 
   it('info tooltip on mobile view should work well', () => {
-    cy.viewport('iphone-xr');
-    cy.get('#step-3-control').click();
+    if (markets?.length) {
+      cy.viewport('iphone-xr');
+      cy.visit(`/trading/${markets[0].id}`);
+      connectVegaWallet();
+      cy.get('#step-3-control').click();
 
-    // Start from the bottom tooltip to ensure the tooltip above
-    // can be interacted with
-    cy.getByTestId('review-trade').get('div.cursor-help').eq(1).realTouch();
-    cy.get('[data-radix-popper-content-wrapper]').contains(
-      'The notional size represents the position size'
-    );
+      // Start from the bottom tooltip to ensure the tooltip above
+      // can be interacted with
+      cy.getByTestId('review-trade').get('div.cursor-help').eq(1).realTouch();
+      cy.get('[data-radix-popper-content-wrapper]').contains(
+        'The notional size represents the position size'
+      );
 
-    cy.getByTestId('review-trade')
-      .get('#contracts_tooltip_trigger')
-      .realTouch();
-    cy.get('[data-radix-popper-content-wrapper]').contains(
-      'The number of contracts determines'
-    );
+      cy.getByTestId('review-trade')
+        .get('#contracts_tooltip_trigger')
+        .realTouch();
+      cy.get('[data-radix-popper-content-wrapper]').contains(
+        'The number of contracts determines'
+      );
+    }
   });
 });

apps/console-lite-e2e/src/integration/portfolio-page.test.ts

@@ -1,44 +1,39 @@
-import { aliasGQLQuery } from '@vegaprotocol/cypress';
 import {
-  accountsQuery,
-  assetsQuery,
-  chainIdQuery,
-  fillsQuery,
-  marginsQuery,
-  marketsDataQuery,
-  marketsQuery,
-  ordersQuery,
-  positionsQuery,
-  statisticsQuery,
-} from '@vegaprotocol/mock';
+  connectVegaWallet,
+  disconnectVegaWallet,
+} from '../support/connect-wallet';
+import { aliasQuery } from '@vegaprotocol/cypress';
+import {
+  generatePositions,
+  emptyPositions,
+  generateMargins,
+} from '../support/mocks/generate-positions';
+import { generateAccounts } from '../support/mocks/generate-accounts';
+import { generateAssets } from '../support/mocks/generate-assets';
+import { generateOrders } from '../support/mocks/generate-orders';
+import { generateFills } from '../support/mocks/generate-fills';
+import {
+  generateFillsMarkets,
+  generateMarketsData,
+  generatePositionsMarkets,
+} from '../support/mocks/generate-markets';
+
+describe('Portfolio page', { tags: '@smoke' }, () => {
+  afterEach(() => {
+    disconnectVegaWallet();
+  });
 
-describe('Portfolio page - wallet', { tags: '@smoke' }, () => {
   it('button for wallet connect should work', () => {
     cy.visit('/');
     cy.get('[href="/portfolio"]').eq(0).click();
     cy.getByTestId('trading-connect-wallet').should('be.visible');
-    cy.connectVegaWallet();
+    connectVegaWallet();
     cy.getByTestId('trading-connect-wallet').should('not.exist');
   });
-});
-
-describe('Portfolio page tabs', { tags: '@smoke' }, () => {
-  before(() => {
-    cy.mockGQL((req) => {
-      aliasGQLQuery(req, 'ChainId', chainIdQuery());
-      aliasGQLQuery(req, 'Statistics', statisticsQuery());
-      aliasGQLQuery(req, 'Positions', positionsQuery());
-      aliasGQLQuery(req, 'Margins', marginsQuery());
-      aliasGQLQuery(req, 'Markets', marketsQuery());
-      aliasGQLQuery(req, 'MarketsData', marketsDataQuery());
-      aliasGQLQuery(req, 'Accounts', accountsQuery());
-      aliasGQLQuery(req, 'Assets', assetsQuery());
-    });
-  });
 
   it('certain tabs should exist', () => {
     cy.visit('/portfolio');
-    cy.connectVegaWallet();
+    connectVegaWallet();
 
     cy.getByTestId('assets').click();
     cy.location('pathname').should('eq', '/portfolio/assets');
@@ -57,23 +52,21 @@ describe('Portfolio page tabs', { tags: '@smoke' }, () => {
   });
 
   describe('Assets view', () => {
-    before(() => {
+    beforeEach(() => {
       cy.mockGQL((req) => {
-        aliasGQLQuery(req, 'ChainId', chainIdQuery());
-        aliasGQLQuery(req, 'Statistics', statisticsQuery());
-        aliasGQLQuery(req, 'Positions', positionsQuery());
-        aliasGQLQuery(req, 'Margins', marginsQuery());
-        aliasGQLQuery(req, 'Markets', marketsQuery());
-        aliasGQLQuery(req, 'MarketsData', marketsDataQuery());
-        aliasGQLQuery(req, 'Accounts', accountsQuery());
-        aliasGQLQuery(req, 'Assets', assetsQuery());
+        aliasQuery(req, 'Positions', generatePositions());
+        aliasQuery(req, 'Margins', generateMargins());
+        aliasQuery(req, 'Markets', generatePositionsMarkets());
+        aliasQuery(req, 'MarketsData', generateMarketsData());
+        aliasQuery(req, 'Accounts', generateAccounts());
+        aliasQuery(req, 'Assets', generateAssets());
       });
       cy.visit('/portfolio/assets');
-      cy.connectVegaWallet();
+      connectVegaWallet();
     });
 
     it('data should be properly rendered', () => {
-      cy.get('.ag-center-cols-container .ag-row').should('have.length', 5);
+      cy.get('.ag-center-cols-container .ag-row').should('have.length', 3);
       cy.get(
         '.ag-center-cols-container [row-id="ACCOUNT_TYPE_GENERAL-asset-id-null"]'
       )
@@ -90,34 +83,31 @@ describe('Portfolio page tabs', { tags: '@smoke' }, () => {
   describe('Positions view', () => {
     beforeEach(() => {
       cy.mockGQL((req) => {
-        aliasGQLQuery(req, 'ChainId', chainIdQuery());
-        aliasGQLQuery(req, 'Statistics', statisticsQuery());
-        aliasGQLQuery(req, 'Positions', positionsQuery());
-        aliasGQLQuery(req, 'Margins', marginsQuery());
-        aliasGQLQuery(req, 'Markets', marketsQuery());
-        aliasGQLQuery(req, 'MarketsData', marketsDataQuery());
-        aliasGQLQuery(req, 'Accounts', accountsQuery());
-        aliasGQLQuery(req, 'Assets', assetsQuery());
+        aliasQuery(req, 'Positions', generatePositions());
+        aliasQuery(req, 'Accounts', generateAccounts());
+        aliasQuery(req, 'Margins', generateMargins());
+        aliasQuery(req, 'Markets', generatePositionsMarkets());
+        aliasQuery(req, 'MarketsData', generateMarketsData());
+        aliasQuery(req, 'Assets', generateAssets());
       });
       cy.visit('/portfolio/positions');
-      cy.connectVegaWallet();
+      connectVegaWallet();
     });
 
     it('data should be properly rendered', () => {
-      cy.get('.ag-center-cols-container .ag-row').should('have.length', 2);
+      cy.getByTestId('positions-asset-tDAI').should('exist');
+      cy.getByTestId('positions-asset-tEURO').should('exist');
     });
   });
 
   describe('Orders view', () => {
     beforeEach(() => {
       cy.mockGQL((req) => {
-        aliasGQLQuery(req, 'ChainId', chainIdQuery());
-        aliasGQLQuery(req, 'Statistics', statisticsQuery());
-        aliasGQLQuery(req, 'Orders', ordersQuery());
-        aliasGQLQuery(req, 'Markets', marketsQuery());
+        aliasQuery(req, 'Orders', generateOrders());
+        aliasQuery(req, 'Markets', generateFillsMarkets());
       });
       cy.visit('/portfolio/orders');
-      cy.connectVegaWallet();
+      connectVegaWallet();
     });
 
     it('data should be properly rendered', () => {
@@ -128,14 +118,11 @@ describe('Portfolio page tabs', { tags: '@smoke' }, () => {
   describe('Fills view', () => {
     beforeEach(() => {
       cy.mockGQL((req) => {
-        aliasGQLQuery(req, 'ChainId', chainIdQuery());
-        aliasGQLQuery(req, 'Statistics', statisticsQuery());
-        aliasGQLQuery(req, 'Orders', ordersQuery());
-        aliasGQLQuery(req, 'Markets', marketsQuery());
-        aliasGQLQuery(req, 'Fills', fillsQuery());
+        aliasQuery(req, 'Fills', generateFills());
+        aliasQuery(req, 'Markets', generateFillsMarkets());
       });
       cy.visit('/portfolio/fills');
-      cy.connectVegaWallet();
+      connectVegaWallet();
     });
 
     it('data should be properly rendered', () => {
@@ -146,23 +133,19 @@ describe('Portfolio page tabs', { tags: '@smoke' }, () => {
   describe('Empty views', () => {
     beforeEach(() => {
       cy.mockGQL((req) => {
-        aliasGQLQuery(req, 'ChainId', chainIdQuery());
-        aliasGQLQuery(req, 'Statistics', statisticsQuery());
-        aliasGQLQuery(req, 'Positions', { party: null });
-        aliasGQLQuery(req, 'Accounts', { party: null });
-        aliasGQLQuery(req, 'Orders', { party: null });
-        aliasGQLQuery(req, 'Fills', { party: null });
-        aliasGQLQuery(req, 'Markets', {
+        aliasQuery(req, 'Positions', emptyPositions());
+        aliasQuery(req, 'Accounts', { party: null });
+        aliasQuery(req, 'Orders', { party: null });
+        aliasQuery(req, 'Fills', { party: null });
+        aliasQuery(req, 'Markets', {
           marketsConnection: { edges: [], __typename: 'MarketConnection' },
         });
-        aliasGQLQuery(req, 'Assets', {
+        aliasQuery(req, 'Assets', {
           assetsConnection: { edges: null, __typename: 'AssetsConnection' },
         });
-        aliasGQLQuery(req, 'Margins', marginsQuery());
-        aliasGQLQuery(req, 'MarketsData', marketsDataQuery());
       });
       cy.visit('/portfolio');
-      cy.connectVegaWallet();
+      connectVegaWallet();
     });
 
     it('"No data to display" should be always displayed', () => {

apps/console-lite-e2e/src/support/commands.ts

@@ -0,0 +1,9 @@
+// ***********************************************
+// This example commands.js shows you how to
+// create various custom commands and overwrite
+// existing commands.
+//
+// For more comprehensive examples of custom
+// commands please read more here:
+// https://on.cypress.io/custom-commands
+// ***********************************************

apps/console-lite-e2e/src/support/connect-wallet.ts

@@ -0,0 +1,18 @@
+export const connectVegaWallet = () => {
+  const form = 'rest-connector-form';
+  const walletName = Cypress.env('TRADING_TEST_VEGA_WALLET_NAME');
+  const walletPassphrase = Cypress.env('TRADING_TEST_VEGA_WALLET_PASSPHRASE');
+
+  cy.getByTestId('connect-vega-wallet').click();
+  cy.getByTestId('connectors-list')
+    .find('[data-testid="connector-gui"]')
+    .click();
+  cy.getByTestId(form).find('#wallet').click().type(walletName);
+  cy.getByTestId(form).find('#passphrase').click().type(walletPassphrase);
+  cy.getByTestId('rest-connector-form').find('button[type=submit]').click();
+};
+
+export const disconnectVegaWallet = () => {
+  cy.getByTestId('connect-vega-wallet').click();
+  cy.getByTestId('disconnect').click();
+};

apps/console-lite-e2e/src/support/console-mock.ts

@@ -1,56 +0,0 @@
-import { aliasGQLQuery } from '@vegaprotocol/cypress';
-import type { CyHttpMessages } from 'cypress/types/net-stubbing';
-import {
-  accountsQuery,
-  assetsQuery,
-  chainIdQuery,
-  estimateOrderQuery,
-  fillsQuery,
-  marginsQuery,
-  marketDataQuery,
-  marketDepthQuery,
-  marketQuery,
-  marketsCandlesQuery,
-  marketsDataQuery,
-  marketsQuery,
-  ordersQuery,
-  positionsQuery,
-  statisticsQuery,
-} from '@vegaprotocol/mock';
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace Cypress {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    interface Chainable<Subject> {
-      mockConsole(): void;
-    }
-  }
-}
-
-const mockPage = (req: CyHttpMessages.IncomingHttpRequest) => {
-  aliasGQLQuery(req, 'ChainId', chainIdQuery());
-  aliasGQLQuery(req, 'Statistics', statisticsQuery());
-  aliasGQLQuery(req, 'Markets', marketsQuery());
-  aliasGQLQuery(req, 'MarketsCandles', marketsCandlesQuery());
-  aliasGQLQuery(req, 'MarketsData', marketsDataQuery());
-  aliasGQLQuery(req, 'MarketData', marketDataQuery());
-  aliasGQLQuery(req, 'Market', marketQuery());
-  aliasGQLQuery(req, 'MarketTags', {});
-  aliasGQLQuery(req, 'EstimateOrder', estimateOrderQuery());
-  aliasGQLQuery(req, 'MarketNames', {});
-  aliasGQLQuery(req, 'MarketDepth', marketDepthQuery());
-  aliasGQLQuery(req, 'Positions', positionsQuery());
-  aliasGQLQuery(req, 'Margins', marginsQuery());
-  aliasGQLQuery(req, 'Accounts', accountsQuery());
-  aliasGQLQuery(req, 'Assets', assetsQuery());
-  aliasGQLQuery(req, 'SimpleMarkets', marketsQuery());
-  aliasGQLQuery(req, 'Orders', ordersQuery());
-  aliasGQLQuery(req, 'Fills', fillsQuery());
-};
-
-export const addMockConsole = () => {
-  Cypress.Commands.add('mockConsole', () => {
-    cy.mockGQL(mockPage);
-  });
-};

apps/console-lite-e2e/src/support/index.js

@@ -1,7 +1,34 @@
+// ***********************************************************
+// This example support/index.js is processed and
+// loaded automatically before your test files.
+//
+// This is a great place to put global configuration and
+// behavior that modifies Cypress.
+//
+// You can change the location of this file or turn off
+// automatically serving support files with the
+// 'supportFile' configuration option.
+//
+// You can read more here:
+// https://on.cypress.io/configuration
+// ***********************************************************
+
 import '@vegaprotocol/cypress';
 import 'cypress-real-events/support';
-import registerCypressGrep from '@cypress/grep';
-import { addMockConsole } from './console-mock';
-
+// Import commands.js using ES2015 syntax:
+import './commands';
+import registerCypressGrep from 'cypress-grep';
+import { aliasQuery } from '@vegaprotocol/cypress';
 registerCypressGrep();
-addMockConsole();
+
+before(() => {
+  // Mock chainId fetch which happens on every page for wallet connection
+  cy.mockGQL((req) => {
+    aliasQuery(req, 'ChainId', {
+      statistics: {
+        __typename: 'Statistics',
+        chainId: 'vega-fairground-202210041151',
+      },
+    });
+  });
+});

apps/console-lite-e2e/src/support/mocks/commons.ts

@@ -0,0 +1,147 @@
+import type { Market } from '@vegaprotocol/market-list';
+import { MarketState, MarketTradingMode } from '@vegaprotocol/types';
+import type { SingleMarketFieldsFragment } from '@vegaprotocol/market-list';
+
+export const protoCandles = [
+  { open: '9556163', close: '9587028', __typename: 'Candle' },
+  {
+    open: '9587028',
+    close: '9769899',
+    __typename: 'Candle',
+  },
+  { open: '9769899', close: '9586292', __typename: 'Candle' },
+  {
+    open: '9586292',
+    close: '9261774',
+    __typename: 'Candle',
+  },
+  { open: '9261773', close: '9236369', __typename: 'Candle' },
+  {
+    open: '9236369',
+    close: '9226070',
+    __typename: 'Candle',
+  },
+  { open: '9226077', close: '9233252', __typename: 'Candle' },
+  {
+    open: '9249854',
+    close: '9333038',
+    __typename: 'Candle',
+  },
+  { open: '9333038', close: '9410371', __typename: 'Candle' },
+  {
+    open: '9410371',
+    close: '9626249',
+    __typename: 'Candle',
+  },
+  { open: '9626247', close: '9493253', __typename: 'Candle' },
+  {
+    open: '9493253',
+    close: '9309054',
+    __typename: 'Candle',
+  },
+  { open: '9309054', close: '9378428', __typename: 'Candle' },
+  {
+    open: '9378428',
+    close: '9352996',
+    __typename: 'Candle',
+  },
+  { open: '9352996', close: '9451142', __typename: 'Candle' },
+  {
+    open: '9451142',
+    close: '9691070',
+    __typename: 'Candle',
+  },
+  { open: '9691071', close: '9622031', __typename: 'Candle' },
+  {
+    open: '9622034',
+    close: '9519285',
+    __typename: 'Candle',
+  },
+  { open: '9528904', close: '9671275', __typename: 'Candle' },
+  {
+    open: '9671275',
+    close: '9988454',
+    __typename: 'Candle',
+  },
+  { open: '9982457', close: '10085537', __typename: 'Candle' },
+  {
+    open: '10085537',
+    close: '9967390',
+    __typename: 'Candle',
+  },
+  { open: '9967390', close: '9974844', __typename: 'Candle' },
+  {
+    open: '9974844',
+    close: '9940706',
+    __typename: 'Candle',
+  },
+];
+
+export const protoMarket: Market = {
+  id: 'ca7768f6de84bf86a21bbb6b0109d9659c81917b0e0339b2c262566c9b581a15',
+  tradingMode: MarketTradingMode.TRADING_MODE_CONTINUOUS,
+  state: MarketState.STATE_ACTIVE,
+  decimalPlaces: 5,
+  positionDecimalPlaces: 0,
+  marketTimestamps: {
+    __typename: 'MarketTimestamps',
+    close: '',
+    open: '',
+  },
+  fees: {
+    __typename: 'Fees',
+    factors: {
+      __typename: 'FeeFactors',
+      makerFee: '',
+      infrastructureFee: '',
+      liquidityFee: '',
+    },
+  },
+  tradableInstrument: {
+    instrument: {
+      id: '',
+      code: 'AAVEDAI.MF21',
+      name: 'AAVEDAI Monthly (30 Jun 2022)',
+      metadata: {
+        tags: [
+          'formerly:2839D9B2329C9E70',
+          'base:AAVE',
+          'quote:DAI',
+          'class:fx/crypto',
+          'monthly',
+          'sector:defi',
+        ],
+        __typename: 'InstrumentMetadata',
+      },
+      product: {
+        __typename: 'Future',
+        quoteName: 'DAI',
+        settlementAsset: { symbol: 'tDAI', __typename: 'Asset', decimals: 5 },
+      },
+      __typename: 'Instrument',
+    },
+    __typename: 'TradableInstrument',
+  },
+  __typename: 'Market',
+};
+
+export const singleMarket: SingleMarketFieldsFragment = {
+  ...protoMarket,
+  tradableInstrument: {
+    ...protoMarket.tradableInstrument,
+    instrument: {
+      ...protoMarket.tradableInstrument.instrument,
+      product: {
+        ...protoMarket.tradableInstrument.instrument.product,
+        settlementAsset: {
+          ...protoMarket.tradableInstrument.instrument.product.settlementAsset,
+          id: 'dai-id',
+          name: 'DAI Name',
+        },
+        oracleSpecForTradingTermination: {
+          id: 'oid',
+        },
+      },
+    },
+  },
+};

apps/console-lite-e2e/src/support/mocks/generate-accounts.ts

@@ -0,0 +1,77 @@
+import merge from 'lodash/merge';
+import type { AccountsQuery } from '@vegaprotocol/accounts';
+import { AccountType } from '@vegaprotocol/types';
+import type { PartialDeep } from 'type-fest';
+
+export const generateAccounts = (
+  override?: PartialDeep<AccountsQuery>
+): AccountsQuery => {
+  const defaultAccounts: AccountsQuery = {
+    party: {
+      __typename: 'Party',
+      id: Cypress.env('VEGA_PUBLIC_KEY'),
+      accounts: [
+        {
+          __typename: 'AccountBalance',
+          type: AccountType.ACCOUNT_TYPE_GENERAL,
+          balance: '100000000',
+          market: null,
+          asset: {
+            __typename: 'Asset',
+            id: 'asset-id',
+          },
+        },
+        {
+          __typename: 'AccountBalance',
+          type: AccountType.ACCOUNT_TYPE_GENERAL,
+          balance: '100000000',
+          market: {
+            id: '0604e8c918655474525e1a95367902266ade70d318c2c908f0cca6e3d11dcb13',
+            __typename: 'Market',
+          },
+          asset: {
+            __typename: 'Asset',
+            id: 'asset-id-2',
+          },
+        },
+        {
+          __typename: 'AccountBalance',
+          type: AccountType.ACCOUNT_TYPE_MARGIN,
+          balance: '1000',
+          market: {
+            __typename: 'Market',
+            id: '5a4b0b9e9c0629f0315ec56fcb7bd444b0c6e4da5ec7677719d502626658a376',
+          },
+          asset: {
+            __typename: 'Asset',
+            id: 'asset-id',
+          },
+        },
+        {
+          __typename: 'AccountBalance',
+          type: AccountType.ACCOUNT_TYPE_MARGIN,
+          balance: '1000',
+          market: {
+            __typename: 'Market',
+            id: 'c9f5acd348796011c075077e4d58d9b7f1689b7c1c8e030a5e886b83aa96923d',
+          },
+          asset: {
+            __typename: 'Asset',
+            id: 'asset-id-2',
+          },
+        },
+        {
+          __typename: 'AccountBalance',
+          type: AccountType.ACCOUNT_TYPE_GENERAL,
+          balance: '100000000',
+          market: null,
+          asset: {
+            __typename: 'Asset',
+            id: 'asset-0',
+          },
+        },
+      ],
+    },
+  };
+  return merge(defaultAccounts, override);
+};

apps/console-lite-e2e/src/support/mocks/generate-assets.ts

@@ -0,0 +1,120 @@
+import merge from 'lodash/merge';
+import type { AssetsQuery } from '@vegaprotocol/assets';
+import { Schema as Types } from '@vegaprotocol/types';
+import type { PartialDeep } from 'type-fest';
+
+export const generateAssets = (override?: PartialDeep<AssetsQuery>) => {
+  const defaultAssets: AssetsQuery = {
+    assetsConnection: {
+      edges: [
+        {
+          node: {
+            id: 'asset-id',
+            symbol: 'tEURO',
+            decimals: 5,
+            name: 'Euro',
+            source: {
+              __typename: 'ERC20',
+              contractAddress: '0x0158031158Bb4dF2AD02eAA31e8963E84EA978a4',
+              lifetimeLimit: '1',
+              withdrawThreshold: '2',
+            },
+            quantum: '',
+            status: Types.AssetStatus.STATUS_ENABLED,
+            infrastructureFeeAccount: {
+              balance: '1',
+              __typename: 'AccountBalance',
+            },
+            globalRewardPoolAccount: {
+              balance: '2',
+              __typename: 'AccountBalance',
+            },
+            takerFeeRewardAccount: {
+              balance: '3',
+              __typename: 'AccountBalance',
+            },
+            makerFeeRewardAccount: {
+              balance: '4',
+              __typename: 'AccountBalance',
+            },
+            lpFeeRewardAccount: {
+              balance: '5',
+              __typename: 'AccountBalance',
+            },
+            marketProposerRewardAccount: {
+              balance: '6',
+              __typename: 'AccountBalance',
+            },
+            __typename: 'Asset',
+          },
+        },
+        {
+          node: {
+            id: 'asset-id-2',
+            symbol: 'tDAI',
+            decimals: 5,
+            name: 'DAI',
+            source: {
+              __typename: 'ERC20',
+              contractAddress: '0x0158031158Bb4dF2AD02eAA31e8963E84EA978a4',
+              lifetimeLimit: '1',
+              withdrawThreshold: '2',
+            },
+            quantum: '',
+            status: Types.AssetStatus.STATUS_ENABLED,
+            infrastructureFeeAccount: {
+              balance: '1',
+              __typename: 'AccountBalance',
+            },
+            globalRewardPoolAccount: {
+              balance: '2',
+              __typename: 'AccountBalance',
+            },
+            takerFeeRewardAccount: {
+              balance: '3',
+              __typename: 'AccountBalance',
+            },
+            makerFeeRewardAccount: {
+              balance: '4',
+              __typename: 'AccountBalance',
+            },
+            lpFeeRewardAccount: {
+              balance: '5',
+              __typename: 'AccountBalance',
+            },
+            marketProposerRewardAccount: {
+              balance: '6',
+              __typename: 'AccountBalance',
+            },
+            __typename: 'Asset',
+          },
+        },
+        {
+          node: {
+            id: 'asset-0',
+            symbol: 'AST0',
+            decimals: 5,
+            name: 'Asto',
+            source: {
+              __typename: 'BuiltinAsset',
+              maxFaucetAmountMint: '3',
+            },
+            quantum: '',
+            status: Types.AssetStatus.STATUS_ENABLED,
+            infrastructureFeeAccount: {
+              balance: '0',
+              __typename: 'AccountBalance',
+            },
+            globalRewardPoolAccount: null,
+            takerFeeRewardAccount: null,
+            makerFeeRewardAccount: null,
+            lpFeeRewardAccount: null,
+            marketProposerRewardAccount: null,
+            __typename: 'Asset',
+          },
+        },
+      ],
+    },
+  };
+  return merge(defaultAssets, override);
+};

apps/console-lite-e2e/src/support/mocks/generate-deal-ticket.ts

@@ -0,0 +1,52 @@
+import type { DealTicketQuery } from '@vegaprotocol/deal-ticket';
+import { MarketTradingMode, MarketState } from '@vegaprotocol/types';
+import merge from 'lodash/merge';
+import type { PartialDeep } from 'type-fest';
+
+export const generateDealTicket = (
+  override?: PartialDeep<DealTicketQuery>
+): DealTicketQuery => {
+  const defaultResult: DealTicketQuery = {
+    market: {
+      id: 'ca7768f6de84bf86a21bbb6b0109d9659c81917b0e0339b2c262566c9b581a15',
+      decimalPlaces: 5,
+      positionDecimalPlaces: 0,
+      state: MarketState.STATE_ACTIVE,
+      tradingMode: MarketTradingMode.TRADING_MODE_CONTINUOUS,
+      tradableInstrument: {
+        instrument: {
+          id: 'c9f5acd348796011c075077e4d58d9b7f1689b7c1c8e030a5e886b83aa96923d',
+          name: 'AAVEDAI Monthly (30 Jun 2022)',
+          product: {
+            quoteName: 'DAI',
+            settlementAsset: {
+              id: '6d9d35f657589e40ddfb448b7ad4a7463b66efb307527fedd2aa7df1bbd5ea61',
+              symbol: 'tDAI',
+              name: 'tDAI TEST',
+              decimals: 5,
+              __typename: 'Asset',
+            },
+            __typename: 'Future',
+          },
+          __typename: 'Instrument',
+        },
+        __typename: 'TradableInstrument',
+      },
+      depth: {
+        lastTrade: { price: '9893006', __typename: 'Trade' },
+        __typename: 'MarketDepth',
+      },
+      fees: {
+        factors: {
+          makerFee: '0.0002',
+          infrastructureFee: '0.0005',
+          liquidityFee: '0.001',
+          __typename: 'FeeFactors',
+        },
+        __typename: 'Fees',
+      },
+      __typename: 'Market',
+    },
+  };
+  return merge(defaultResult, override);
+};

apps/console-lite-e2e/src/support/mocks/generate-estimate-order.ts

@@ -0,0 +1,17 @@
+export const generateEstimateOrder = () => {
+  return {
+    estimateOrder: {
+      fee: {
+        __typename: 'TradeFee',
+        makerFee: '100000',
+        liquidityFee: '100000',
+        infrastructureFee: '100000',
+      },
+      marginLevels: {
+        initialLevel: '2844054.80937741220203',
+        __typename: 'MarginLevels',
+      },
+      __typename: 'OrderEstimate',
+    },
+  };
+};

apps/console-lite-e2e/src/support/mocks/generate-fills.ts

@@ -0,0 +1,111 @@
+import type { FillsQuery, FillFieldsFragment } from '@vegaprotocol/fills';
+import { Schema } from '@vegaprotocol/types';
+import merge from 'lodash/merge';
+import type { PartialDeep } from 'type-fest';
+
+export const generateFills = (
+  override?: PartialDeep<FillsQuery>
+): FillsQuery => {
+  const fills: FillFieldsFragment[] = [
+    generateFill({
+      buyer: {
+        id: Cypress.env('VEGA_PUBLIC_KEY'),
+      },
+    }),
+    generateFill({
+      id: '1',
+      seller: {
+        id: Cypress.env('VEGA_PUBLIC_KEY'),
+      },
+      aggressor: Schema.Side.SIDE_SELL,
+      buyerFee: {
+        infrastructureFee: '5000',
+      },
+      market: {
+        id: 'market-1',
+      },
+    }),
+    generateFill({
+      id: '2',
+      seller: {
+        id: Cypress.env('VEGA_PUBLIC_KEY'),
+      },
+      aggressor: Schema.Side.SIDE_BUY,
+    }),
+    generateFill({
+      id: '3',
+      aggressor: Schema.Side.SIDE_SELL,
+      market: {
+        id: 'market-2',
+      },
+      buyer: {
+        id: Cypress.env('VEGA_PUBLIC_KEY'),
+      },
+    }),
+  ];
+
+  const defaultResult: FillsQuery = {
+    party: {
+      id: 'buyer-id',
+      tradesConnection: {
+        __typename: 'TradeConnection',
+        edges: fills.map((f) => {
+          return {
+            __typename: 'TradeEdge',
+            node: f,
+            cursor: '3',
+          };
+        }),
+        pageInfo: {
+          __typename: 'PageInfo',
+          startCursor: '1',
+          endCursor: '2',
+          hasNextPage: false,
+          hasPreviousPage: false,
+        },
+      },
+      __typename: 'Party',
+    },
+  };
+
+  return merge(defaultResult, override);
+};
+
+export const generateFill = (override?: PartialDeep<FillFieldsFragment>) => {
+  const defaultFill: FillFieldsFragment = {
+    __typename: 'Trade',
+    id: '0',
+    createdAt: new Date().toISOString(),
+    price: '10000000',
+    size: '50000',
+    buyOrder: 'buy-order',
+    sellOrder: 'sell-order',
+    aggressor: Schema.Side.SIDE_BUY,
+    buyer: {
+      __typename: 'Party',
+      id: 'buyer-id',
+    },
+    seller: {
+      __typename: 'Party',
+      id: 'seller-id',
+    },
+    buyerFee: {
+      __typename: 'TradeFee',
+      makerFee: '100',
+      infrastructureFee: '100',
+      liquidityFee: '100',
+    },
+    sellerFee: {
+      __typename: 'TradeFee',
+      makerFee: '200',
+      infrastructureFee: '200',
+      liquidityFee: '200',
+    },
+    market: {
+      __typename: 'Market',
+      id: 'market-0',
+    },
+  };
+
+  return merge(defaultFill, override);
+};

apps/console-lite-e2e/src/support/mocks/generate-market-depth.ts

@@ -0,0 +1,210 @@
+import merge from 'lodash/merge';
+import type { PartialDeep } from 'type-fest';
+// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries
+import type { MarketDepthQuery } from '../../../../../libs/market-depth/src/lib/__generated___/MarketDepth';
+
+export const generateMarketDepth = (
+  override?: PartialDeep<MarketDepthQuery>
+): MarketDepthQuery => {
+  const defaultResult: MarketDepthQuery = {
+    market: {
+      id: 'a46bd7e5277087723b7ab835844dec3cef8b4445738101269624bf5537d5d423',
+      depth: {
+        sell: [
+          {
+            price: '9893007',
+            volume: '3',
+            numberOfOrders: '3',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893010',
+            volume: '4',
+            numberOfOrders: '4',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893012',
+            volume: '1',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893015',
+            volume: '1',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893017',
+            volume: '2',
+            numberOfOrders: '2',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893021',
+            volume: '4',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893025',
+            volume: '5',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893125',
+            volume: '4',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893135',
+            volume: '2',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893165',
+            volume: '5',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893175',
+            volume: '3',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893185',
+            volume: '3',
+            numberOfOrders: '3',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9894185',
+            volume: '1',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9894585',
+            volume: '1',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9895585',
+            volume: '4',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9896585',
+            volume: '2',
+            numberOfOrders: '2',
+            __typename: 'PriceLevel',
+          },
+        ],
+        buy: [
+          {
+            price: '9893005',
+            volume: '4',
+            numberOfOrders: '3',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893003',
+            volume: '2',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9893001',
+            volume: '1',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9892006',
+            volume: '3',
+            numberOfOrders: '2',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9891006',
+            volume: '2',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9891001',
+            volume: '1',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890101',
+            volume: '2',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890091',
+            volume: '5',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890081',
+            volume: '4',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890050',
+            volume: '2',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890040',
+            volume: '6',
+            numberOfOrders: '3',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890030',
+            volume: '6',
+            numberOfOrders: '2',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890021',
+            volume: '3',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890011',
+            volume: '1',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+          {
+            price: '9890001',
+            volume: '11',
+            numberOfOrders: '1',
+            __typename: 'PriceLevel',
+          },
+        ],
+        sequenceNumber: '1661773865550746910',
+        __typename: 'MarketDepth',
+      },
+      __typename: 'Market',
+    },
+  };
+  return merge(defaultResult, override);
+};

apps/console-lite-e2e/src/support/mocks/generate-market-mark-price.ts

@@ -0,0 +1,9 @@
+export const generateMarketMarkPrice = () => {
+  return {
+    market: {
+      decimalPlaces: 5,
+      data: { markPrice: '692748', __typename: 'MarketData' },
+      __typename: 'Market',
+    },
+  };
+};

apps/console-lite-e2e/src/support/mocks/generate-market-names.ts

@@ -0,0 +1,136 @@
+import { protoMarket } from './commons';
+
+export const generateMarketNames = () => {
+  return {
+    markets: [
+      { ...protoMarket },
+      {
+        id: '1d7ddf67dac4924db03f5bf58571a7bcb1908d70c66580467717aabc5345b68a',
+        state: 'STATE_SUSPENDED',
+        tradableInstrument: {
+          instrument: {
+            code: 'AAPL.MF21',
+            name: 'Apple Monthly (30 Jun 2022)',
+            metadata: {
+              tags: [
+                'formerly:4899E01009F1A721',
+                'quote:USD',
+                'ticker:AAPL',
+                'class:equities/single-stock-futures',
+                'sector:tech',
+                'listing_venue:NASDAQ',
+                'country:US',
+              ],
+              __typename: 'InstrumentMetadata',
+            },
+            product: { quoteName: 'USD', __typename: 'Future' },
+            __typename: 'Instrument',
+          },
+          __typename: 'TradableInstrument',
+        },
+        __typename: 'Market',
+      },
+      {
+        id: '87ae87cd3244fc1fab4b0e2dad2437879864192bb969f3109b69293421644c8b',
+        state: 'STATE_SUSPENDED',
+        tradableInstrument: {
+          instrument: {
+            code: 'TSLA.QM21',
+            name: 'Tesla Quarterly (30 Jun 2022)',
+            metadata: {
+              tags: [
+                'formerly:5A86B190C384997F',
+                'quote:EURO',
+                'ticker:TSLA',
+                'class:equities/single-stock-futures',
+                'sector:tech',
+                'listing_venue:NASDAQ',
+                'country:US',
+              ],
+              __typename: 'InstrumentMetadata',
+            },
+            product: { quoteName: 'EURO', __typename: 'Future' },
+            __typename: 'Instrument',
+          },
+          __typename: 'TradableInstrument',
+        },
+        __typename: 'Market',
+      },
+      {
+        id: '69205712a854f1bbfb69fa3d11b60e01a1e249bafb5ece88115e7451e8ef07b3',
+        state: 'STATE_SUSPENDED',
+        tradableInstrument: {
+          instrument: {
+            code: 'BTCUSD.MF21',
+            name: 'BTCUSD Monthly (30 Jun 2022)',
+            metadata: {
+              tags: [
+                'formerly:076BB86A5AA41E3E',
+                'base:BTC',
+                'quote:USD',
+                'class:fx/crypto',
+                'monthly',
+                'sector:crypto',
+              ],
+              __typename: 'InstrumentMetadata',
+            },
+            product: { quoteName: 'USD', __typename: 'Future' },
+            __typename: 'Instrument',
+          },
+          __typename: 'TradableInstrument',
+        },
+        __typename: 'Market',
+      },
+      {
+        id: 'ethbtc-quaterly',
+        state: 'STATE_ACTIVE',
+        tradableInstrument: {
+          instrument: {
+            code: 'ETHBTC.QM21',
+            name: 'ETHBTC Quarterly (30 Jun 2022)',
+            metadata: {
+              tags: [
+                'formerly:1F0BB6EB5703B099',
+                'base:ETH',
+                'quote:BTC',
+                'class:fx/crypto',
+                'quarterly',
+                'sector:crypto',
+              ],
+              __typename: 'InstrumentMetadata',
+            },
+            product: { quoteName: 'BTC', __typename: 'Future' },
+            __typename: 'Instrument',
+          },
+          __typename: 'TradableInstrument',
+        },
+        __typename: 'Market',
+      },
+      {
+        id: '3c62b2714c4332d1a689a5352bff090e6aabccfd6bd87ce018936b38372530c9',
+        state: 'STATE_ACTIVE',
+        tradableInstrument: {
+          instrument: {
+            code: 'UNIDAI.MF21',
+            name: 'UNIDAI Monthly (30 Jun 2022)',
+            metadata: {
+              tags: [
+                'formerly:3C58ED2A4A6C5D7E',
+                'base:UNI',
+                'quote:DAI',
+                'class:fx/crypto',
+                'monthly',
+                'sector:defi',
+              ],
+              __typename: 'InstrumentMetadata',
+            },
+            product: { quoteName: 'DAI', __typename: 'Future' },
+            __typename: 'Instrument',
+          },
+          __typename: 'TradableInstrument',
+        },
+        __typename: 'Market',
+      },
+    ],
+  };
+};

apps/console-lite-e2e/src/support/mocks/generate-market-positions.ts

@@ -0,0 +1,59 @@
+export const generateMarketPositions = () => {
+  return {
+    party: {
+      id: '2e1ef32e5804e14232406aebaad719087d326afa5c648b7824d0823d8a46c8d1',
+      accounts: [
+        {
+          type: 'General',
+          asset: {
+            decimals: 5,
+          },
+          balance: '400000000000000000000',
+          market: {
+            id: '2751c508f9759761f912890f37fb3f97a00300bf7685c02a56a86e05facfe221',
+            __typename: 'Market',
+          },
+        },
+        {
+          type: 'Margin',
+          asset: {
+            decimals: 5,
+          },
+          balance: '265329',
+          market: {
+            id: 'ca7768f6de84bf86a21bbb6b0109d9659c81917b0e0339b2c262566c9b581a15',
+            __typename: 'Market',
+          },
+        },
+      ],
+      positionsConnection: {
+        edges: [
+          {
+            node: {
+              openVolume: '3',
+              market: {
+                id: '2751c508f9759761f912890f37fb3f97a00300bf7685c02a56a86e05facfe221',
+                __typename: 'Market',
+              },
+              __typename: 'Position',
+            },
+            __typename: 'PositionEdge',
+          },
+          {
+            node: {
+              openVolume: '12',
+              market: {
+                id: 'ca7768f6de84bf86a21bbb6b0109d9659c81917b0e0339b2c262566c9b581a15',
+                __typename: 'Market',
+              },
+              __typename: 'Position',
+            },
+            __typename: 'PositionEdge',
+          },
+        ],
+        __typename: 'PositionConnection',
+      },
+      __typename: 'Party',
+    },
+  };
+};

apps/console-lite-e2e/src/support/mocks/generate-market-tags.ts

@@ -0,0 +1,25 @@
+export const generateMarketTags = () => {
+  return {
+    market: {
+      tradableInstrument: {
+        instrument: {
+          metadata: {
+            tags: [
+              'formerly:2839D9B2329C9E70',
+              'base:AAVE',
+              'quote:DAI',
+              'class:fx/crypto',
+              'monthly',
+              'sector:defi',
+              'settlement:2022-08-01',
+            ],
+            __typename: 'InstrumentMetadata',
+          },
+          __typename: 'Instrument',
+        },
+        __typename: 'TradableInstrument',
+      },
+      __typename: 'Market',
+    },
+  };
+};

apps/console-lite-e2e/src/support/mocks/generate-orders.ts

@@ -0,0 +1,143 @@
+import merge from 'lodash/merge';
+import type { PartialDeep } from 'type-fest';
+import type { OrdersQuery, OrderFieldsFragment } from '@vegaprotocol/orders';
+import { Schema } from '@vegaprotocol/types';
+
+export const generateOrders = (
+  override?: PartialDeep<OrdersQuery>
+): OrdersQuery => {
+  const orders: OrderFieldsFragment[] = [
+    {
+      __typename: 'Order',
+      id: '066468C06549101DAF7BC51099E1412A0067DC08C246B7D8013C9D0CBF1E8EE7',
+      market: {
+        __typename: 'Market',
+        id: 'market-0',
+      },
+      size: '10',
+      type: Schema.OrderType.TYPE_LIMIT,
+      status: Schema.OrderStatus.STATUS_FILLED,
+      side: Schema.Side.SIDE_BUY,
+      remaining: '0',
+      price: '20000000',
+      timeInForce: Schema.OrderTimeInForce.TIME_IN_FORCE_GTC,
+      createdAt: new Date(2020, 1, 30).toISOString(),
+      updatedAt: null,
+      expiresAt: null,
+      rejectionReason: null,
+      liquidityProvision: null,
+      peggedOrder: null,
+    },
+    {
+      __typename: 'Order',
+      id: '48DB6767E4E4E0F649C5A13ABFADE39F8451C27DA828DAF14B7A1E8E5EBDAD99',
+      market: {
+        __typename: 'Market',
+        id: 'market-1',
+      },
+      size: '1',
+      type: Schema.OrderType.TYPE_LIMIT,
+      status: Schema.OrderStatus.STATUS_FILLED,
+      side: Schema.Side.SIDE_BUY,
+      remaining: '0',
+      price: '100',
+      timeInForce: Schema.OrderTimeInForce.TIME_IN_FORCE_GTC,
+      createdAt: new Date(2020, 1, 29).toISOString(),
+      updatedAt: null,
+      expiresAt: null,
+      rejectionReason: null,
+      liquidityProvision: null,
+      peggedOrder: null,
+    },
+    {
+      __typename: 'Order',
+      id: '4e93702990712c41f6995fcbbd94f60bb372ad12d64dfa7d96d205c49f790336',
+      market: {
+        __typename: 'Market',
+        id: 'market-2',
+      },
+      size: '1',
+      type: Schema.OrderType.TYPE_LIMIT,
+      status: Schema.OrderStatus.STATUS_FILLED,
+      side: Schema.Side.SIDE_BUY,
+      remaining: '0',
+      price: '20000',
+      timeInForce: Schema.OrderTimeInForce.TIME_IN_FORCE_GTC,
+      createdAt: new Date(2020, 1, 28).toISOString(),
+      updatedAt: null,
+      expiresAt: null,
+      rejectionReason: null,
+      liquidityProvision: null,
+      peggedOrder: null,
+    },
+    {
+      __typename: 'Order',
+      id: '94737d2bafafa4bc3b80a56ef084ae52a983b91aa067c31e243c61a0f962a836',
+      market: {
+        __typename: 'Market',
+        id: 'market-3',
+      },
+      size: '1',
+      type: Schema.OrderType.TYPE_LIMIT,
+      status: Schema.OrderStatus.STATUS_ACTIVE,
+      side: Schema.Side.SIDE_BUY,
+      remaining: '0',
+      price: '100000',
+      timeInForce: Schema.OrderTimeInForce.TIME_IN_FORCE_GTC,
+      createdAt: new Date(2020, 1, 27).toISOString(),
+      updatedAt: null,
+      expiresAt: null,
+      rejectionReason: null,
+      liquidityProvision: null,
+      peggedOrder: null,
+    },
+    {
+      __typename: 'Order',
+      id: '94aead3ca92dc932efcb503631b03a410e2a5d4606cae6083e2406dc38e52f78',
+      market: {
+        __typename: 'Market',
+        id: 'market-3',
+      },
+      size: '10',
+      type: Schema.OrderType.TYPE_LIMIT,
+      status: Schema.OrderStatus.STATUS_PARTIALLY_FILLED,
+      side: Schema.Side.SIDE_SELL,
+      remaining: '3',
+      price: '100000',
+      timeInForce: Schema.OrderTimeInForce.TIME_IN_FORCE_GTC,
+      createdAt: new Date(2020, 1, 27).toISOString(),
+      updatedAt: null,
+      expiresAt: null,
+      liquidityProvision: null,
+      peggedOrder: null,
+      rejectionReason: null,
+    },
+  ];
+
+  const defaultResult: OrdersQuery = {
+    party: {
+      id: Cypress.env('VEGA_PUBLIC_KEY'),
+      ordersConnection: {
+        __typename: 'OrderConnection',
+        edges: orders.map((f) => {
+          return {
+            __typename: 'OrderEdge',
+            node: f,
+            cursor: f.id,
+          };
+        }),
+        pageInfo: {
+          __typename: 'PageInfo',
+          startCursor:
+            '066468C06549101DAF7BC51099E1412A0067DC08C246B7D8013C9D0CBF1E8EE7',
+          endCursor:
+            '94737d2bafafa4bc3b80a56ef084ae52a983b91aa067c31e243c61a0f962a836',
+          hasNextPage: false,
+          hasPreviousPage: false,
+        },
+      },
+      __typename: 'Party',
+    },
+  };
+  return merge(defaultResult, override);
+};

apps/console-lite-e2e/src/support/mocks/generate-party-balance.ts

@@ -0,0 +1,66 @@
+import merge from 'lodash/merge';
+import type { PartyBalanceQuery } from '@vegaprotocol/deal-ticket';
+import type { PartialDeep } from 'type-fest';
+import { AccountType } from '@vegaprotocol/types';
+
+export const generatePartyBalance = (
+  override?: PartialDeep<PartyBalanceQuery>
+): PartyBalanceQuery => {
+  const defaultResult: PartyBalanceQuery = {
+    party: {
+      accounts: [
+        {
+          balance: '88474051',
+          type: AccountType.ACCOUNT_TYPE_GENERAL,
+          asset: {
+            id: '6d9d35f657589e40ddfb448b7ad4a7463b66efb307527fedd2aa7df1bbd5ea61',
+            symbol: 'tDAI',
+            name: 'tDAI TEST',
+            decimals: 5,
+            __typename: 'Asset',
+          },
+          __typename: 'AccountBalance',
+        },
+        {
+          balance: '100000000',
+          type: AccountType.ACCOUNT_TYPE_GENERAL,
+          asset: {
+            id: '8b52d4a3a4b0ffe733cddbc2b67be273816cfeb6ca4c8b339bac03ffba08e4e4',
+            symbol: 'tEURO',
+            name: 'tEURO TEST',
+            decimals: 5,
+            __typename: 'Asset',
+          },
+          __typename: 'AccountBalance',
+        },
+        {
+          balance: '3412867',
+          type: AccountType.ACCOUNT_TYPE_GENERAL,
+          asset: {
+            id: '6d9d35f657589e40ddfb448b7ad4a7463b66efb307527fedd2aa7df1bbd5ea61',
+            symbol: 'tDAI',
+            name: 'tDAI TEST',
+            decimals: 5,
+            __typename: 'Asset',
+          },
+          __typename: 'AccountBalance',
+        },
+        {
+          balance: '70007',
+          type: AccountType.ACCOUNT_TYPE_GENERAL,
+          asset: {
+            id: '6d9d35f657589e40ddfb448b7ad4a7463b66efb307527fedd2aa7df1bbd5ea61',
+            symbol: 'tDAI',
+            name: 'tDAI TEST',
+            decimals: 5,
+            __typename: 'Asset',
+          },
+          __typename: 'AccountBalance',
+        },
+      ],
+      __typename: 'Party',
+    },
+  };
+
+  return merge(defaultResult, override);
+};

apps/console-lite-e2e/src/support/mocks/generate-party-market-data.ts

@@ -0,0 +1,19 @@
+export const generatePartyMarketData = () => {
+  return {
+    party: {
+      id: '2e1ef32e5804e14232406aebaad719087d326afa5c648b7824d0823d8a46c8d1',
+      accounts: [
+        {
+          type: 'General',
+          balance: '1200000',
+          asset: { id: 'fBTC', decimals: 5, __typename: 'Asset' },
+          market: null,
+          __typename: 'AccountBalance',
+        },
+      ],
+      marginsConnection: { edges: null, __typename: 'MarginConnection' },
+      positionsConnection: { edges: null, __typename: 'PositionConnection' },
+      __typename: 'Party',
+    },
+  };
+};

apps/console-lite-e2e/src/support/mocks/generate-positions.ts

@@ -0,0 +1,145 @@
+import merge from 'lodash/merge';
+import type { PartialDeep } from 'type-fest';
+import type {
+  PositionsQuery,
+  PositionFieldsFragment,
+  MarginsQuery,
+} from '@vegaprotocol/positions';
+
+export const generatePositions = (
+  override?: PartialDeep<PositionsQuery>
+): PositionsQuery => {
+  const nodes: PositionFieldsFragment[] = [
+    {
+      __typename: 'Position',
+      realisedPNL: '0',
+      openVolume: '6',
+      unrealisedPNL: '895000',
+      averageEntryPrice: '1129935',
+      updatedAt: '2022-07-28T15:09:34.441143Z',
+      market: {
+        id: 'c9f5acd348796011c075077e4d58d9b7f1689b7c1c8e030a5e886b83aa96923d',
+        __typename: 'Market',
+      },
+    },
+    {
+      __typename: 'Position',
+      realisedPNL: '100',
+      openVolume: '20',
+      unrealisedPNL: '895000',
+      averageEntryPrice: '8509338',
+      updatedAt: '2022-07-28T15:09:34.441143Z',
+      market: {
+        id: '0604e8c918655474525e1a95367902266ade70d318c2c908f0cca6e3d11dcb13',
+        __typename: 'Market',
+      },
+    },
+    {
+      realisedPNL: '0',
+      openVolume: '1',
+      unrealisedPNL: '-22519',
+      averageEntryPrice: '84400088',
+      updatedAt: '2022-07-28T14:53:54.725477Z',
+      market: {
+        id: '5a4b0b9e9c0629f0315ec56fcb7bd444b0c6e4da5ec7677719d502626658a376',
+        __typename: 'Market',
+      },
+      __typename: 'Position',
+    },
+  ];
+
+  const defaultResult: PositionsQuery = {
+    party: {
+      __typename: 'Party',
+      id: Cypress.env('VEGA_PUBLIC_KEY'),
+      positionsConnection: {
+        __typename: 'PositionConnection',
+        edges: nodes.map((node) => {
+          return {
+            __typename: 'PositionEdge',
+            node,
+          };
+        }),
+      },
+    },
+  };
+
+  return merge(defaultResult, override);
+};
+
+export const emptyPositions = (): PositionsQuery => {
+  return {
+    party: {
+      id: Cypress.env('VEGA_PUBLIC_KEY'),
+      positionsConnection: { edges: null, __typename: 'PositionConnection' },
+      __typename: 'Party',
+    },
+  };
+};
+
+export const generateMargins = (): MarginsQuery => {
+  return {
+    party: {
+      id: Cypress.env('VEGA_PUBLIC_KEY'),
+      marginsConnection: {
+        edges: [
+          {
+            node: {
+              __typename: 'MarginLevels',
+              maintenanceLevel: '0',
+              searchLevel: '0',
+              initialLevel: '0',
+              collateralReleaseLevel: '0',
+              market: {
+                __typename: 'Market',
+                id: 'c9f5acd348796011c075077e4d58d9b7f1689b7c1c8e030a5e886b83aa96923d',
+              },
+              asset: {
+                __typename: 'Asset',
+                id: 'tDAI-id',
+              },
+            },
+          },
+          {
+            node: {
+              __typename: 'MarginLevels',
+              maintenanceLevel: '0',
+              searchLevel: '0',
+              initialLevel: '0',
+              collateralReleaseLevel: '0',
+              market: {
+                __typename: 'Market',
+                id: '0604e8c918655474525e1a95367902266ade70d318c2c908f0cca6e3d11dcb13',
+              },
+              asset: {
+                __typename: 'Asset',
+                id: 'tDAI-id',
+              },
+            },
+            __typename: 'MarginEdge',
+          },
+          {
+            node: {
+              __typename: 'MarginLevels',
+              maintenanceLevel: '0',
+              searchLevel: '0',
+              initialLevel: '0',
+              collateralReleaseLevel: '0',
+              market: {
+                __typename: 'Market',
+                id: '5a4b0b9e9c0629f0315ec56fcb7bd444b0c6e4da5ec7677719d502626658a376',
+              },
+              asset: {
+                __typename: 'Asset',
+                id: 'tEURO-id',
+              },
+            },
+            __typename: 'MarginEdge',
+          },
+        ],
+        __typename: 'MarginConnection',
+      },
+      __typename: 'Party',
+    },
+  };
+};

apps/console-lite-e2e/tsconfig.json

@@ -7,7 +7,7 @@
     "allowSyntheticDefaultImports": true,
     "outDir": "../../dist/out-tsc",
     "allowJs": true,
-    "types": ["cypress", "node", "cypress-real-events", "@cypress/grep"]
+    "types": ["cypress", "node", "cypress-real-events", "cypress-grep"]
   },
-  "include": ["src/**/*.ts", "src/**/*.js", "./declaration.d.ts", "index.d.ts"]
+  "include": ["src/**/*.ts", "src/**/*.js", "./declaration.d.ts"]
 }

apps/console-lite/.env

@@ -17,9 +17,9 @@ NX_INCOMING_HOOK_BODY=$INCOMING_HOOK_BODY
 NX_URL=$URL
 NX_DEPLOY_URL=$DEPLOY_URL
 NX_DEPLOY_PRIME_URL=$DEPLOY_PRIME_URL
-NX_VEGA_CONFIG_URL="https://static.vega.xyz/assets/stagnet3-network.json"
-NX_VEGA_ENV=STAGNET3
-NX_VEGA_URL="https://api.stagnet3.vega.xyz/graphql"
+NX_VEGA_CONFIG_URL="https://static.vega.xyz/assets/testnet-network.json"
+NX_VEGA_ENV = 'TESTNET'
+NX_VEGA_URL="https://api.n11.testnet.vega.xyz/graphql"
 NX_VEGA_WALLET_URL=http://localhost:1789
 NX_ETHEREUM_PROVIDER_URL=https://sepolia.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8
 NX_ETHERSCAN_URL=https://sepolia.etherscan.io

apps/console-lite/.env.sandbox

@@ -4,4 +4,4 @@ NX_VEGA_ENV=SANDBOX
 NX_VEGA_NETWORKS='{"DEVNET":"https://dev.token.vega.xyz","STAGNET3":"https://stagnet3.token.vega.xyz","STAGNET1":"https://stagnet1.token.vega.xyz","TESTNET":"https://token.fairground.wtf","MAINNET":"https://token.vega.xyz"}'
 NX_VEGA_CONFIG_URL=https://static.vega.xyz/assets/sandbox-network.json
 NX_VEGA_EXPLORER_URL=https://sandbox.explorer.vega.xyz
-NX_VEGA_DOCS_URL=https://docs.vega.xyz/testnet
+NX_VEGA_DOCS_URL=https://docs.vega.xyz/docs/testnet

apps/console-lite/.env.stagnet3

@@ -1,6 +1,6 @@
 # App configuration variables
 NX_VEGA_CONFIG_URL=https://static.vega.xyz/assets/stagnet3-network.json
-NX_VEGA_URL=https://api.stagnet3.vega.xyz/graphql
+NX_VEGA_URL=https://api.n01.stagnet3.vega.xyz/graphql
 NX_VEGA_ENV=STAGNET3
 NX_ETHEREUM_PROVIDER_URL=https://sepolia.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8
 NX_ETHERSCAN_URL=https://sepolia.etherscan.io

apps/console-lite/src/app/app.tsx

@@ -1,5 +1,8 @@
 import { useEffect } from 'react';
 import { useLocation } from 'react-router-dom';
+import { createClient } from './lib/apollo-client';
+import { ThemeContext } from '@vegaprotocol/react-helpers';
+import { useThemeSwitcher } from '@vegaprotocol/react-helpers';
 import { EnvironmentProvider, NetworkLoader } from '@vegaprotocol/environment';
 import {
   VegaConnectDialog,
@@ -13,10 +16,10 @@ import Header from './components/header';
 import { Main } from './components/main';
 import LocalContext from './context/local-context';
 import useLocalValues from './hooks/use-local-values';
-import type { InMemoryCacheConfig } from '@apollo/client';
 
 function App() {
-  const localValues = useLocalValues();
+  const [theme, toggleTheme] = useThemeSwitcher();
+  const localValues = useLocalValues(theme, toggleTheme);
   const {
     vegaWalletDialog,
     menu: { setMenuOpen },
@@ -27,49 +30,27 @@ function App() {
     setMenuOpen(false);
   }, [location, setMenuOpen]);
 
-  const cacheConfig: InMemoryCacheConfig = {
-    typePolicies: {
-      Market: {
-        merge: true,
-      },
-      Party: {
-        merge: true,
-      },
-      Query: {},
-      Account: {
-        keyFields: false,
-        fields: {
-          balanceFormatted: {},
-        },
-      },
-      Node: {
-        keyFields: false,
-      },
-      Instrument: {
-        keyFields: false,
-      },
-    },
-  };
-
   return (
     <EnvironmentProvider>
-      <NetworkLoader cache={cacheConfig}>
-        <VegaWalletProvider>
-          <LocalContext.Provider value={localValues}>
-            <AppLoader>
-              <div className="max-h-full min-h-full dark:bg-lite-black dark:text-neutral-200 bg-white text-neutral-800 grid grid-rows-[min-content,1fr]">
-                <Header />
-                <Main />
-                <VegaConnectDialog connectors={Connectors} />
-                <VegaManageDialog
-                  dialogOpen={vegaWalletDialog.manage}
-                  setDialogOpen={vegaWalletDialog.setManage}
-                />
-              </div>
-            </AppLoader>
-          </LocalContext.Provider>
-        </VegaWalletProvider>
-      </NetworkLoader>
+      <ThemeContext.Provider value={theme}>
+        <NetworkLoader createClient={createClient}>
+          <VegaWalletProvider>
+            <LocalContext.Provider value={localValues}>
+              <AppLoader>
+                <div className="max-h-full min-h-full dark:bg-lite-black dark:text-neutral-200 bg-white text-neutral-800 grid grid-rows-[min-content,1fr]">
+                  <Header />
+                  <Main />
+                  <VegaConnectDialog connectors={Connectors} />
+                  <VegaManageDialog
+                    dialogOpen={vegaWalletDialog.manage}
+                    setDialogOpen={vegaWalletDialog.setManage}
+                  />
+                </div>
+              </AppLoader>
+            </LocalContext.Provider>
+          </VegaWalletProvider>
+        </NetworkLoader>
+      </ThemeContext.Provider>
     </EnvironmentProvider>
   );
 }

apps/console-lite/src/app/components/console-lite-grid/console-lite-grid.tsx

@@ -1,11 +1,14 @@
-import React, { forwardRef, useCallback, useMemo, useRef } from 'react';
+import React, {
+  forwardRef,
+  useCallback,
+  useContext,
+  useMemo,
+  useRef,
+} from 'react';
 import classNames from 'classnames';
 import type { AgGridReact } from 'ag-grid-react';
 import { AgGridDynamic as AgGrid } from '@vegaprotocol/ui-toolkit';
-import {
-  useScreenDimensions,
-  useThemeSwitcher,
-} from '@vegaprotocol/react-helpers';
+import { ThemeContext, useScreenDimensions } from '@vegaprotocol/react-helpers';
 import type {
   GridOptions,
   GetRowIdParams,
@@ -40,7 +43,7 @@ const ConsoleLiteGrid = <T extends { id?: string }>(
 ) => {
   const { isMobile, screenSize } = useScreenDimensions();
   const gridRef = useRef<AgGridReact | null>(null);
-  const { theme } = useThemeSwitcher();
+  const theme = useContext(ThemeContext);
   const handleOnGridReady = useCallback(() => {
     (
       (ref as React.RefObject<AgGridReact>) || gridRef

apps/console-lite/src/app/components/deal-ticket/PartyBalance.graphql

@@ -0,0 +1,14 @@
+query PartyBalanceQuery($partyId: ID!) {
+  party(id: $partyId) {
+    accounts {
+      type
+      balance
+      asset {
+        id
+        symbol
+        name
+        decimals
+      }
+    }
+  }
+}

apps/console-lite/src/app/components/deal-ticket/__generated__/MarketTags.ts

@@ -1,54 +1,51 @@
-import * as Types from '@vegaprotocol/types';
+/* tslint:disable */
+/* eslint-disable */
+// @generated
+// This file was automatically generated and should not be edited.
 
-import { gql } from '@apollo/client';
-import * as Apollo from '@apollo/client';
-const defaultOptions = {} as const;
-export type MarketTagsQueryVariables = Types.Exact<{
-  marketId: Types.Scalars['ID'];
-}>;
+// ====================================================
+// GraphQL query operation: MarketTags
+// ====================================================
 
-
-export type MarketTagsQuery = { __typename?: 'Query', market?: { __typename?: 'Market', tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null } } } } | null };
-
-
-export const MarketTagsDocument = gql`
-    query MarketTags($marketId: ID!) {
-  market(id: $marketId) {
-    tradableInstrument {
-      instrument {
-        metadata {
-          tags
-        }
-      }
-    }
-  }
+export interface MarketTags_market_tradableInstrument_instrument_metadata {
+  __typename: "InstrumentMetadata";
+  /**
+   * An arbitrary list of tags to associated to associate to the Instrument (string list)
+   */
+  tags: string[] | null;
 }
-    `;
 
-/**
- * __useMarketTagsQuery__
- *
- * To run a query within a React component, call `useMarketTagsQuery` and pass it any options that fit your needs.
- * When your component renders, `useMarketTagsQuery` returns an object from Apollo Client that contains loading, error, and data properties
- * you can use to render your UI.
- *
- * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
- *
- * @example
- * const { data, loading, error } = useMarketTagsQuery({
- *   variables: {
- *      marketId: // value for 'marketId'
- *   },
- * });
- */
-export function useMarketTagsQuery(baseOptions: Apollo.QueryHookOptions<MarketTagsQuery, MarketTagsQueryVariables>) {
-        const options = {...defaultOptions, ...baseOptions}
-        return Apollo.useQuery<MarketTagsQuery, MarketTagsQueryVariables>(MarketTagsDocument, options);
-      }
-export function useMarketTagsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MarketTagsQuery, MarketTagsQueryVariables>) {
-          const options = {...defaultOptions, ...baseOptions}
-          return Apollo.useLazyQuery<MarketTagsQuery, MarketTagsQueryVariables>(MarketTagsDocument, options);
-        }
-export type MarketTagsQueryHookResult = ReturnType<typeof useMarketTagsQuery>;
-export type MarketTagsLazyQueryHookResult = ReturnType<typeof useMarketTagsLazyQuery>;
-export type MarketTagsQueryResult = Apollo.QueryResult<MarketTagsQuery, MarketTagsQueryVariables>;
+export interface MarketTags_market_tradableInstrument_instrument {
+  __typename: "Instrument";
+  /**
+   * Metadata for this instrument
+   */
+  metadata: MarketTags_market_tradableInstrument_instrument_metadata;
+}
+
+export interface MarketTags_market_tradableInstrument {
+  __typename: "TradableInstrument";
+  /**
+   * An instance of, or reference to, a fully specified instrument.
+   */
+  instrument: MarketTags_market_tradableInstrument_instrument;
+}
+
+export interface MarketTags_market {
+  __typename: "Market";
+  /**
+   * An instance of, or reference to, a tradable instrument.
+   */
+  tradableInstrument: MarketTags_market_tradableInstrument;
+}
+
+export interface MarketTags {
+  /**
+   * An instrument that is trading on the Vega network
+   */
+  market: MarketTags_market | null;
+}
+
+export interface MarketTagsVariables {
+  marketId: string;
+}

apps/console-lite/src/app/components/deal-ticket/__generated___/MarketTags.ts

@@ -0,0 +1,54 @@
+import { Schema as Types } from '@vegaprotocol/types';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type MarketTagsQueryVariables = Types.Exact<{
+  marketId: Types.Scalars['ID'];
+}>;
+
+
+export type MarketTagsQuery = { __typename?: 'Query', market?: { __typename?: 'Market', tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null } } } } | null };
+
+
+export const MarketTagsDocument = gql`
+    query MarketTags($marketId: ID!) {
+  market(id: $marketId) {
+    tradableInstrument {
+      instrument {
+        metadata {
+          tags
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useMarketTagsQuery__
+ *
+ * To run a query within a React component, call `useMarketTagsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useMarketTagsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useMarketTagsQuery({
+ *   variables: {
+ *      marketId: // value for 'marketId'
+ *   },
+ * });
+ */
+export function useMarketTagsQuery(baseOptions: Apollo.QueryHookOptions<MarketTagsQuery, MarketTagsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<MarketTagsQuery, MarketTagsQueryVariables>(MarketTagsDocument, options);
+      }
+export function useMarketTagsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MarketTagsQuery, MarketTagsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<MarketTagsQuery, MarketTagsQueryVariables>(MarketTagsDocument, options);
+        }
+export type MarketTagsQueryHookResult = ReturnType<typeof useMarketTagsQuery>;
+export type MarketTagsLazyQueryHookResult = ReturnType<typeof useMarketTagsLazyQuery>;
+export type MarketTagsQueryResult = Apollo.QueryResult<MarketTagsQuery, MarketTagsQueryVariables>;

apps/console-lite/src/app/components/deal-ticket/__generated___/PartyBalance.ts

@@ -0,0 +1,57 @@
+import { Schema as Types } from '@vegaprotocol/types';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type PartyBalanceQueryQueryVariables = Types.Exact<{
+  partyId: Types.Scalars['ID'];
+}>;
+
+
+export type PartyBalanceQueryQuery = { __typename?: 'Query', party?: { __typename?: 'Party', accounts?: Array<{ __typename?: 'AccountBalance', type: Types.AccountType, balance: string, asset: { __typename?: 'Asset', id: string, symbol: string, name: string, decimals: number } }> | null } | null };
+
+
+export const PartyBalanceQueryDocument = gql`
+    query PartyBalanceQuery($partyId: ID!) {
+  party(id: $partyId) {
+    accounts {
+      type
+      balance
+      asset {
+        id
+        symbol
+        name
+        decimals
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __usePartyBalanceQueryQuery__
+ *
+ * To run a query within a React component, call `usePartyBalanceQueryQuery` and pass it any options that fit your needs.
+ * When your component renders, `usePartyBalanceQueryQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = usePartyBalanceQueryQuery({
+ *   variables: {
+ *      partyId: // value for 'partyId'
+ *   },
+ * });
+ */
+export function usePartyBalanceQueryQuery(baseOptions: Apollo.QueryHookOptions<PartyBalanceQueryQuery, PartyBalanceQueryQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<PartyBalanceQueryQuery, PartyBalanceQueryQueryVariables>(PartyBalanceQueryDocument, options);
+      }
+export function usePartyBalanceQueryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PartyBalanceQueryQuery, PartyBalanceQueryQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<PartyBalanceQueryQuery, PartyBalanceQueryQueryVariables>(PartyBalanceQueryDocument, options);
+        }
+export type PartyBalanceQueryQueryHookResult = ReturnType<typeof usePartyBalanceQueryQuery>;
+export type PartyBalanceQueryLazyQueryHookResult = ReturnType<typeof usePartyBalanceQueryLazyQuery>;
+export type PartyBalanceQueryQueryResult = Apollo.QueryResult<PartyBalanceQueryQuery, PartyBalanceQueryQueryVariables>;

apps/console-lite/src/app/components/deal-ticket/deal-ticket-balance.spec.tsx

@@ -1,36 +1,38 @@
 import React from 'react';
 import { render } from '@testing-library/react';
-import { MockedProvider } from '@apollo/client/testing';
-import type { MarketDealTicketAsset } from '@vegaprotocol/market-list';
+import type {
+  AccountFragment,
+  DealTicketMarketFragment,
+} from '@vegaprotocol/deal-ticket';
 import { DealTicketBalance } from './deal-ticket-balance';
+import { AccountType } from '@vegaprotocol/types';
 
-jest.mock('@vegaprotocol/wallet', () => ({
-  ...jest.requireActual('@vegaprotocol/wallet'),
-  useVegaWallet: jest.fn().mockReturnValue('wallet-pub-key'),
-}));
+const tDAI: DealTicketMarketFragment['tradableInstrument']['instrument']['product']['settlementAsset'] =
+  {
+    __typename: 'Asset',
+    id: '1',
+    symbol: 'tDAI',
+    name: 'TDAI',
+    decimals: 2,
+  };
 
-const tDAI: MarketDealTicketAsset = {
-  __typename: 'Asset',
-  id: '1',
-  symbol: 'tDAI',
-  name: 'TDAI',
-  decimals: 2,
-};
-
-let mockAccountBalance: {
-  accountBalance: string;
-  accountDecimals: number | null;
-} = { accountBalance: '1000000', accountDecimals: 2 };
-jest.mock('@vegaprotocol/accounts', () => ({
-  ...jest.requireActual('@vegaprotocol/accounts'),
-  useAccountBalance: jest.fn(() => mockAccountBalance),
-}));
+const accounts: AccountFragment[] = [
+  {
+    __typename: 'AccountBalance',
+    type: AccountType.ACCOUNT_TYPE_GENERAL,
+    balance: '1000000',
+    asset: tDAI,
+  },
+];
 
 describe('DealTicketBalance', function () {
   it('should render the balance', () => {
     const { getByText, getByRole } = render(
-      <DealTicketBalance settlementAsset={tDAI} isWalletConnected />,
-      { wrapper: MockedProvider }
+      <DealTicketBalance
+        settlementAsset={tDAI}
+        accounts={accounts}
+        isWalletConnected
+      />
     );
 
     expect(getByRole('complementary')).toHaveAccessibleName('tDAI Balance');
@@ -40,8 +42,11 @@ describe('DealTicketBalance', function () {
 
   it('should prompt to connect wallet', () => {
     const { getByText } = render(
-      <DealTicketBalance settlementAsset={tDAI} isWalletConnected={false} />,
-      { wrapper: MockedProvider }
+      <DealTicketBalance
+        settlementAsset={tDAI}
+        accounts={accounts}
+        isWalletConnected={false}
+      />
     );
 
     expect(
@@ -50,10 +55,12 @@ describe('DealTicketBalance', function () {
   });
 
   it('should display zero balance', () => {
-    mockAccountBalance = { accountBalance: '', accountDecimals: null };
     const { getByText } = render(
-      <DealTicketBalance settlementAsset={tDAI} isWalletConnected={true} />,
-      { wrapper: MockedProvider }
+      <DealTicketBalance
+        settlementAsset={tDAI}
+        accounts={[]}
+        isWalletConnected={true}
+      />
     );
 
     expect(getByText('No tDAI left to trade')).toBeInTheDocument();

apps/console-lite/src/app/components/deal-ticket/deal-ticket-balance.tsx

@@ -1,38 +1,43 @@
 import classNames from 'classnames';
-import {
-  addDecimalsFormatNumber,
-  t,
-  toBigNum,
-} from '@vegaprotocol/react-helpers';
-import type { MarketDealTicket } from '@vegaprotocol/market-list';
-import { useAccountBalance } from '@vegaprotocol/accounts';
+import { addDecimalsFormatNumber, t } from '@vegaprotocol/react-helpers';
+import { AccountType } from '@vegaprotocol/types';
+import type {
+  AccountFragment,
+  DealTicketMarketFragment,
+} from '@vegaprotocol/deal-ticket';
+import { useSettlementAccount } from '@vegaprotocol/deal-ticket';
 
 interface DealTicketBalanceProps {
-  settlementAsset: MarketDealTicket['tradableInstrument']['instrument']['product']['settlementAsset'];
+  settlementAsset: DealTicketMarketFragment['tradableInstrument']['instrument']['product']['settlementAsset'];
+  accounts: AccountFragment[];
   isWalletConnected: boolean;
   className?: string;
 }
 
 export const DealTicketBalance = ({
   settlementAsset,
+  accounts,
   isWalletConnected,
   className = '',
 }: DealTicketBalanceProps) => {
   const settlementAssetId = settlementAsset?.id;
   const settlementAssetSymbol = settlementAsset?.symbol;
-
-  const { accountBalance, accountDecimals } =
-    useAccountBalance(settlementAssetId) || {};
-  const settlementBalance = toBigNum(accountBalance || 0, accountDecimals || 0);
-
+  const settlementAccount = useSettlementAccount(
+    settlementAssetId,
+    accounts,
+    AccountType.ACCOUNT_TYPE_GENERAL
+  );
   const formattedNumber =
-    accountBalance &&
-    accountDecimals &&
-    addDecimalsFormatNumber(accountBalance, accountDecimals);
+    settlementAccount?.balance &&
+    settlementAccount.asset.decimals &&
+    addDecimalsFormatNumber(
+      settlementAccount.balance,
+      settlementAccount.asset.decimals
+    );
 
   const balance = (
     <p className="text-blue text-lg font-semibold">
-      {!settlementBalance.isZero()
+      {settlementAccount
         ? t(`${formattedNumber}`)
         : `No ${settlementAssetSymbol} left to trade`}
     </p>

apps/console-lite/src/app/components/deal-ticket/deal-ticket-container.tsx

@@ -1,18 +1,16 @@
 import { useParams } from 'react-router-dom';
-import { DealTicketManager } from '@vegaprotocol/deal-ticket';
-import { Loader, Splash } from '@vegaprotocol/ui-toolkit';
-import { t, useDataProvider } from '@vegaprotocol/react-helpers';
+import {
+  DealTicketManager,
+  DealTicketContainer as Container,
+  usePartyBalanceQuery,
+} from '@vegaprotocol/deal-ticket';
+import { Loader } from '@vegaprotocol/ui-toolkit';
+import { t } from '@vegaprotocol/react-helpers';
 import { useVegaWallet } from '@vegaprotocol/wallet';
 import { DealTicketSteps } from './deal-ticket-steps';
 import { DealTicketBalance } from './deal-ticket-balance';
 import Baubles from './baubles-decor';
 import ConnectWallet from '../wallet-connector';
-import { useMemo } from 'react';
-import type {
-  MarketDataUpdateFieldsFragment,
-  MarketDealTicket,
-} from '@vegaprotocol/market-list';
-import { marketDealTicketProvider } from '@vegaprotocol/market-list';
 
 const tempEmptyText = (
   <p>{t('Please select a market from the markets page')}</p>
@@ -22,54 +20,49 @@ export const DealTicketContainer = () => {
   const { marketId } = useParams<{ marketId: string }>();
   const { pubKey } = useVegaWallet();
 
-  const variables = useMemo(
-    () => ({
-      marketId: marketId || '',
-    }),
-    [marketId]
-  );
-  const { data, loading } = useDataProvider<
-    MarketDealTicket,
-    MarketDataUpdateFieldsFragment
-  >({
-    dataProvider: marketDealTicketProvider,
-    variables,
-    skip: !marketId,
+  const { data: partyData, loading } = usePartyBalanceQuery({
+    variables: { partyId: pubKey || '' },
+    skip: !pubKey,
   });
 
   const loader = <Loader />;
-  if (marketId && data) {
-    const balance = (
-      <DealTicketBalance
-        className="mb-4"
-        settlementAsset={
-          data.tradableInstrument.instrument.product?.settlementAsset
+
+  const container = marketId ? (
+    <Container marketId={marketId}>
+      {(data) => {
+        if (!data.market) {
+          return null as unknown as JSX.Element;
         }
-        isWalletConnected={!!pubKey}
-      />
-    );
 
-    const container = (
-      <DealTicketManager market={data}>
-        {loading ? loader : balance}
-        <DealTicketSteps market={data} />
-      </DealTicketManager>
-    );
+        const balance = (
+          <DealTicketBalance
+            className="mb-4"
+            settlementAsset={
+              data.market.tradableInstrument.instrument.product?.settlementAsset
+            }
+            accounts={partyData?.party?.accounts || []}
+            isWalletConnected={!!pubKey}
+          />
+        );
 
-    return (
-      <section className="flex p-4 md:p-6">
-        <section className="w-full md:w-1/2 md:min-w-[500px]">
-          {pubKey ? container : <ConnectWallet />}
-        </section>
-        <Baubles />
-      </section>
-    );
-  }
-  return marketId ? (
-    <Splash>
-      <p>{t('Could not load market')}</p>
-    </Splash>
+        return (
+          <DealTicketManager market={data.market}>
+            {loading ? loader : balance}
+            <DealTicketSteps market={data.market} />
+          </DealTicketManager>
+        );
+      }}
+    </Container>
   ) : (
     tempEmptyText
   );
+
+  return (
+    <section className="flex p-4 md:p-6">
+      <section className="w-full md:w-1/2 md:min-w-[500px]">
+        {pubKey ? container : <ConnectWallet />}
+      </section>
+      <Baubles />
+    </section>
+  );
 };

apps/console-lite/src/app/components/deal-ticket/deal-ticket-slippage.tsx

@@ -11,8 +11,8 @@ import { InputSetter } from '../../components/input-setter';
 import { IconNames } from '@blueprintjs/icons';
 import {
   DataTitle,
-  ValueTooltipRow,
   EST_SLIPPAGE,
+  ValueTooltipRow,
 } from '@vegaprotocol/deal-ticket';
 
 interface DealTicketSlippageProps {

apps/console-lite/src/app/components/deal-ticket/deal-ticket-steps.tsx

@@ -2,13 +2,18 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useNavigate } from 'react-router-dom';
 import { useForm, Controller } from 'react-hook-form';
 import { Stepper } from '../stepper';
+import type { DealTicketMarketFragment } from '@vegaprotocol/deal-ticket';
 import {
-  getDefaultOrder,
   useOrderCloseOut,
   useOrderMargin,
+  usePartyBalanceQuery,
   useMaximumPositionSize,
   useCalculateSlippage,
-  validateAmount,
+} from '@vegaprotocol/deal-ticket';
+import {
+  getDefaultOrder,
+  useOrderValidation,
+  validateSize,
 } from '@vegaprotocol/deal-ticket';
 import { InputError } from '@vegaprotocol/ui-toolkit';
 import { BigNumber } from 'bignumber.js';
@@ -21,8 +26,6 @@ import {
   toDecimal,
   removeDecimal,
   addDecimalsFormatNumber,
-  addDecimal,
-  formatNumber,
 } from '@vegaprotocol/react-helpers';
 import {
   useOrderSubmit,
@@ -35,13 +38,11 @@ import { DealTicketSize } from './deal-ticket-size';
 import MarketNameRenderer from '../simple-market-list/simple-market-renderer';
 import SideSelector, { SIDE_NAMES } from './side-selector';
 import ReviewTrade from './review-trade';
-import * as Schema from '@vegaprotocol/types';
+import { Schema } from '@vegaprotocol/types';
 import { DealTicketSlippage } from './deal-ticket-slippage';
-import { useOrderValidation } from './use-order-validation';
-import type { MarketDealTicket } from '@vegaprotocol/market-list';
 
 interface DealTicketMarketProps {
-  market: MarketDealTicket;
+  market: DealTicketMarketFragment;
 }
 
 export const DealTicketSteps = ({ market }: DealTicketMarketProps) => {
@@ -67,15 +68,28 @@ export const DealTicketSteps = ({ market }: DealTicketMarketProps) => {
   const emptyString = ' - ';
   const step = toDecimal(market.positionDecimalPlaces);
   const order = watch();
-  const { pubKey } = useVegaWallet();
   const { message: invalidText, isDisabled } = useOrderValidation({
     market,
-    order,
+    orderType: order.type,
+    orderTimeInForce: order.timeInForce,
     fieldErrors: errors,
   });
   const { submit, transaction, finalizedOrder, Dialog } = useOrderSubmit();
+  const { pubKey } = useVegaWallet();
+  const estMargin = useOrderMargin({
+    order,
+    market,
+    partyId: pubKey || '',
+  });
+
+  const { data: partyBalance } = usePartyBalanceQuery({
+    variables: { partyId: pubKey || '' },
+    skip: !pubKey,
+  });
 
   const maxTrade = useMaximumPositionSize({
+    partyId: pubKey || '',
+    accounts: partyBalance?.party?.accounts || [],
     marketId: market.id,
     settlementAssetId:
       market.tradableInstrument.instrument.product.settlementAsset.id,
@@ -86,6 +100,7 @@ export const DealTicketSteps = ({ market }: DealTicketMarketProps) => {
   const estCloseOut = useOrderCloseOut({
     order,
     market,
+    partyData: partyBalance,
   });
   const slippage = useCalculateSlippage({ marketId: market.id, order });
   const [slippageValue, setSlippageValue] = useState(
@@ -109,18 +124,11 @@ export const DealTicketSteps = ({ market }: DealTicketMarketProps) => {
       );
       return new BigNumber(market?.depth?.lastTrade?.price)
         .multipliedBy(multiplier)
-        .toString();
+        .toNumber();
     }
-    return undefined;
+    return null;
   }, [market?.depth?.lastTrade?.price, order.side, slippage]);
 
-  const estMargin = useOrderMargin({
-    order,
-    market,
-    partyId: pubKey || '',
-    derivedPrice: price,
-  });
-
   const formattedPrice =
     price && addDecimalsFormatNumber(price, market.decimalPlaces);
 
@@ -133,9 +141,6 @@ export const DealTicketSteps = ({ market }: DealTicketMarketProps) => {
     return null;
   }, [market.decimalPlaces, order.size, price]);
 
-  const assetDecimals =
-    market.tradableInstrument.instrument.product.settlementAsset.decimals;
-
   const fees = useMemo(() => {
     if (estMargin?.totalFees && notionalSize) {
       const percentage = new BigNumber(estMargin?.totalFees)
@@ -144,14 +149,11 @@ export const DealTicketSteps = ({ market }: DealTicketMarketProps) => {
         .decimalPlaces(2)
         .toString();
 
-      return `${addDecimalsFormatNumber(
-        estMargin.totalFees,
-        assetDecimals
-      )} (${formatNumber(addDecimal(percentage, assetDecimals), 2)}%)`;
+      return `${estMargin.totalFees} (${percentage}%)`;
     }
 
     return null;
-  }, [assetDecimals, estMargin?.totalFees, notionalSize]);
+  }, [estMargin?.totalFees, notionalSize]);
 
   const max = useMemo(() => {
     return new BigNumber(maxTrade)
@@ -168,7 +170,7 @@ export const DealTicketSteps = ({ market }: DealTicketMarketProps) => {
       const newVal = new BigNumber(value)
         .decimalPlaces(market.positionDecimalPlaces)
         .toString();
-      const isValid = validateAmount(step, 'Size')(newVal);
+      const isValid = validateSize(step)(newVal);
       if (isValid !== 'step') {
         setValue('size', newVal);
       }

apps/console-lite/src/app/components/deal-ticket/review-trade.tsx

@@ -5,16 +5,34 @@ import {
   KeyValueTableRow,
 } from '@vegaprotocol/ui-toolkit';
 import classNames from 'classnames';
+import type { DealTicketMarketFragment } from '@vegaprotocol/deal-ticket';
 import { DealTicketEstimates } from '@vegaprotocol/deal-ticket';
 import type { OrderSubmissionBody } from '@vegaprotocol/wallet';
 import { SIDE_NAMES } from './side-selector';
-import * as Schema from '@vegaprotocol/types';
+import { gql, useQuery } from '@apollo/client';
+import type {
+  MarketTags,
+  MarketTagsVariables,
+} from './__generated__/MarketTags';
+import { Schema } from '@vegaprotocol/types';
 import { MarketExpires } from '@vegaprotocol/market-info';
-import type { MarketDealTicket } from '@vegaprotocol/market-list';
-import { useMarketTagsQuery } from './__generated__/MarketTags';
+
+export const MARKET_TAGS_QUERY = gql`
+  query MarketTags($marketId: ID!) {
+    market(id: $marketId) {
+      tradableInstrument {
+        instrument {
+          metadata {
+            tags
+          }
+        }
+      }
+    }
+  }
+`;
 
 interface Props {
-  market: MarketDealTicket;
+  market: DealTicketMarketFragment;
   isDisabled: boolean;
   transactionStatus?: string;
   order: OrderSubmissionBody['orderSubmission'];
@@ -39,9 +57,12 @@ export default ({
   notionalSize,
   slippage,
 }: Props) => {
-  const { data: tagsData } = useMarketTagsQuery({
-    variables: { marketId: market.id },
-  });
+  const { data: tagsData } = useQuery<MarketTags, MarketTagsVariables>(
+    MARKET_TAGS_QUERY,
+    {
+      variables: { marketId: market.id },
+    }
+  );
 
   return (
     <div className="mb-8 text-black dark:text-white" data-testid="review-trade">

apps/console-lite/src/app/components/deal-ticket/side-selector.tsx

@@ -2,7 +2,7 @@ import React from 'react';
 import classNames from 'classnames';
 import { FormGroup } from '@vegaprotocol/ui-toolkit';
 import { t } from '@vegaprotocol/react-helpers';
-import * as Schema from '@vegaprotocol/types';
+import { Schema } from '@vegaprotocol/types';
 
 interface SideSelectorProps {
   value: Schema.Side;

apps/console-lite/src/app/components/deal-ticket/use-order-validation.spec.tsx

@@ -1,415 +0,0 @@
-import * as React from 'react';
-import { renderHook } from '@testing-library/react';
-import { useVegaWallet } from '@vegaprotocol/wallet';
-import { MockedProvider } from '@apollo/client/testing';
-import type { VegaWalletContextShape } from '@vegaprotocol/wallet';
-import * as Schema from '@vegaprotocol/types';
-import type { ValidationProps } from './use-order-validation';
-import { marketTranslations, useOrderValidation } from './use-order-validation';
-import type { MarketDealTicket } from '@vegaprotocol/market-list';
-import * as DealTicket from '@vegaprotocol/deal-ticket';
-
-jest.mock('@vegaprotocol/wallet');
-jest.mock('@vegaprotocol/deal-ticket', () => {
-  return {
-    ...jest.requireActual('@vegaprotocol/deal-ticket'),
-    useOrderMarginValidation: jest.fn(),
-  };
-});
-
-type SettlementAsset =
-  MarketDealTicket['tradableInstrument']['instrument']['product']['settlementAsset'];
-const asset: SettlementAsset = {
-  __typename: 'Asset',
-  id: 'asset-id',
-  symbol: 'asset-symbol',
-  name: 'asset-name',
-  decimals: 2,
-};
-
-const market: MarketDealTicket = {
-  id: 'market-id',
-  decimalPlaces: 2,
-  positionDecimalPlaces: 1,
-  tradingMode: Schema.MarketTradingMode.TRADING_MODE_CONTINUOUS,
-  state: Schema.MarketState.STATE_ACTIVE,
-  tradableInstrument: {
-    __typename: 'TradableInstrument',
-    instrument: {
-      __typename: 'Instrument',
-      id: 'instrument-id',
-      name: 'instrument-name',
-      code: 'instriment-code',
-      metadata: {
-        tags: [],
-      },
-      product: {
-        __typename: 'Future',
-        quoteName: 'quote-name',
-        settlementAsset: asset,
-        dataSourceSpecForTradingTermination: {
-          id: 'dataSource-id',
-        },
-      },
-    },
-  },
-  depth: {
-    __typename: 'MarketDepth',
-    lastTrade: {
-      __typename: 'Trade',
-      price: '100',
-    },
-  },
-  fees: {
-    __typename: 'Fees',
-    factors: {
-      __typename: 'FeeFactors',
-      makerFee: '1',
-      infrastructureFee: '2',
-      liquidityFee: '3',
-    },
-  },
-  data: {
-    __typename: 'MarketData',
-    bestBidPrice: '1605489971',
-    bestOfferPrice: '1606823730',
-    markPrice: '1606823730',
-    trigger: Schema.AuctionTrigger.AUCTION_TRIGGER_UNSPECIFIED,
-    staticMidPrice: '1606156850',
-    marketTradingMode: Schema.MarketTradingMode.TRADING_MODE_CONTINUOUS,
-    marketState: Schema.MarketState.STATE_ACTIVE,
-    indicativeVolume: '0',
-    indicativePrice: '0',
-    bestStaticBidPrice: '1605489971',
-    bestStaticOfferPrice: '1606823730',
-    targetStake: '8561302732',
-    suppliedStake: '727654170336',
-    auctionStart: null,
-    auctionEnd: null,
-    market: { __typename: 'Market', id: 'market-id' },
-  },
-  marketTimestamps: {
-    __typename: 'MarketTimestamps',
-    close: null,
-    open: null,
-  },
-};
-
-const defaultWalletContext = {
-  pubKey: '111111__111111',
-  pubKeys: [],
-  sendTx: jest.fn().mockReturnValue(Promise.resolve(null)),
-  connect: jest.fn(),
-  disconnect: jest.fn(),
-  selectPubKey: jest.fn(),
-  connector: null,
-};
-
-const order = {
-  type: Schema.OrderType.TYPE_MARKET,
-  timeInForce: Schema.OrderTimeInForce.TIME_IN_FORCE_FOK,
-  marketId: 'market-id',
-  side: Schema.Side.SIDE_BUY,
-  size: '0.1',
-};
-
-const defaultOrder = {
-  market: { ...market },
-  step: 0.1,
-  order: {
-    ...order,
-  },
-};
-
-const ERROR = {
-  KEY_MISSING: 'No public key selected',
-  KEY_TAINTED: 'Selected public key has been tainted',
-  MARKET_SUSPENDED: 'Market is currently suspended',
-  MARKET_INACTIVE: 'Market is no longer active',
-  MARKET_WAITING: 'Market is not active yet',
-  MARKET_CONTINUOUS_LIMIT:
-    'Only limit orders are permitted when market is in auction',
-  MARKET_CONTINUOUS_TIF:
-    'Until the auction ends, you can only place GFA, GTT, or GTC limit orders',
-  FIELD_SIZE_REQ: 'You need to provide a size',
-  FIELD_SIZE_MIN: `Size cannot be lower than "${defaultOrder.step}"`,
-  FIELD_PRICE_REQ: 'You need to provide a price',
-  FIELD_PRICE_MIN: 'The price cannot be negative',
-  FIELD_PRICE_STEP_NULL: 'Order sizes must be in whole numbers for this market',
-  FIELD_PRICE_STEP_DECIMAL: `The size field accepts up to ${market.positionDecimalPlaces} decimal places`,
-};
-
-function setup(
-  props?: Partial<ValidationProps>,
-  context?: Partial<VegaWalletContextShape>
-) {
-  const mockUseVegaWallet = useVegaWallet as jest.Mock;
-  mockUseVegaWallet.mockReturnValue({ ...defaultWalletContext, context });
-  return renderHook(() => useOrderValidation({ ...defaultOrder, ...props }), {
-    wrapper: MockedProvider,
-  });
-}
-
-describe('useOrderValidation', () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('Returns empty string when given valid data', () => {
-    jest.spyOn(DealTicket, 'useOrderMarginValidation').mockReturnValue({
-      balance: '0',
-      margin: '100',
-      balanceError: false,
-    });
-
-    const { result } = setup();
-    expect(result.current).toStrictEqual({
-      isDisabled: false,
-      message: ``,
-      section: '',
-    });
-  });
-
-  it('Returns an error message when no keypair found', () => {
-    jest.spyOn(DealTicket, 'useOrderMarginValidation').mockReturnValue({
-      balance: '0',
-      margin: '100',
-      balanceError: false,
-    });
-    const { result } = setup(defaultOrder, { pubKey: null });
-    expect(result.current).toStrictEqual({
-      isDisabled: false,
-      message: ``,
-      section: '',
-    });
-  });
-
-  it.each`
-    state
-    ${Schema.MarketState.STATE_SETTLED}
-    ${Schema.MarketState.STATE_REJECTED}
-    ${Schema.MarketState.STATE_TRADING_TERMINATED}
-    ${Schema.MarketState.STATE_CLOSED}
-    ${Schema.MarketState.STATE_CANCELLED}
-  `(
-    'Returns an error message for market state when not accepting orders',
-    ({ state }) => {
-      const market = {
-        ...defaultOrder.market,
-        data: { ...defaultOrder.market.data, marketState: state },
-      };
-      const { result } = setup({ market });
-      expect(result.current).toStrictEqual({
-        isDisabled: true,
-        message: `This market is ${marketTranslations(
-          state
-        )} and not accepting orders`,
-        section: 'sec-summary',
-      });
-    }
-  );
-
-  it.each`
-    state
-    ${Schema.MarketState.STATE_PENDING}
-    ${Schema.MarketState.STATE_PROPOSED}
-  `(
-    'Returns an error message for market state suspended or pending',
-    ({ state }) => {
-      jest.spyOn(DealTicket, 'useOrderMarginValidation').mockReturnValue({
-        balance: '0',
-        margin: '100',
-        balanceError: false,
-      });
-
-      const market = {
-        ...defaultOrder.market,
-        data: {
-          ...defaultOrder.market.data,
-          marketState: state,
-          marketTradingMode:
-            Schema.MarketTradingMode.TRADING_MODE_BATCH_AUCTION,
-        },
-      };
-      const { result } = setup({
-        market,
-        order: {
-          ...order,
-          type: Schema.OrderType.TYPE_LIMIT,
-          timeInForce: Schema.OrderTimeInForce.TIME_IN_FORCE_GTT,
-        },
-      });
-      expect(result.current).toStrictEqual({
-        isDisabled: false,
-        message: `This market is ${Schema.MarketStateMapping[
-          state as Schema.MarketState
-        ].toLowerCase()} and only accepting liquidity commitment orders`,
-        section: 'sec-summary',
-      });
-    }
-  );
-
-  it.each`
-    tradingMode                                                 | errorMessage
-    ${Schema.MarketTradingMode.TRADING_MODE_BATCH_AUCTION}      | ${ERROR.MARKET_CONTINUOUS_LIMIT}
-    ${Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION} | ${ERROR.MARKET_CONTINUOUS_LIMIT}
-    ${Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION}    | ${ERROR.MARKET_CONTINUOUS_LIMIT}
-  `(
-    `Returns an error message when trying to submit a non-limit order for a "$tradingMode" market`,
-    ({ tradingMode, errorMessage }) => {
-      const market = {
-        ...defaultOrder.market,
-        data: { ...defaultOrder.market.data, marketTradingMode: tradingMode },
-      };
-      const { result } = setup({
-        market,
-        order: {
-          ...order,
-          type: Schema.OrderType.TYPE_MARKET,
-        },
-      });
-      expect(result.current.isDisabled).toBeTruthy();
-      expect(result.current.message).toBe(errorMessage);
-    }
-  );
-
-  it.each`
-    tradingMode                                                 | orderTimeInForce                             | errorMessage
-    ${Schema.MarketTradingMode.TRADING_MODE_BATCH_AUCTION}      | ${Schema.OrderTimeInForce.TIME_IN_FORCE_FOK} | ${ERROR.MARKET_CONTINUOUS_TIF}
-    ${Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION} | ${Schema.OrderTimeInForce.TIME_IN_FORCE_FOK} | ${ERROR.MARKET_CONTINUOUS_TIF}
-    ${Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION}    | ${Schema.OrderTimeInForce.TIME_IN_FORCE_FOK} | ${ERROR.MARKET_CONTINUOUS_TIF}
-    ${Schema.MarketTradingMode.TRADING_MODE_BATCH_AUCTION}      | ${Schema.OrderTimeInForce.TIME_IN_FORCE_IOC} | ${ERROR.MARKET_CONTINUOUS_TIF}
-    ${Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION} | ${Schema.OrderTimeInForce.TIME_IN_FORCE_IOC} | ${ERROR.MARKET_CONTINUOUS_TIF}
-    ${Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION}    | ${Schema.OrderTimeInForce.TIME_IN_FORCE_IOC} | ${ERROR.MARKET_CONTINUOUS_TIF}
-    ${Schema.MarketTradingMode.TRADING_MODE_BATCH_AUCTION}      | ${Schema.OrderTimeInForce.TIME_IN_FORCE_GFN} | ${ERROR.MARKET_CONTINUOUS_TIF}
-    ${Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION} | ${Schema.OrderTimeInForce.TIME_IN_FORCE_GFN} | ${ERROR.MARKET_CONTINUOUS_TIF}
-    ${Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION}    | ${Schema.OrderTimeInForce.TIME_IN_FORCE_GFN} | ${ERROR.MARKET_CONTINUOUS_TIF}
-  `(
-    `Returns an error message when submitting a limit order with a "$orderTimeInForce" value to a "$tradingMode" market`,
-    ({ tradingMode, orderTimeInForce, errorMessage }) => {
-      const market = {
-        ...defaultOrder.market,
-        data: { ...defaultOrder.market.data, marketTradingMode: tradingMode },
-      };
-      const { result } = setup({
-        market,
-        order: {
-          ...order,
-          type: Schema.OrderType.TYPE_LIMIT,
-          timeInForce: orderTimeInForce,
-        },
-      });
-      expect(result.current).toStrictEqual({
-        isDisabled: true,
-        message: errorMessage,
-        section: 'sec-force',
-      });
-    }
-  );
-
-  it.each`
-    fieldName  | errorType     | section        | errorMessage
-    ${`size`}  | ${`required`} | ${'sec-size'}  | ${ERROR.FIELD_SIZE_REQ}
-    ${`size`}  | ${`min`}      | ${'sec-size'}  | ${ERROR.FIELD_SIZE_MIN}
-    ${`price`} | ${`required`} | ${'sec-price'} | ${ERROR.FIELD_PRICE_REQ}
-    ${`price`} | ${`min`}      | ${'sec-price'} | ${ERROR.FIELD_PRICE_MIN}
-  `(
-    `Returns an error message when the order $fieldName "$errorType" validation fails`,
-    ({ fieldName, errorType, section, errorMessage }) => {
-      const { result } = setup({
-        fieldErrors: { [fieldName]: { type: errorType } },
-        order: {
-          ...order,
-          type: Schema.OrderType.TYPE_LIMIT,
-        },
-      });
-      expect(result.current).toStrictEqual({
-        isDisabled: true,
-        message: errorMessage,
-        section,
-      });
-    }
-  );
-
-  it('Returns an error message when the order size incorrectly has decimal values', () => {
-    const { result } = setup({
-      market: { ...market, positionDecimalPlaces: 0 },
-      fieldErrors: {
-        size: { type: `validate`, message: DealTicket.ERROR_SIZE_DECIMAL },
-      },
-    });
-    expect(result.current).toStrictEqual({
-      isDisabled: true,
-      message: ERROR.FIELD_PRICE_STEP_NULL,
-      section: 'sec-size',
-    });
-  });
-
-  it('Returns an error message when the order size has more decimals than allowed', () => {
-    const { result } = setup({
-      fieldErrors: {
-        size: { type: `validate`, message: DealTicket.ERROR_SIZE_DECIMAL },
-      },
-    });
-    expect(result.current).toStrictEqual({
-      isDisabled: true,
-      message: ERROR.FIELD_PRICE_STEP_DECIMAL,
-      section: 'sec-size',
-    });
-  });
-
-  it('Returns an error message when the estimated margin is higher than collateral', async () => {
-    const invalidatedMockValue = {
-      balance: '100',
-      margin: '200',
-      balanceError: true,
-    };
-
-    jest
-      .spyOn(DealTicket, 'useOrderMarginValidation')
-      .mockReturnValue(invalidatedMockValue);
-
-    const { result } = setup({});
-
-    expect(result.current.isDisabled).toBe(false);
-
-    const testElement = (
-      <DealTicket.MarginWarning
-        margin={invalidatedMockValue.margin}
-        balance={invalidatedMockValue.balance}
-        asset={asset}
-      />
-    );
-    expect((result.current.message as React.ReactElement)?.props).toEqual(
-      testElement.props
-    );
-    expect((result.current.message as React.ReactElement)?.type).toEqual(
-      testElement.type
-    );
-  });
-
-  it.each`
-    state
-    ${Schema.MarketState.STATE_PENDING}
-    ${Schema.MarketState.STATE_PROPOSED}
-  `(
-    'Returns error when market state is pending and size is wrong',
-    ({ state }) => {
-      const market = {
-        ...defaultOrder.market,
-        data: { ...defaultOrder.market.data, marketState: state },
-      };
-      const { result } = setup({
-        fieldErrors: {
-          size: { type: `validate`, message: DealTicket.ERROR_SIZE_DECIMAL },
-        },
-        market,
-      });
-      expect(result.current).toStrictEqual({
-        isDisabled: true,
-        message: ERROR.FIELD_PRICE_STEP_DECIMAL,
-        section: 'sec-size',
-      });
-    }
-  );
-});

apps/console-lite/src/app/components/deal-ticket/use-order-validation.tsx

@@ -1,375 +0,0 @@
-import type { ReactNode } from 'react';
-import type { FieldErrors } from 'react-hook-form';
-import { useMemo } from 'react';
-import { DataGrid, t, toDecimal } from '@vegaprotocol/react-helpers';
-import { useVegaWallet } from '@vegaprotocol/wallet';
-import * as Schema from '@vegaprotocol/types';
-import type { OrderSubmissionBody } from '@vegaprotocol/wallet';
-import { Tooltip } from '@vegaprotocol/ui-toolkit';
-import {
-  compileGridData,
-  MarginWarning,
-  isMarketInAuction,
-  ERROR_SIZE_DECIMAL,
-  useOrderMarginValidation,
-} from '@vegaprotocol/deal-ticket';
-import type { MarketDealTicket } from '@vegaprotocol/market-list';
-
-export const DEAL_TICKET_SECTION = {
-  TYPE: 'sec-type',
-  SIZE: 'sec-size',
-  PRICE: 'sec-price',
-  FORCE: 'sec-force',
-  EXPIRY: 'sec-expiry',
-  SUMMARY: 'sec-summary',
-};
-
-export const ERROR_EXPIRATION_IN_THE_PAST = 'ERROR_EXPIRATION_IN_THE_PAST';
-
-export type ValidationProps = {
-  step?: number;
-  market: MarketDealTicket;
-  order: OrderSubmissionBody['orderSubmission'];
-  fieldErrors?: FieldErrors<OrderSubmissionBody['orderSubmission']>;
-};
-
-export const marketTranslations = (marketState: Schema.MarketState) => {
-  switch (marketState) {
-    case Schema.MarketState.STATE_TRADING_TERMINATED:
-      return t('terminated');
-    default:
-      return t(Schema.MarketStateMapping[marketState]).toLowerCase();
-  }
-};
-
-export type DealTicketSection =
-  | ''
-  | typeof DEAL_TICKET_SECTION[keyof typeof DEAL_TICKET_SECTION];
-
-export const useOrderValidation = ({
-  market,
-  fieldErrors,
-  order,
-}: ValidationProps): {
-  message: ReactNode | string;
-  isDisabled: boolean;
-  section: DealTicketSection;
-} => {
-  const { pubKey } = useVegaWallet();
-  const minSize = toDecimal(market.positionDecimalPlaces);
-  const isInvalidOrderMargin = useOrderMarginValidation({ market, order });
-
-  const fieldErrorChecking = useMemo<{
-    message: ReactNode | string;
-    isDisabled: boolean;
-    section: DealTicketSection;
-  } | null>(() => {
-    if (fieldErrors?.size?.type || fieldErrors?.price?.type) {
-      if (fieldErrors?.size?.type === 'required') {
-        return {
-          isDisabled: true,
-          message: t('You need to provide a size'),
-          section: DEAL_TICKET_SECTION.SIZE,
-        };
-      }
-
-      if (fieldErrors?.size?.type === 'min') {
-        return {
-          isDisabled: true,
-          message: t(`Size cannot be lower than "${minSize}"`),
-          section: DEAL_TICKET_SECTION.SIZE,
-        };
-      }
-
-      if (
-        fieldErrors?.price?.type === 'required' &&
-        order.type !== Schema.OrderType.TYPE_MARKET
-      ) {
-        return {
-          isDisabled: true,
-          message: t('You need to provide a price'),
-          section: DEAL_TICKET_SECTION.PRICE,
-        };
-      }
-
-      if (
-        fieldErrors?.price?.type === 'min' &&
-        order.type !== Schema.OrderType.TYPE_MARKET
-      ) {
-        return {
-          isDisabled: true,
-          message: t(`The price cannot be negative`),
-          section: DEAL_TICKET_SECTION.PRICE,
-        };
-      }
-
-      if (
-        fieldErrors?.size?.type === 'validate' &&
-        fieldErrors?.size?.message === ERROR_SIZE_DECIMAL
-      ) {
-        if (market.positionDecimalPlaces === 0) {
-          return {
-            isDisabled: true,
-            message: t('Order sizes must be in whole numbers for this market'),
-            section: DEAL_TICKET_SECTION.SIZE,
-          };
-        }
-        return {
-          isDisabled: true,
-          message: t(
-            `The size field accepts up to ${market.positionDecimalPlaces} decimal places`
-          ),
-          section: DEAL_TICKET_SECTION.SIZE,
-        };
-      }
-    }
-
-    if (
-      fieldErrors?.expiresAt?.type === 'validate' &&
-      fieldErrors?.expiresAt.message === ERROR_EXPIRATION_IN_THE_PAST
-    ) {
-      return {
-        isDisabled: false,
-        message: t(
-          'The expiry date that you have entered appears to be in the past'
-        ),
-        section: DEAL_TICKET_SECTION.EXPIRY,
-      };
-    }
-    return null;
-  }, [
-    fieldErrors?.size?.type,
-    fieldErrors?.size?.message,
-    fieldErrors?.price?.type,
-    fieldErrors?.expiresAt?.type,
-    fieldErrors?.expiresAt?.message,
-    order.type,
-    minSize,
-    market.positionDecimalPlaces,
-  ]);
-
-  const { message, isDisabled, section } = useMemo<{
-    message: ReactNode | string;
-    isDisabled: boolean;
-    section: DealTicketSection;
-  }>(() => {
-    if (!pubKey) {
-      return {
-        message: t('No public key selected'),
-        isDisabled: true,
-        section: DEAL_TICKET_SECTION.SUMMARY,
-      };
-    }
-
-    if (
-      [
-        Schema.MarketState.STATE_SETTLED,
-        Schema.MarketState.STATE_REJECTED,
-        Schema.MarketState.STATE_TRADING_TERMINATED,
-        Schema.MarketState.STATE_CANCELLED,
-        Schema.MarketState.STATE_CLOSED,
-      ].includes(market.data.marketState)
-    ) {
-      return {
-        isDisabled: true,
-        message: t(
-          `This market is ${marketTranslations(
-            market.data.marketState
-          )} and not accepting orders`
-        ),
-        section: DEAL_TICKET_SECTION.SUMMARY,
-      };
-    }
-
-    if (
-      [
-        Schema.MarketState.STATE_PROPOSED,
-        Schema.MarketState.STATE_PENDING,
-      ].includes(market.data.marketState)
-    ) {
-      if (fieldErrorChecking) {
-        return fieldErrorChecking;
-      }
-      return {
-        isDisabled: false,
-        message: t(
-          `This market is ${marketTranslations(
-            market.data.marketState
-          )} and only accepting liquidity commitment orders`
-        ),
-        section: DEAL_TICKET_SECTION.SUMMARY,
-      };
-    }
-
-    if (isMarketInAuction(market)) {
-      if (order.type === Schema.OrderType.TYPE_MARKET) {
-        if (
-          market.data.marketTradingMode ===
-            Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION &&
-          market.data.trigger ===
-            Schema.AuctionTrigger.AUCTION_TRIGGER_LIQUIDITY
-        ) {
-          return {
-            isDisabled: true,
-            message: (
-              <span>
-                {t('This market is in auction until it reaches')}{' '}
-                <Tooltip
-                  description={<DataGrid grid={compileGridData(market)} />}
-                >
-                  <span>{t('sufficient liquidity')}</span>
-                </Tooltip>
-                {'. '}
-                {t('Only limit orders are permitted when market is in auction')}
-              </span>
-            ),
-            section: DEAL_TICKET_SECTION.TYPE,
-          };
-        }
-        if (
-          market.data.marketTradingMode ===
-            Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION &&
-          market.data.trigger === Schema.AuctionTrigger.AUCTION_TRIGGER_PRICE
-        ) {
-          return {
-            isDisabled: true,
-            message: (
-              <span>
-                {t('This market is in auction due to')}{' '}
-                <Tooltip
-                  description={<DataGrid grid={compileGridData(market)} />}
-                >
-                  <span>{t('high price volatility')}</span>
-                </Tooltip>
-                {'. '}
-                {t('Only limit orders are permitted when market is in auction')}
-              </span>
-            ),
-            section: DEAL_TICKET_SECTION.TYPE,
-          };
-        }
-        return {
-          isDisabled: true,
-          message: t(
-            'Only limit orders are permitted when market is in auction'
-          ),
-          section: DEAL_TICKET_SECTION.SUMMARY,
-        };
-      }
-      if (
-        order.type === Schema.OrderType.TYPE_LIMIT &&
-        [
-          Schema.OrderTimeInForce.TIME_IN_FORCE_FOK,
-          Schema.OrderTimeInForce.TIME_IN_FORCE_IOC,
-          Schema.OrderTimeInForce.TIME_IN_FORCE_GFN,
-        ].includes(order.timeInForce)
-      ) {
-        if (
-          market.data.marketTradingMode ===
-            Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION &&
-          market.data.trigger ===
-            Schema.AuctionTrigger.AUCTION_TRIGGER_LIQUIDITY
-        ) {
-          return {
-            isDisabled: true,
-            message: (
-              <span>
-                {t('This market is in auction until it reaches')}{' '}
-                <Tooltip
-                  description={<DataGrid grid={compileGridData(market)} />}
-                >
-                  <span>{t('sufficient liquidity')}</span>
-                </Tooltip>
-                {'. '}
-                {t(
-                  `Until the auction ends, you can only place GFA, GTT, or GTC limit orders`
-                )}
-              </span>
-            ),
-            section: DEAL_TICKET_SECTION.FORCE,
-          };
-        }
-        if (
-          market.data.marketTradingMode ===
-            Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION &&
-          market.data.trigger === Schema.AuctionTrigger.AUCTION_TRIGGER_PRICE
-        ) {
-          return {
-            isDisabled: true,
-            message: (
-              <span>
-                {t('This market is in auction due to')}{' '}
-                <Tooltip
-                  description={<DataGrid grid={compileGridData(market)} />}
-                >
-                  <span>{t('high price volatility')}</span>
-                </Tooltip>
-                {'. '}
-                {t(
-                  `Until the auction ends, you can only place GFA, GTT, or GTC limit orders`
-                )}
-              </span>
-            ),
-            section: DEAL_TICKET_SECTION.FORCE,
-          };
-        }
-        return {
-          isDisabled: true,
-          message: t(
-            `Until the auction ends, you can only place GFA, GTT, or GTC limit orders`
-          ),
-          section: DEAL_TICKET_SECTION.FORCE,
-        };
-      }
-    }
-
-    if (fieldErrorChecking) {
-      return fieldErrorChecking;
-    }
-
-    if (isInvalidOrderMargin.balanceError) {
-      return {
-        isDisabled: false,
-        message: (
-          <MarginWarning
-            margin={isInvalidOrderMargin.margin}
-            balance={isInvalidOrderMargin.balance}
-            asset={market.tradableInstrument.instrument.product.settlementAsset}
-          />
-        ),
-        section: DEAL_TICKET_SECTION.PRICE,
-      };
-    }
-
-    if (
-      [
-        Schema.MarketTradingMode.TRADING_MODE_BATCH_AUCTION,
-        Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION,
-        Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION,
-      ].includes(market.data.marketTradingMode)
-    ) {
-      return {
-        isDisabled: false,
-        message: t(
-          'Any orders placed now will not trade until the auction ends'
-        ),
-        section: DEAL_TICKET_SECTION.SUMMARY,
-      };
-    }
-
-    return {
-      isDisabled: false,
-      message: '',
-      section: '',
-    };
-  }, [
-    pubKey,
-    market,
-    fieldErrorChecking,
-    isInvalidOrderMargin,
-    order.type,
-    order.timeInForce,
-  ]);
-
-  return { message, isDisabled, section };
-};

apps/console-lite/src/app/components/deposits/Deposits.graphql

@@ -0,0 +1,17 @@
+query DepositAssets {
+  assetsConnection {
+    edges {
+      node {
+        id
+        name
+        symbol
+        decimals
+        source {
+          ... on ERC20 {
+            contractAddress
+          }
+        }
+      }
+    }
+  }
+}

apps/console-lite/src/app/components/deposits/__generated__/DepositAssets.ts

@@ -0,0 +1,75 @@
+/* tslint:disable */
+/* eslint-disable */
+// @generated
+// This file was automatically generated and should not be edited.
+
+import { AssetStatus } from "@vegaprotocol/types";
+
+// ====================================================
+// GraphQL query operation: DepositAssets
+// ====================================================
+
+export interface DepositAssets_assetsConnection_edges_node_source_BuiltinAsset {
+  __typename: "BuiltinAsset";
+}
+
+export interface DepositAssets_assetsConnection_edges_node_source_ERC20 {
+  __typename: "ERC20";
+  /**
+   * The address of the ERC20 contract
+   */
+  contractAddress: string;
+}
+
+export type DepositAssets_assetsConnection_edges_node_source = DepositAssets_assetsConnection_edges_node_source_BuiltinAsset | DepositAssets_assetsConnection_edges_node_source_ERC20;
+
+export interface DepositAssets_assetsConnection_edges_node {
+  __typename: "Asset";
+  /**
+   * The ID of the asset
+   */
+  id: string;
+  /**
+   * The full name of the asset (e.g: Great British Pound)
+   */
+  name: string;
+  /**
+   * The symbol of the asset (e.g: GBP)
+   */
+  symbol: string;
+  /**
+   * The precision of the asset. Should match the decimal precision of the asset on its native chain, e.g: for ERC20 assets, it is often 18
+   */
+  decimals: number;
+  /**
+   * The status of the asset in the Vega network
+   */
+  status: AssetStatus;
+  /**
+   * The origin source of the asset (e.g: an ERC20 asset)
+   */
+  source: DepositAssets_assetsConnection_edges_node_source;
+}
+
+export interface DepositAssets_assetsConnection_edges {
+  __typename: "AssetEdge";
+  /**
+   * The asset information
+   */
+  node: DepositAssets_assetsConnection_edges_node;
+}
+
+export interface DepositAssets_assetsConnection {
+  __typename: "AssetsConnection";
+  /**
+   * The assets
+   */
+  edges: (DepositAssets_assetsConnection_edges | null)[] | null;
+}
+
+export interface DepositAssets {
+  /**
+   * The list of all assets in use in the Vega network or the specified asset if ID is provided
+   */
+  assetsConnection: DepositAssets_assetsConnection | null;
+}

apps/console-lite/src/app/components/deposits/__generated___/Deposits.ts

@@ -0,0 +1,57 @@
+import { Schema as Types } from '@vegaprotocol/types';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type DepositAssetsQueryVariables = Types.Exact<{ [key: string]: never; }>;
+
+
+export type DepositAssetsQuery = { __typename?: 'Query', assetsConnection?: { __typename?: 'AssetsConnection', edges?: Array<{ __typename?: 'AssetEdge', node: { __typename?: 'Asset', id: string, name: string, symbol: string, decimals: number, source: { __typename?: 'BuiltinAsset' } | { __typename?: 'ERC20', contractAddress: string } } } | null> | null } | null };
+
+
+export const DepositAssetsDocument = gql`
+    query DepositAssets {
+  assetsConnection {
+    edges {
+      node {
+        id
+        name
+        symbol
+        decimals
+        source {
+          ... on ERC20 {
+            contractAddress
+          }
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useDepositAssetsQuery__
+ *
+ * To run a query within a React component, call `useDepositAssetsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useDepositAssetsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useDepositAssetsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useDepositAssetsQuery(baseOptions?: Apollo.QueryHookOptions<DepositAssetsQuery, DepositAssetsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<DepositAssetsQuery, DepositAssetsQueryVariables>(DepositAssetsDocument, options);
+      }
+export function useDepositAssetsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DepositAssetsQuery, DepositAssetsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<DepositAssetsQuery, DepositAssetsQueryVariables>(DepositAssetsDocument, options);
+        }
+export type DepositAssetsQueryHookResult = ReturnType<typeof useDepositAssetsQuery>;
+export type DepositAssetsLazyQueryHookResult = ReturnType<typeof useDepositAssetsLazyQuery>;
+export type DepositAssetsQueryResult = Apollo.QueryResult<DepositAssetsQuery, DepositAssetsQueryVariables>;

apps/console-lite/src/app/components/deposits/deposits.tsx

@@ -1,18 +1,40 @@
+import { useMemo } from 'react';
+import { DepositManager } from '@vegaprotocol/deposits';
 import { t } from '@vegaprotocol/react-helpers';
-import { Button } from '@vegaprotocol/ui-toolkit';
-import { DepositDialog, useDepositDialog } from '@vegaprotocol/deposits';
+import { enabledAssetsProvider } from '@vegaprotocol/assets';
+import { useDataProvider } from '@vegaprotocol/react-helpers';
+import { Networks, useEnvironment } from '@vegaprotocol/environment';
+import { AsyncRenderer, Splash } from '@vegaprotocol/ui-toolkit';
+import { useVegaWallet } from '@vegaprotocol/wallet';
+import { Web3Container } from '@vegaprotocol/web3';
 
 /**
  *  Fetches data required for the Deposit page
  */
 export const DepositContainer = () => {
-  const openDepositDialog = useDepositDialog((state) => state.open);
+  const { VEGA_ENV } = useEnvironment();
+  const { pubKey } = useVegaWallet();
+  const variables = useMemo(() => ({ partyId: pubKey }), [pubKey]);
+  const { data, loading, error } = useDataProvider({
+    dataProvider: enabledAssetsProvider,
+    variables,
+    skip: !pubKey,
+  });
+
   return (
-    <div>
-      <DepositDialog />
-      <Button size="sm" onClick={() => openDepositDialog()}>
-        {t('Make deposit')}
-      </Button>
-    </div>
+    <AsyncRenderer data={data} loading={loading} error={error}>
+      {data && data.length ? (
+        <Web3Container>
+          <DepositManager
+            assets={data}
+            isFaucetable={VEGA_ENV !== Networks.MAINNET}
+          />
+        </Web3Container>
+      ) : (
+        <Splash>
+          <p>{t('No assets on this network')}</p>
+        </Splash>
+      )}
+    </AsyncRenderer>
   );
 };

apps/console-lite/src/app/components/header/header.tsx

@@ -11,6 +11,8 @@ const Header = () => {
   }));
   const {
     vegaWalletDialog: { setManage },
+    theme,
+    toggleTheme,
   } = useContext(LocalContext);
   return (
     <div
@@ -23,7 +25,7 @@ const Header = () => {
           setConnectDialog={updateVegaWalletDialog}
           setManageDialog={setManage}
         />
-        <ThemeSwitcher className="-my-4" />
+        <ThemeSwitcher theme={theme} onToggle={toggleTheme} className="-my-4" />
       </div>
     </div>
   );

apps/console-lite/src/app/components/portfolio/accounts/accounts.tsx

@@ -16,7 +16,7 @@ import { useAccountColumnDefinitions } from '.';
 
 const AccountsManager = () => {
   const { partyId = '' } = useOutletContext<{ partyId: string }>();
-  const { isOpen, id, setOpen } = useAssetDetailsDialogStore();
+  const { isOpen, symbol, setOpen } = useAssetDetailsDialogStore();
   const gridRef = useRef<AgGridReact | null>(null);
   const dataRef = useRef<AccountFields[] | null>(null);
   const variables = useMemo(() => ({ partyId }), [partyId]);
@@ -33,6 +33,9 @@ const AccountsManager = () => {
     update,
     variables,
   });
+  if (!dataRef.current && data) {
+    dataRef.current = data;
+  }
   const getRows = async ({
     successCallback,
     startRow,
@@ -45,13 +48,12 @@ const AccountsManager = () => {
     successCallback(rowsThisBlock, lastRow);
   };
   const { columnDefs, defaultColDef } = useAccountColumnDefinitions();
-  console.log(data, loading);
   return (
     <>
       <AsyncRenderer
         loading={loading}
         error={error}
-        data={data?.length ? data : null}
+        data={data}
         noDataMessage={NO_DATA_MESSAGE}
       >
         <ConsoleLiteGrid<AccountFields>
@@ -66,7 +68,7 @@ const AccountsManager = () => {
         />
       </AsyncRenderer>
       <AssetDetailsDialog
-        assetId={id}
+        assetSymbol={symbol}
         open={isOpen}
         onChange={(open) => setOpen(open)}
       />

apps/console-lite/src/app/components/portfolio/accounts/use-column-definitions.tsx

@@ -15,14 +15,14 @@ const useAccountColumnDefinitions = () => {
         field: 'asset.symbol',
         headerClass: 'uppercase justify-start',
         cellClass: 'uppercase flex h-full items-center md:pl-4',
-        cellRenderer: ({ value, data }: GroupCellRendererParams) =>
+        cellRenderer: ({ value }: GroupCellRendererParams) =>
           value && value.length > 0 ? (
             <div className="md:pl-4 grid h-full items-center" title={value}>
               <div className="truncate min-w-0">
                 <button
                   className="hover:underline"
                   onClick={() => {
-                    open(data.asset.id);
+                    open(value);
                   }}
                 >
                   {value}

apps/console-lite/src/app/components/portfolio/fills/use-column-definitions.tsx

@@ -12,7 +12,7 @@ import {
   t,
 } from '@vegaprotocol/react-helpers';
 import BigNumber from 'bignumber.js';
-import * as Schema from '@vegaprotocol/types';
+import { Schema } from '@vegaprotocol/types';
 
 interface Props {
   partyId: string;

apps/console-lite/src/app/components/portfolio/orders/orders.tsx

@@ -65,8 +65,8 @@ const OrdersManager = () => {
         defaultColDef={defaultColDef}
       />
       <orderCancel.Dialog
-        title={getCancelDialogTitle(orderCancel)}
-        intent={getCancelDialogIntent(orderCancel)}
+        title={getCancelDialogTitle(orderCancel.cancelledOrder?.status)}
+        intent={getCancelDialogIntent(orderCancel.cancelledOrder?.status)}
         content={{
           Complete: (
             <OrderFeedback

apps/console-lite/src/app/components/portfolio/orders/use-column-definitions.tsx

@@ -11,21 +11,30 @@ import {
   positiveClassNames,
   t,
 } from '@vegaprotocol/react-helpers';
-import type { OrderFieldsFragment, Order } from '@vegaprotocol/orders';
-import type { OrderCancellationBody } from '@vegaprotocol/wallet';
+import type {
+  OrderFieldsFragment,
+  Order,
+  CancelOrderArgs,
+} from '@vegaprotocol/orders';
 import { isOrderActive } from '@vegaprotocol/orders';
-import * as Schema from '@vegaprotocol/types';
+import {
+  OrderRejectionReasonMapping,
+  OrderStatusMapping,
+  OrderTypeMapping,
+  Schema,
+  OrderTimeInForceMapping,
+} from '@vegaprotocol/types';
 
 import BigNumber from 'bignumber.js';
 import { Button } from '@vegaprotocol/ui-toolkit';
 
-type StatusKey = keyof typeof Schema.OrderStatusMapping;
-type RejectReasonKey = keyof typeof Schema.OrderRejectionReasonMapping;
-type OrderTimeKey = keyof typeof Schema.OrderTimeInForceMapping;
+type StatusKey = keyof typeof OrderStatusMapping;
+type RejectReasonKey = keyof typeof OrderRejectionReasonMapping;
+type OrderTimeKey = keyof typeof OrderTimeInForceMapping;
 interface Props {
   setEditOrder: (order: Order) => void;
   orderCancel: {
-    cancel: (args: OrderCancellationBody['orderCancellation']) => void;
+    cancel: (args: CancelOrderArgs) => void;
     [key: string]: unknown;
   };
 }
@@ -75,7 +84,7 @@ const useColumnDefinitions = ({ setEditOrder, orderCancel }: Props) => {
           value,
         }: ValueFormatterParams & {
           value?: OrderFieldsFragment['type'];
-        }) => Schema.OrderTypeMapping[value as Schema.OrderType],
+        }) => OrderTypeMapping[value as Schema.OrderType],
       },
       {
         colId: 'status',
@@ -89,14 +98,14 @@ const useColumnDefinitions = ({ setEditOrder, orderCancel }: Props) => {
         }) => {
           if (value && data && data.market) {
             if (value === Schema.OrderStatus.STATUS_REJECTED) {
-              return `${Schema.OrderStatusMapping[value as StatusKey]}: ${
+              return `${OrderStatusMapping[value as StatusKey]}: ${
                 data.rejectionReason &&
-                Schema.OrderRejectionReasonMapping[
+                OrderRejectionReasonMapping[
                   data.rejectionReason as RejectReasonKey
                 ]
               }`;
             }
-            return Schema.OrderStatusMapping[value as StatusKey] as string;
+            return OrderStatusMapping[value as StatusKey] as string;
           }
           return '-';
         },
@@ -170,11 +179,11 @@ const useColumnDefinitions = ({ setEditOrder, orderCancel }: Props) => {
                 new Date(data.expiresAt)
               );
               return `${
-                Schema.OrderTimeInForceMapping[value as OrderTimeKey]
+                OrderTimeInForceMapping[value as OrderTimeKey]
               }: ${expiry}`;
             }
 
-            return Schema.OrderTimeInForceMapping[value as OrderTimeKey];
+            return OrderTimeInForceMapping[value as OrderTimeKey];
           }
           return '-';
         },

apps/console-lite/src/app/components/portfolio/positions/positions-asset.tsx

@@ -0,0 +1,58 @@
+import { AsyncRenderer } from '@vegaprotocol/ui-toolkit';
+import { useRef } from 'react';
+import type { AgGridReact } from 'ag-grid-react';
+import type { Position } from '@vegaprotocol/positions';
+import { PriceFlashCell, t } from '@vegaprotocol/react-helpers';
+import { AssetBalance } from '@vegaprotocol/accounts';
+import { usePositionsData } from '@vegaprotocol/positions';
+import { ConsoleLiteGrid } from '../../console-lite-grid';
+import useColumnDefinitions from './use-column-definitions';
+
+interface Props {
+  partyId: string;
+  assetSymbol: string;
+}
+
+const getRowId = ({ data }: { data: Position }) => data.marketId;
+
+const PositionsAsset = ({ partyId, assetSymbol }: Props) => {
+  const gridRef = useRef<AgGridReact | null>(null);
+  const { data, error, loading, getRows } = usePositionsData(
+    partyId,
+    gridRef,
+    assetSymbol
+  );
+  const { columnDefs, defaultColDef } = useColumnDefinitions();
+  return (
+    <AsyncRenderer loading={loading} error={error} data={data}>
+      <div
+        data-testid={`positions-asset-${assetSymbol}`}
+        className="flex justify-between items-center px-4 pt-3 pb-1"
+      >
+        <h4>
+          {assetSymbol} {t('markets')}
+        </h4>
+        <div className="text-sm text-neutral-500 dark:text-neutral-300">
+          {assetSymbol} {t('balance')}:
+          <span data-testid="balance" className="pl-1 font-mono">
+            <AssetBalance partyId={partyId} assetSymbol={assetSymbol} />
+          </span>
+        </div>
+      </div>
+      <ConsoleLiteGrid<Position & { id: undefined }>
+        ref={gridRef}
+        domLayout="autoHeight"
+        classNamesParam="h-auto"
+        columnDefs={columnDefs}
+        defaultColDef={defaultColDef}
+        getRowId={getRowId}
+        rowModelType={data?.length ? 'infinite' : 'clientSide'}
+        rowData={data?.length ? undefined : []}
+        datasource={{ getRows }}
+        components={{ PriceFlashCell }}
+      />
+    </AsyncRenderer>
+  );
+};
+
+export default PositionsAsset;

apps/console-lite/src/app/components/portfolio/positions/positions.tsx

@@ -1,37 +1,26 @@
 import { useOutletContext } from 'react-router-dom';
-import { PriceFlashCell } from '@vegaprotocol/react-helpers';
-import { usePositionsData, getRowId } from '@vegaprotocol/positions';
-import { AsyncRenderer } from '@vegaprotocol/ui-toolkit';
-import { ConsoleLiteGrid } from '../../console-lite-grid';
-import { useRef } from 'react';
-import type { AgGridReact } from 'ag-grid-react';
-import type { Position } from '@vegaprotocol/positions';
-import { NO_DATA_MESSAGE } from '../../../constants';
-
-import useColumnDefinitions from './use-column-definitions';
+import { t } from '@vegaprotocol/react-helpers';
+import { usePositionsAssets } from '@vegaprotocol/positions';
+import { AsyncRenderer, Splash } from '@vegaprotocol/ui-toolkit';
+import PositionsAsset from './positions-asset';
 
 const Positions = () => {
-  const gridRef = useRef<AgGridReact | null>(null);
   const { partyId } = useOutletContext<{ partyId: string }>();
-  const { data, error, loading } = usePositionsData(partyId, gridRef);
-  const { columnDefs, defaultColDef } = useColumnDefinitions();
+  const { data, error, loading, assetSymbols } = usePositionsAssets(partyId);
   return (
-    <AsyncRenderer
-      loading={loading}
-      error={error}
-      data={data?.length ? data : null}
-      noDataMessage={NO_DATA_MESSAGE}
-    >
-      <ConsoleLiteGrid<Position>
-        ref={gridRef}
-        domLayout="autoHeight"
-        classNamesParam="h-auto"
-        columnDefs={columnDefs}
-        defaultColDef={defaultColDef}
-        getRowId={getRowId}
-        rowData={data || undefined}
-        components={{ PriceFlashCell }}
-      />
+    <AsyncRenderer loading={loading} error={error} data={data}>
+      {assetSymbols && assetSymbols.length > 0 && (
+        <div className="w-full, h-max">
+          {assetSymbols?.map((assetSymbol) => (
+            <PositionsAsset
+              key={assetSymbol}
+              partyId={partyId}
+              assetSymbol={assetSymbol}
+            />
+          ))}
+        </div>
+      )}
+      {assetSymbols?.length === 0 && <Splash>{t('No data to display')}</Splash>}
     </AsyncRenderer>
   );
 };

apps/console-lite/src/app/components/portfolio/positions/use-column-definitions.tsx

@@ -16,7 +16,7 @@ import type {
   GroupCellRendererParams,
   ColDef,
 } from 'ag-grid-community';
-import * as Schema from '@vegaprotocol/types';
+import { MarketTradingMode } from '@vegaprotocol/types';
 import type { VegaValueFormatterParams } from '@vegaprotocol/ui-toolkit';
 import { Intent, ProgressBarCell } from '@vegaprotocol/ui-toolkit';
 
@@ -109,7 +109,7 @@ const useColumnDefinitions = () => {
             value &&
             node?.rowPinned &&
             data.marketTradingMode ===
-              Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION
+              MarketTradingMode.TRADING_MODE_OPENING_AUCTION
           ) {
             return addDecimalsFormatNumber(
               value.toString(),

apps/console-lite/src/app/components/simple-market-list/__generated___/Candles.ts

@@ -1,4 +1,4 @@
-import * as Types from '@vegaprotocol/types';
+import { Schema as Types } from '@vegaprotocol/types';
 
 import { gql } from '@apollo/client';
 import * as Apollo from '@apollo/client';

apps/console-lite/src/app/components/simple-market-list/constants.ts

@@ -1,24 +1,21 @@
 import { t } from '@vegaprotocol/react-helpers';
 import { themelite as theme } from '@vegaprotocol/tailwindcss-config';
-import * as Schema from '@vegaprotocol/types';
+import { MarketState } from '@vegaprotocol/types';
 import colors from 'tailwindcss/colors';
 import type { Market } from '@vegaprotocol/market-list';
 import { IS_MARKET_TRADABLE } from '../../constants';
 
 export const STATES_FILTER = [
   { value: 'all', text: t('All') },
-  { value: Schema.MarketState.STATE_ACTIVE, text: t('Active') },
-  { value: Schema.MarketState.STATE_CANCELLED, text: t('Cancelled') },
-  { value: Schema.MarketState.STATE_CLOSED, text: t('Closed') },
-  { value: Schema.MarketState.STATE_PENDING, text: t('Pending') },
-  { value: Schema.MarketState.STATE_PROPOSED, text: t('Proposed') },
-  { value: Schema.MarketState.STATE_REJECTED, text: t('Rejected') },
-  { value: Schema.MarketState.STATE_SETTLED, text: t('Settled') },
-  { value: Schema.MarketState.STATE_SUSPENDED, text: t('Suspended') },
-  {
-    value: Schema.MarketState.STATE_TRADING_TERMINATED,
-    text: t('TradingTerminated'),
-  },
+  { value: MarketState.STATE_ACTIVE, text: t('Active') },
+  { value: MarketState.STATE_CANCELLED, text: t('Cancelled') },
+  { value: MarketState.STATE_CLOSED, text: t('Closed') },
+  { value: MarketState.STATE_PENDING, text: t('Pending') },
+  { value: MarketState.STATE_PROPOSED, text: t('Proposed') },
+  { value: MarketState.STATE_REJECTED, text: t('Rejected') },
+  { value: MarketState.STATE_SETTLED, text: t('Settled') },
+  { value: MarketState.STATE_SUSPENDED, text: t('Suspended') },
+  { value: MarketState.STATE_TRADING_TERMINATED, text: t('TradingTerminated') },
 ];
 
 export const agGridLightVariables = `

apps/console-lite/src/app/components/simple-market-list/simple-market-list.spec.tsx

@@ -9,7 +9,7 @@ import {
 } from '@testing-library/react';
 import { MockedProvider } from '@apollo/client/testing';
 import { BrowserRouter } from 'react-router-dom';
-import * as Schema from '@vegaprotocol/types';
+import { MarketState } from '@vegaprotocol/types';
 import type { Market } from '@vegaprotocol/market-list';
 import SimpleMarketList from './simple-market-list';
 
@@ -26,7 +26,7 @@ jest.mock('./simple-market-percent-change', () => jest.fn());
 let marketsMock = [
   {
     id: 'MARKET_A',
-    state: Schema.MarketState.STATE_ACTIVE,
+    state: MarketState.STATE_ACTIVE,
     tradableInstrument: {
       instrument: {
         product: {
@@ -42,7 +42,7 @@ let marketsMock = [
   },
   {
     id: 'MARKET_B',
-    state: Schema.MarketState.STATE_ACTIVE,
+    state: MarketState.STATE_ACTIVE,
     tradableInstrument: {
       instrument: {
         product: {
@@ -121,7 +121,7 @@ describe('SimpleMarketList', () => {
       expect(mockIsTradable).toHaveBeenCalledWith(
         expect.objectContaining({
           id: marketsMock[0].id,
-          state: Schema.MarketState.STATE_ACTIVE,
+          state: MarketState.STATE_ACTIVE,
         })
       );
       expect(mockedNavigate).toHaveBeenCalledWith(

apps/console-lite/src/app/components/simple-market-list/simple-market-list.tsx

@@ -7,13 +7,14 @@ import {
   useYesterday,
 } from '@vegaprotocol/react-helpers';
 import { AsyncRenderer } from '@vegaprotocol/ui-toolkit';
+import type { MarketState } from '@vegaprotocol/types';
 import useMarketsFilterData from './use-markets-filter-data';
 import useColumnDefinitions from './use-column-definitions';
 import SimpleMarketToolbar from './simple-market-toolbar';
 import { IS_MARKET_TRADABLE } from '../../constants';
 import { ConsoleLiteGrid } from '../console-lite-grid';
 import type { Market } from '@vegaprotocol/market-list';
-import * as Schema from '@vegaprotocol/types';
+import { Interval } from '@vegaprotocol/types';
 import { marketsWithCandlesProvider } from '@vegaprotocol/market-list';
 
 export type MarketWithPercentChange = Market & {
@@ -30,20 +31,20 @@ const SimpleMarketList = () => {
   const { isMobile } = useScreenDimensions();
   const navigate = useNavigate();
   const params = useParams<RouterParams>();
-  const statusesRef = useRef<Record<string, Schema.MarketState | ''>>({});
+  const statusesRef = useRef<Record<string, MarketState | ''>>({});
   const gridRef = useRef<AgGridReact | null>(null);
 
   const yesterday = useYesterday();
   const variables = useMemo(() => {
     return {
       since: new Date(yesterday).toISOString(),
-      interval: Schema.Interval.INTERVAL_I1H,
+      interval: Interval.INTERVAL_I1H,
     };
   }, [yesterday]);
   const { data, error, loading } = useDataProvider({
     dataProvider: marketsWithCandlesProvider,
     variables,
-    skipUpdates: true,
+    noUpdate: true,
   });
   const localData = useMarketsFilterData(data, params);
 
@@ -52,7 +53,7 @@ const SimpleMarketList = () => {
   }, [gridRef]);
 
   useEffect(() => {
-    const statuses: Record<string, Schema.MarketState | ''> = {};
+    const statuses: Record<string, MarketState | ''> = {};
     data?.forEach((market) => {
       statuses[market.id] = market.state || '';
     });

apps/console-lite/src/app/components/simple-market-list/simple-market-percent-change.tsx

@@ -4,7 +4,7 @@ import { InView } from 'react-intersection-observer';
 import { useDataProvider, useYesterday } from '@vegaprotocol/react-helpers';
 import type { Candle } from '@vegaprotocol/market-list';
 import { marketCandlesProvider } from '@vegaprotocol/market-list';
-import * as Schema from '@vegaprotocol/types';
+import { Interval } from '@vegaprotocol/types';
 
 interface Props {
   candles: (Candle | null)[] | null;
@@ -73,7 +73,7 @@ const SimpleMarketPercentChange = ({ candles, marketId, setValue }: Props) => {
     dataProvider: marketCandlesProvider,
     variables: {
       marketId,
-      interval: Schema.Interval.INTERVAL_I1D,
+      interval: Interval.INTERVAL_I1D,
       since: new Date(yesterday).toISOString(),
     },
   });

apps/console-lite/src/app/components/simple-market-list/simple-market-renderer.spec.tsx

@@ -1,13 +1,13 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
-import * as Schema from '@vegaprotocol/types';
+import { MarketState } from '@vegaprotocol/types';
 import MarketNameRenderer from './simple-market-renderer';
 import type { Market } from '@vegaprotocol/market-list';
 
 describe('SimpleMarketRenderer', () => {
   const market = {
     id: 'MARKET_A',
-    state: Schema.MarketState.STATE_ACTIVE,
+    state: MarketState.STATE_ACTIVE,
     tradableInstrument: {
       instrument: {
         code: 'MARKET_A_CODE',

apps/console-lite/src/app/components/simple-market-list/simple-market-toolbar.spec.tsx

@@ -14,7 +14,7 @@ import {
   getAllByText,
 } from '@testing-library/react';
 import { MockedProvider } from '@apollo/react-testing';
-import * as Schema from '@vegaprotocol/types';
+import { MarketState } from '@vegaprotocol/types';
 import type { Market } from '@vegaprotocol/market-list';
 import SimpleMarketToolbar from './simple-market-toolbar';
 import { markets as filterData } from './mocks/market-filters.json';
@@ -113,7 +113,7 @@ describe('SimpleMarketToolbar', () => {
 
     await waitFor(() => {
       expect(screen.getByTestId('location-display')).toHaveTextContent(
-        `/markets/${Schema.MarketState.STATE_ACTIVE}/Future`
+        `/markets/${MarketState.STATE_ACTIVE}/Future`
       );
     });
 
@@ -124,7 +124,7 @@ describe('SimpleMarketToolbar', () => {
     );
     await waitFor(() => {
       expect(screen.getByTestId('location-display')).toHaveTextContent(
-        `/markets/${Schema.MarketState.STATE_ACTIVE}/Future/tEURO`
+        `/markets/${MarketState.STATE_ACTIVE}/Future/tEURO`
       );
     });
 
@@ -139,7 +139,7 @@ describe('SimpleMarketToolbar', () => {
     });
     await waitFor(() => {
       expect(mockedNavigate).toHaveBeenCalledWith(
-        `/markets/${Schema.MarketState.STATE_PENDING}/Future/tEURO`
+        `/markets/${MarketState.STATE_PENDING}/Future/tEURO`
       );
     });
   });
@@ -165,7 +165,7 @@ describe('SimpleMarketToolbar', () => {
     fireEvent.click(suspended);
 
     expect(mockedNavigate).toHaveBeenCalledWith(
-      `/markets/${Schema.MarketState.STATE_SUSPENDED}/product1/asset1`
+      `/markets/${MarketState.STATE_SUSPENDED}/product1/asset1`
     );
   });
 
@@ -186,7 +186,7 @@ describe('SimpleMarketToolbar', () => {
     fireEvent.click(closed);
 
     expect(mockedNavigate).toHaveBeenCalledWith(
-      `/markets/${Schema.MarketState.STATE_CLOSED}`
+      `/markets/${MarketState.STATE_CLOSED}`
     );
   });
 

apps/console-lite/src/app/components/simple-market-list/simple-market-toolbar.tsx

@@ -13,7 +13,7 @@ import {
   DropdownMenuItemIndicator,
   Icon,
 } from '@vegaprotocol/ui-toolkit';
-import * as Schema from '@vegaprotocol/types';
+import { MarketState } from '@vegaprotocol/types';
 import type { Market } from '@vegaprotocol/market-list';
 import { HorizontalMenu } from '../horizontal-menu';
 import type { HorizontalMenuItem } from '../horizontal-menu';
@@ -36,7 +36,7 @@ const SimpleMarketToolbar = ({ data }: Props) => {
         params.asset && params.asset !== 'all' ? `/${params.asset}` : '';
       const product = params.product ? `/${params.product}` : '';
       const state =
-        activeState !== Schema.MarketState.STATE_ACTIVE || product
+        activeState !== MarketState.STATE_ACTIVE || product
           ? `/${activeState}`
           : '';
       navigate(`/markets${state}${product}${asset}`);
@@ -45,8 +45,8 @@ const SimpleMarketToolbar = ({ data }: Props) => {
   );
 
   const productItems = useMemo(() => {
-    const currentState = params.state || Schema.MarketState.STATE_ACTIVE;
-    const noStateSkip = currentState !== Schema.MarketState.STATE_ACTIVE;
+    const currentState = params.state || MarketState.STATE_ACTIVE;
+    const noStateSkip = currentState !== MarketState.STATE_ACTIVE;
     const items: HorizontalMenuItem[] = [
       {
         ...constants.ALL_PRODUCTS_ITEM,
@@ -83,8 +83,7 @@ const SimpleMarketToolbar = ({ data }: Props) => {
                 {constants.STATES_FILTER.find(
                   (state) =>
                     state.value === params.state ||
-                    (!params.state &&
-                      state.value === Schema.MarketState.STATE_ACTIVE)
+                    (!params.state && state.value === MarketState.STATE_ACTIVE)
                 )?.text || params.state}
                 <Icon
                   name={IconNames.ARROW_DOWN}
@@ -104,7 +103,7 @@ const SimpleMarketToolbar = ({ data }: Props) => {
                   key={value}
                   checked={
                     value === params.state ||
-                    (!params.state && value === Schema.MarketState.STATE_ACTIVE)
+                    (!params.state && value === MarketState.STATE_ACTIVE)
                   }
                   onCheckedChange={() => onStateChange(value)}
                 >

apps/console-lite/src/app/components/simple-market-list/use-markets-filter-data.ts

@@ -1,5 +1,5 @@
 import { useMemo } from 'react';
-import * as Schema from '@vegaprotocol/types';
+import { MarketState } from '@vegaprotocol/types';
 import type { MarketWithCandles } from '@vegaprotocol/market-list';
 import type { RouterParams } from './simple-market-list';
 
@@ -30,7 +30,7 @@ const useMarketsFilterData = (
             ? ''
             : params.state
             ? params.state
-            : Schema.MarketState.STATE_ACTIVE;
+            : MarketState.STATE_ACTIVE;
         if (state && state !== item.state) {
           return false;
         }

apps/console-lite/src/app/constants/index.ts

@@ -1,26 +1,26 @@
-import * as Schema from '@vegaprotocol/types';
+import { MarketState } from '@vegaprotocol/types';
 import { t } from '@vegaprotocol/react-helpers';
 import type { Market } from '@vegaprotocol/market-list';
 
 export const DATE_FORMAT = 'dd MMMM yyyy HH:mm';
 
 export const TRADABLE_STATES = {
-  [Schema.MarketState.STATE_ACTIVE]: true,
+  [MarketState.STATE_ACTIVE]: true,
 };
 
 export const IS_MARKET_TRADABLE = (market: Market) =>
   Boolean((market.state ?? '') in TRADABLE_STATES && market?.id);
 
-export const MARKET_STATES_MAP: Record<Schema.MarketState | '', string> = {
-  [Schema.MarketState.STATE_ACTIVE]: t('Active'),
-  [Schema.MarketState.STATE_CANCELLED]: t('Cancelled'),
-  [Schema.MarketState.STATE_CLOSED]: t('Closed'),
-  [Schema.MarketState.STATE_PENDING]: t('Pending'),
-  [Schema.MarketState.STATE_PROPOSED]: t('Proposed'),
-  [Schema.MarketState.STATE_REJECTED]: t('Rejected'),
-  [Schema.MarketState.STATE_SETTLED]: t('Settled'),
-  [Schema.MarketState.STATE_SUSPENDED]: t('Suspended'),
-  [Schema.MarketState.STATE_TRADING_TERMINATED]: t('TradingTerminated'),
+export const MARKET_STATES_MAP: Record<MarketState | '', string> = {
+  [MarketState.STATE_ACTIVE]: t('Active'),
+  [MarketState.STATE_CANCELLED]: t('Cancelled'),
+  [MarketState.STATE_CLOSED]: t('Closed'),
+  [MarketState.STATE_PENDING]: t('Pending'),
+  [MarketState.STATE_PROPOSED]: t('Proposed'),
+  [MarketState.STATE_REJECTED]: t('Rejected'),
+  [MarketState.STATE_SETTLED]: t('Settled'),
+  [MarketState.STATE_SUSPENDED]: t('Suspended'),
+  [MarketState.STATE_TRADING_TERMINATED]: t('TradingTerminated'),
   '': t('Unknown'),
 };
 

apps/console-lite/src/app/context/local-context.ts

@@ -14,6 +14,8 @@ interface MenuState {
 export interface LocalValues {
   vegaWalletDialog: VegaWalletDialogState;
   menu: MenuState;
+  theme: 'light' | 'dark';
+  toggleTheme: () => void;
 }
 
 const LocalContext = createContext<LocalValues>({} as LocalValues);

apps/console-lite/src/app/hooks/use-local-values.spec.ts

@@ -3,7 +3,8 @@ import useLocalValues from './use-local-values';
 
 describe('local values hook', () => {
   it('state of wallet dialog should be properly handled', () => {
-    const { result } = renderHook(() => useLocalValues());
+    const setTheme = jest.fn();
+    const { result } = renderHook(() => useLocalValues('light', setTheme));
     expect(result.current.vegaWalletDialog).toBeDefined();
     expect(result.current.vegaWalletDialog.manage).toBe(false);
     act(() => {

apps/console-lite/src/app/hooks/use-local-values.ts

@@ -1,15 +1,17 @@
 import { useMemo, useState } from 'react';
 import type { LocalValues } from '../context/local-context';
 
-const useLocalValues = () => {
+const useLocalValues = (theme: 'light' | 'dark', toggleTheme: () => void) => {
   const [manage, setManage] = useState<boolean>(false);
   const [menuOpen, setMenuOpen] = useState(false);
   return useMemo<LocalValues>(
     () => ({
       vegaWalletDialog: { manage, setManage },
       menu: { menuOpen, setMenuOpen, onToggle: () => setMenuOpen(!menuOpen) },
+      theme,
+      toggleTheme,
     }),
-    [manage, menuOpen]
+    [manage, theme, toggleTheme, menuOpen]
   );
 };
 

apps/console-lite/src/app/lib/apollo-client.tsx

@@ -0,0 +1,88 @@
+import {
+  ApolloClient,
+  from,
+  HttpLink,
+  InMemoryCache,
+  split,
+} from '@apollo/client';
+import { onError } from '@apollo/client/link/error';
+import { RetryLink } from '@apollo/client/link/retry';
+import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
+import { createClient as createWSClient } from 'graphql-ws';
+import { getMainDefinition } from '@apollo/client/utilities';
+
+export function createClient(base?: string) {
+  if (!base) {
+    throw new Error('Base must be passed into createClient!');
+  }
+  const urlHTTP = new URL(base);
+  const urlWS = new URL(base);
+  // Replace http with ws, preserving if its a secure connection eg. https => wss
+  urlWS.protocol = urlWS.protocol.replace('http', 'ws');
+
+  const cache = new InMemoryCache({
+    typePolicies: {
+      Market: {
+        merge: true,
+      },
+      Party: {
+        merge: true,
+      },
+      Query: {},
+      Account: {
+        keyFields: false,
+        fields: {
+          balanceFormatted: {},
+        },
+      },
+      Node: {
+        keyFields: false,
+      },
+      Instrument: {
+        keyFields: false,
+      },
+    },
+  });
+
+  const retryLink = new RetryLink({
+    delay: {
+      initial: 300,
+      max: 10000,
+      jitter: true,
+    },
+  });
+
+  const httpLink = new HttpLink({
+    uri: urlHTTP.href,
+    credentials: 'same-origin',
+  });
+
+  const wsLink = new GraphQLWsLink(
+    createWSClient({
+      url: urlWS.href,
+    })
+  );
+
+  const splitLink = split(
+    ({ query }) => {
+      const definition = getMainDefinition(query);
+      return (
+        definition.kind === 'OperationDefinition' &&
+        definition.operation === 'subscription'
+      );
+    },
+    wsLink,
+    httpLink
+  );
+
+  const errorLink = onError(({ graphQLErrors, networkError }) => {
+    console.log(graphQLErrors);
+    console.log(networkError);
+  });
+
+  return new ApolloClient({
+    connectToDevTools: process.env['NODE_ENV'] === 'development',
+    link: from([errorLink, retryLink, splitLink]),
+    cache,
+  });
+}

apps/console-lite/src/app/lib/vega-connectors.ts

@@ -1,9 +1,7 @@
-import { RestConnector, JsonRpcConnector } from '@vegaprotocol/wallet';
+import { RestConnector } from '@vegaprotocol/wallet';
 
 export const rest = new RestConnector();
-export const jsonRpc = new JsonRpcConnector();
 
 export const Connectors = {
   rest,
-  jsonRpc,
 };

apps/console-lite/tsconfig.json

@@ -12,6 +12,7 @@
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true
   },
+  "files": [],
   "include": [],
   "references": [
     {

apps/explorer-e2e/.cypress-cucumber-preprocessorrc

@@ -0,0 +1,3 @@
+{
+    "stepDefinitions": "src/support/step_definitions"
+}

apps/explorer-e2e/.env

@@ -16,5 +16,3 @@ NX_EXPLORER_TXS_LIST=0
 NX_EXPLORER_NETWORK_PARAMETERS=1
 NX_EXPLORER_PARTIES=1
 NX_EXPLORER_VALIDATORS=1
-
-CYPRESS_VEGA_WALLET_API_TOKEN=