feat: individual connect account dashboard page (#92)

Author: Benzilla

apps/api/src/routes/accounts.routes.ts

@@ -58,8 +58,8 @@ async function PopulateAccountResources(
     account.individual = person;
   }
 
-  // External accounts and login links are only returned when controller.is_controller is true
-  if (isPlatformRequest && account.controller?.is_controller) {
+  // External accounts and login links are returned for platform/controller requests
+  if (isPlatformRequest) {
     const [externalWallets, loginLinkRecords] = await Promise.all([
       externalWalletModule.GetExternalWalletsByAccount(account.id),
       loginLinkModule.GetLoginLinksByAccount(account.id),

apps/api/src/routes/balanceTransactions.routes.ts

@@ -9,6 +9,7 @@ import { db } from '../modules/Database';
 import { BalanceTransactionModule } from '../modules/BalanceTransaction';
 import { AccountModule } from '../modules/Account';
 import { CanAccessAccount } from '../modules/PlatformAccess';
+import { OptionalConnectedAccount } from '../middleware/Authorization';
 
 const router = express.Router();
 
@@ -34,10 +35,15 @@ const accountModule = new AccountModule(db);
  */
 router.get(
   '/',
+  OptionalConnectedAccount('zoneless-account'),
   AsyncHandler(async (req: express.Request, res: express.Response) => {
-    const accountId = req.user.account;
+    // Platforms may pass Zoneless-Account to list a connected account's transactions
+    const accountId = req.connectedAccount?.id ?? req.user.account;
 
-    Logger.info('Listing balance transactions', { accountId });
+    Logger.info('Listing balance transactions', {
+      accountId,
+      onBehalf: !!req.connectedAccount,
+    });
 
     const limit = req.query.limit
       ? parseInt(req.query.limit as string, 10)

apps/api/src/routes/payouts.routes.ts

@@ -12,6 +12,7 @@ import {
   RequirePlatform,
   RequireResourceOwnership,
   RequireConnectedAccountOwnership,
+  OptionalConnectedAccount,
 } from '../middleware/Authorization';
 import {
   CreatePayoutSchema,
@@ -289,6 +290,7 @@ router.get(
  */
 router.get(
   '/',
+  OptionalConnectedAccount('zoneless-account'),
   AsyncHandler(async (req: express.Request, res: express.Response) => {
     const limit = req.query.limit
       ? parseInt(req.query.limit as string, 10)
@@ -313,9 +315,22 @@ router.get(
       | undefined;
 
     try {
-      // For platforms, get payouts for all connected accounts using platform_account
-      // For connected accounts, only get their own payouts
-      if (req.user.platform) {
+      // Platform acting on behalf of a connected account
+      if (req.connectedAccount) {
+        const result = await payoutModule.ListPayouts({
+          account: req.connectedAccount.id,
+          limit,
+          startingAfter,
+          endingBefore,
+          status: statusFilter,
+          destination,
+          created,
+          arrivalDate,
+        });
+
+        res.json(result);
+      } else if (req.user.platform) {
+        // For platforms, get payouts for all connected accounts using platform_account
         const result = await payoutModule.ListPayoutsByPlatform({
           platformAccount: req.user.account,
           limit,

apps/api/src/routes/transfers.routes.ts

@@ -22,6 +22,7 @@ import { ValidateRequest } from '../middleware/ValidateRequest';
 import {
   RequirePlatform,
   RequireResourceOwnership,
+  OptionalConnectedAccount,
 } from '../middleware/Authorization';
 import {
   CreateTransferSchema,
@@ -131,12 +132,44 @@ const requireTransferReadAccess = AsyncHandler(
 router.post(
   '/',
   RequirePlatform(),
+  OptionalConnectedAccount('zoneless-account'),
   ValidateRequest(CreateTransferSchema),
   AsyncHandler(async (req: express.Request, res: express.Response) => {
     const platformAccountId = req.user.account;
     const { destination } = req.body;
 
-    // Verify the destination account belongs to this platform
+    // Pull funds: platform acts on behalf of connected account → platform balance
+    if (req.connectedAccount) {
+      if (destination !== platformAccountId) {
+        throw new AppError(
+          'When using Zoneless-Account, destination must be the platform account.',
+          ERRORS.INVALID_REQUEST.status,
+          ERRORS.INVALID_REQUEST.type
+        );
+      }
+
+      Logger.info('Creating pull-funds transfer', {
+        account: req.connectedAccount.id,
+        amount: req.body.amount,
+        destination: platformAccountId,
+      });
+
+      const transfer = await transferModule.CreateTransfer(
+        req.connectedAccount.id,
+        req.body
+      );
+
+      Logger.info('Pull-funds transfer created successfully', {
+        transferId: transfer.id,
+        amount: transfer.amount,
+        destination: transfer.destination,
+      });
+
+      res.status(201).json(transfer);
+      return;
+    }
+
+    // Add funds: platform → connected account
     const destinationAccount = await accountModule.GetAccount(destination);
 
     if (!destinationAccount) {

apps/web/src/app/core/services/api.service.ts

@@ -6,6 +6,8 @@ export interface ApiOptions {
   timeout?: number;
   retries?: number;
   retryDelay?: number;
+  /** Act on behalf of a connected account (sends Zoneless-Account header) */
+  zonelessAccount?: string;
 }
 
 const DEFAULT_TIMEOUT = 30000; // 30 seconds
@@ -42,7 +44,8 @@ export class ApiService {
           method,
           endpoint,
           parameters,
-          timeout
+          timeout,
+          options.zonelessAccount
         );
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
@@ -67,7 +70,8 @@ export class ApiService {
     method: string,
     endpoint: string,
     parameters: object,
-    timeout: number
+    timeout: number,
+    zonelessAccount?: string
   ): Promise<T> {
     const cleanEndpoint = endpoint.startsWith('/')
       ? endpoint.substring(1)
@@ -78,20 +82,23 @@ export class ApiService {
     const timeoutId = setTimeout(() => controller.abort(), timeout);
 
     try {
-      const options: RequestInit = {
-        method: method,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        signal: controller.signal,
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
       };
 
       const token = this.storage.GetItemString('auth_token');
       if (token) {
-        (options.headers as Record<string, string>)[
-          'Authorization'
-        ] = `Bearer ${token}`;
+        headers['Authorization'] = `Bearer ${token}`;
       }
+      if (zonelessAccount) {
+        headers['Zoneless-Account'] = zonelessAccount;
+      }
+
+      const options: RequestInit = {
+        method: method,
+        headers,
+        signal: controller.signal,
+      };
 
       if (method.toUpperCase() === 'GET') {
         const urlParams = new URLSearchParams(

apps/web/src/app/data/services/account.service.ts

@@ -17,14 +17,8 @@ export class AccountService {
   account: WritableSignal<Account | null> = signal(null);
   loading: WritableSignal<boolean> = signal(false);
 
-  // Connected account selection state (for viewing connected accounts in panel)
-  selectedConnectedAccount: WritableSignal<Account | null> = signal(null);
-  loadingConnectedAccount: WritableSignal<boolean> = signal(false);
-
   Reset(): void {
     this.account.set(null);
-    this.selectedConnectedAccount.set(null);
-    this.loadingConnectedAccount.set(false);
   }
 
   async GetAccount(): Promise<Account | null> {
@@ -53,7 +47,10 @@ export class AccountService {
         `accounts/${accountId}`,
         data
       );
-      this.account.set(account);
+      // Only update the signed-in account signal when editing self
+      if (this.account()?.id === accountId) {
+        this.account.set(account);
+      }
       return account;
     } finally {
       this.loading.set(false);
@@ -87,34 +84,10 @@ export class AccountService {
   }
 
   /**
-   * Fetch any account by ID (used for viewing connected accounts).
-   * Sets the selectedConnectedAccount signal for panel display.
-   */
-  async LoadConnectedAccount(accountId: string): Promise<Account | null> {
-    this.loadingConnectedAccount.set(true);
-    this.selectedConnectedAccount.set(null);
-
-    try {
-      const account = await this.api.Call<Account>(
-        'GET',
-        `accounts/${accountId}`
-      );
-      this.selectedConnectedAccount.set(account);
-      return account;
-    } catch (error) {
-      console.error('Failed to load connected account:', error);
-      this.selectedConnectedAccount.set(null);
-      return null;
-    } finally {
-      this.loadingConnectedAccount.set(false);
-    }
-  }
-
-  /**
-   * Clear the selected connected account.
+   * Fetch a connected account by ID.
    */
-  ClearSelectedConnectedAccount(): void {
-    this.selectedConnectedAccount.set(null);
+  async GetConnectedAccount(accountId: string): Promise<Account> {
+    return this.api.Call<Account>('GET', `accounts/${accountId}`);
   }
 
   /**

apps/web/src/app/data/services/balance.service.ts

@@ -19,11 +19,18 @@ export class BalanceService {
     this.balanceDetails.set(null);
   }
 
-  async GetBalance(): Promise<Balance> {
+  async GetBalance(zonelessAccount?: string): Promise<Balance> {
     this.loading.set(true);
     try {
-      const balance = await this.api.Call<Balance>('GET', 'balance');
-      this.balance.set(balance);
+      const balance = await this.api.Call<Balance>(
+        'GET',
+        'balance',
+        {},
+        zonelessAccount ? { zonelessAccount } : undefined
+      );
+      if (!zonelessAccount) {
+        this.balance.set(balance);
+      }
       return balance;
     } finally {
       this.loading.set(false);

apps/web/src/app/data/services/index.ts

@@ -17,5 +17,6 @@ export * from './setup.service';
 export * from './subscription.service';
 export * from './telemetry.service';
 export * from './topup.service';
+export * from './transfer.service';
 export * from './transaction.service';
 export * from './webhook-endpoint.service';

apps/web/src/app/data/services/person.service.ts

@@ -98,8 +98,15 @@ export class PersonService {
     const lines: string[] = [];
     if (person.address.line1) lines.push(person.address.line1);
     if (person.address.line2) lines.push(person.address.line2);
-    if (person.address.city) lines.push(person.address.city);
-    if (person.address.postal_code) lines.push(person.address.postal_code);
+
+    const cityState = [person.address.city, person.address.state]
+      .filter(Boolean)
+      .join(', ');
+    const locality = [cityState, person.address.postal_code]
+      .filter(Boolean)
+      .join(' ');
+    if (locality) lines.push(locality);
+
     if (person.address.country) {
       const countryName = GetCountryName(person.address.country);
       lines.push(countryName || person.address.country);

apps/web/src/app/data/services/transfer.service.ts

@@ -0,0 +1,35 @@
+import { Injectable, inject } from '@angular/core';
+import { ApiService } from '../../core';
+import type { Transfer } from '@zoneless/shared-types';
+import type { CreateTransferInput } from '@zoneless/shared-schemas';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TransferService {
+  private readonly api = inject(ApiService);
+
+  /**
+   * Create a transfer from the platform balance to a connected account.
+   */
+  async CreateTransfer(input: CreateTransferInput): Promise<Transfer> {
+    return this.api.Call<Transfer>('POST', 'transfers', input);
+  }
+
+  /**
+   * Create a transfer on behalf of a connected account (Zoneless-Account header).
+   * The connected account is the source; destination is typically the platform.
+   */
+  async CreateTransferForConnectedAccount(
+    connectedAccountId: string,
+    input: CreateTransferInput
+  ): Promise<Transfer> {
+    return this.api.Call<Transfer>('POST', 'transfers', input, {
+      zonelessAccount: connectedAccountId,
+    });
+  }
+
+  async GetTransfer(transferId: string): Promise<Transfer> {
+    return this.api.Call<Transfer>('GET', `transfers/${transferId}`);
+  }
+}