Engineering · source map

Related code. Unverified deployment.

This page maps the repository as reviewed on 2026-11-04. It distinguishes adjacent packages, mock paths, and research folders instead of implying one connected production pipeline.

Reviewed commitb7207a8177b4d9a564bf3596b8c450372d5d050bOpen commit ↗

Source-level relationships

One repo, several boundaries.

The diagram is a navigable source map. Its key distinguishes unverified relationships from a simulated path.

Interactive source map

Related code. Unverified deployment.

Amber dashes mark source-level or unverified relationships; the red dash pattern marks a simulated path. Choose a node to inspect its evidence and boundary.

  • Source-level or unverified relationship
  • Simulated path
  • Selectable source component
Implemented

Browser application

A React, TypeScript, and Vite app lives under LokiAi/. It contains portfolio, agent, and cross-chain views.

Boundary: Some displayed values and the cross-chain completion state are simulated. A rendered interface does not prove a wallet action or transaction occurred.

Text equivalent

  1. Browser application

    Implemented

    A React, TypeScript, and Vite app lives under LokiAi/. It contains portfolio, agent, and cross-chain views.

    Boundary: Some displayed values and the cross-chain completion state are simulated. A rendered interface does not prove a wallet action or transaction occurred.

  2. API service

    Prototype

    A separate Node/Express server defines API routes and Socket.IO setup, with MongoDB-related packages in its own manifest.

    Boundary: No external database or deployed API was connected during this source review; secrets and local configuration are not part of this website.

  3. Agent orchestration

    Prototype

    The frontend service layer defines an orchestrator and specialist agent interfaces; a separate backend also contains agent modules.

    Boundary: These modules are described as code areas, not a claim that every agent is deployed, funded, or connected to live market data.

  4. Event updates

    Prototype

    The API server imports and configures Socket.IO alongside its HTTP service.

    Boundary: A server-side event path is not a verified production feed or a source of live trading state.

  5. Task gateway

    Prototype

    A separate FastAPI application exposes Celery-backed task handling.

    Boundary: The broker, worker, and app were not verified as a single running deployment in this review.

  6. Portfolio rebalancer

    Simulated

    The Python engine calculates allocation deviations and produces candidate rebalance recommendations.

    Boundary: Its execution method explicitly calls a simulated trade path; it is not evidence of a bridge or exchange transaction.

  7. Database and persistence

    Prototype

    MongoDB-oriented client, service, and model files appear in separate packages; their external endpoint and integrated runtime were not verified.

    Boundary: A dependency or model file is not evidence of a running production database. No connection string or credential is included here.

  8. Solidity contract set

    Simulated

    Arbitrage, yield, risk, and portfolio-rebalancing contract sources are present under loki-contracts/contracts/.

    Boundary: Mock paths in source are not an audit, deployment, or guarantee of execution. No live address is presented here.

Source snapshot: https://github.com/THE-SHRIKS/WallStreet/tree/b7207a8177b4d9a564bf3596b8c450372d5d050b/. The links above are pinned to the reviewed commit; use the latest-source links in the footer for newer changes.

Three source paths

Trace the code. Stop at the boundary.

These are useful ways to read the source, not evidence that a live service is running.

A

From interface to an agent-shaped result

  1. 1
    React/Vite views

    The browser app presents portfolio and agent surfaces. Some displayed states are seeded or simulated.

    LokiAi/src/App.tsx
  2. 2
    Service and orchestration code

    The repository contains an agent orchestrator and distinct backend agent modules.

    LokiAi/src/services/agents/agent-orchestrator.ts
  3. 3
    Data and runtime boundary

    Separate API, database, event, and model packages appear in the tree; this review did not verify one end-to-end deployment.

    LokiAi/backend/server.js

Not verified A rendered result is not a source of live financial state.

B

From a rebalance proposal to an execution boundary

  1. 1
    Allocation comparison

    The Python engine calculates deviations and proposes a rebalancing shape.

    portfolio_rebalancer/rebalance_engine.py
  2. 2
    Simulated trade path

    The implementation explicitly describes its trade execution as simulated.

    Simulated
  3. 3
    Contract prototypes

    Solidity files describe related interfaces and state transitions, but no deployed address or settled transaction is asserted.

    loki-contracts/contracts/PortfolioRebalancer.sol

Simulated A proposed allocation is not a signed order, bridge receipt, or transaction.

C

From displayed state to an update boundary

  1. 1
    Browser views

    Dashboard and cross-chain screens render application state; some repository views also import a mock-data module.

    LokiAi/src/pages/CrossChain.tsxLokiAi/src/data/mockData.ts
  2. 2
    Server-side event setup

    The separate Node server configures Socket.IO alongside HTTP routes.

    LokiAi/backend/server.js
  3. 3
    Connection remains unverified

    This review did not establish that the displayed page receives a live event subscription or market feed.

Not verified A rendered update is not proof of a live source or settled transaction.

Infrastructure and runtimes

Different packages. Different assumptions.

Compose files, reverse-proxy configs, and service manifests describe alternatives. This review did not verify one all-in-one production topology.

03

Compose and reverse proxy

Variants are not a canonical launch recipe

Compose variants group different service sets, while NGINX files hold alternate serving and routing rules. Multiple root and LokiAi variants exist; none is a verified canonical startup recipe. Choose a package intentionally and verify its environment; this website starts none of them.

Solidity · four source files

Contract surfaces, with the mock paths left visible.

Names below come from the repository. A local compile or passing unit test would not replace a security audit or establish a live deployment.

01

ArbitrageBot

An arbitrage-oriented contract prototype with source-level mock execution paths.

Inputs
Token pair, amount, and named venue labels enter the opportunity and execution methods.
State and events
Venue configuration, opportunity records, and aggregate counters are stored; source events include OpportunityDetected and ArbitrageExecuted.

Price and trade helpers are explicitly mocked. An event or recorded counter is not proof of a live route, executable liquidity, or net profitability.

loki-contracts/contracts/ArbitrageBot.sol
02

YieldOptimizer

A strategy-selection and yield-optimization contract prototype.

Inputs
The execution method accepts a user address, token address, and amount; strategy records include protocol and risk fields.
State and events
The source stores strategy metadata and user-position records; events include YieldOptimized and StrategyExecuted.

Selection and protocol execution are explicitly mocked, including a 1:1 output path. Stored fields do not represent current offers or realized yield.

loki-contracts/contracts/YieldOptimizer.sol
03

RiskManager

A contract prototype for risk-score thresholds and related state changes.

Inputs
Risk assessment accepts a user address and evaluates source-held position records against configured score markers.
State and events
Assessment, metrics, and alert state are stored; the source emits RiskAssessed, RiskAlert, and RiskParametersUpdated.

Some liquidity and volatility calculations are mocked. A threshold is not a security review, an oracle guarantee, or a promise that loss can be prevented.

loki-contracts/contracts/RiskManager.sol
04

PortfolioRebalancer

A contract prototype that represents portfolio-rebalance operations.

Inputs
Strategy creation accepts a user, target allocation records, a threshold, and an auto-rebalance flag; other methods operate on a user portfolio.
State and events
Portfolio allocations, strategies, and pending action records are stored; events include StrategyCreated, RebalanceTriggered, and PortfolioRebalanced.

Current-value and action paths are mocked. No exchange transfer, wallet read, or settled on-chain rebalance is claimed.

loki-contracts/contracts/PortfolioRebalancer.sol

Commit-pinned code map

Open the file behind the claim.

Every source link points to the reviewed snapshot. The repository link in the global navigation follows the latest default branch.

Evidence register

What this snapshot establishes—and what it does not.

Every state below is a source-level description pinned to the reviewed commit, not an operational service check.

Source review b7207a8 · 2026-11-04
AreaStatusEvidence boundarySource
Browser applicationImplementedA React, TypeScript, and Vite application is present under LokiAi/.LokiAi/package.json
API servicePrototypeA separate Node/Express service includes API and Socket.IO wiring.LokiAi/backend/server.js
Database and persistencePrototypeMongoDB-facing service and model modules are present; an external database connection was not verified during this review.LokiAi/src/services/database/mongodb-service.ts
Portfolio workflowSimulatedThe Python rebalancer explicitly describes its trade path as simulated rather than a live DEX or bridge transaction.portfolio_rebalancer/rebalance_engine.py
Solidity contractsSimulatedFour contract sources are present. Their mock paths and tests do not establish a deployed, audited protocol.loki-contracts/contracts/ArbitrageBot.sol
Deployment statusNot verifiedThis review did not verify a public production domain, deployed contract address, or audited release.README.md

Security and trust

Intent is not enforcement.

Wallet, risk, and contract modules are engineering surfaces—not independently audited or verified production controls. This website excludes credential values and private configuration. Maintainers should review sensitive materials privately before a public release.