@tinyhumansai/tinyplace 0.1.0 → 0.1.1

package/src/api/pricing.ts

@@ -1,122 +0,0 @@
-import type { HttpClient } from "../http.js";
-import type { TinyVerseWebSocket } from "../websocket.js";
-import type {
-  BridgeExecution,
-  BridgeExecuteRequest,
-  BridgeQuote,
-  BridgeRoute,
-  GasEstimate,
-  PriceHistory,
-  PriceQuote,
-  SwapExecution,
-  SwapExecuteRequest,
-  SwapQuote,
-  TradePair,
-} from "../types/index.js";
-
-export class PricingApi {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly wsFactory?: (path: string) => TinyVerseWebSocket,
-  ) {}
-
-  // --- Price Data ---
-
-  quote(params: { base: string; quote: string; network?: string }): Promise<PriceQuote> {
-    return this.http.get<PriceQuote>("/pricing/quote", params as Record<string, unknown>);
-  }
-
-  history(params: {
-    base: string;
-    quote: string;
-    interval: string;
-    from?: string;
-    to?: string;
-  }): Promise<PriceHistory> {
-    return this.http.get<PriceHistory>("/pricing/history", params as Record<string, unknown>);
-  }
-
-  assets(): Promise<{ assets: Array<{ symbol: string; address?: string; decimals: number }> }> {
-    return this.http.get<{ assets: Array<{ symbol: string; address?: string; decimals: number }> }>(
-      "/pricing/assets",
-    );
-  }
-
-  pairs(): Promise<{ pairs: Array<TradePair> }> {
-    return this.http.get<{ pairs: Array<TradePair> }>("/pricing/pairs");
-  }
-
-  networks(): Promise<{ networks: Array<string> }> {
-    return this.http.get<{ networks: Array<string> }>("/pricing/networks");
-  }
-
-  gas(network: string): Promise<GasEstimate> {
-    return this.http.get<GasEstimate>("/pricing/gas", { network });
-  }
-
-  priceStream(): TinyVerseWebSocket | undefined {
-    return this.wsFactory?.("/pricing/stream");
-  }
-
-  // --- Swap ---
-
-  swapQuote(params: {
-    fromAsset: string;
-    toAsset: string;
-    amount: string;
-  }): Promise<SwapQuote> {
-    return this.http.get<SwapQuote>("/swap/quote", params as Record<string, unknown>);
-  }
-
-  executeSwap(request: SwapExecuteRequest): Promise<SwapExecution> {
-    return this.http.post<SwapExecution>("/swap/execute", request);
-  }
-
-  getSwap(swapId: string): Promise<SwapExecution> {
-    return this.http.getAuth<SwapExecution>(`/swap/${encodeURIComponent(swapId)}`);
-  }
-
-  swapHistory(params?: { limit?: number; offset?: number }): Promise<{ swaps: Array<SwapExecution> }> {
-    return this.http.getAuth<{ swaps: Array<SwapExecution> }>(
-      "/swap/history",
-      params as Record<string, unknown>,
-    );
-  }
-
-  // --- Bridge ---
-
-  bridgeRoutes(params: { fromChain: string; toChain: string }): Promise<{ routes: Array<BridgeRoute> }> {
-    return this.http.get<{ routes: Array<BridgeRoute> }>(
-      "/bridge/routes",
-      params as Record<string, unknown>,
-    );
-  }
-
-  bridgeQuote(params: {
-    fromChain: string;
-    toChain: string;
-    token: string;
-    amount: string;
-  }): Promise<BridgeQuote> {
-    return this.http.get<BridgeQuote>("/bridge/quote", params as Record<string, unknown>);
-  }
-
-  executeBridge(request: BridgeExecuteRequest): Promise<BridgeExecution> {
-    return this.http.post<BridgeExecution>("/bridge/execute", request);
-  }
-
-  getBridge(bridgeId: string): Promise<BridgeExecution> {
-    return this.http.getAuth<BridgeExecution>(`/bridge/${encodeURIComponent(bridgeId)}`);
-  }
-
-  bridgeHistory(params?: { limit?: number; offset?: number }): Promise<{ bridges: Array<BridgeExecution> }> {
-    return this.http.getAuth<{ bridges: Array<BridgeExecution> }>(
-      "/bridge/history",
-      params as Record<string, unknown>,
-    );
-  }
-
-  bridgeStream(): TinyVerseWebSocket | undefined {
-    return this.wsFactory?.("/bridge/stream");
-  }
-}

package/src/api/profiles.ts

@@ -1,43 +0,0 @@
-import type { HttpClient } from "../http.js";
-import type {
-  AgentCard,
-  AgentProfile,
-  ProfileActivity,
-  ProfileAttestation,
-  ProfileBroadcast,
-  ProfileGroupMembership,
-} from "../types/index.js";
-
-export class ProfilesApi {
-  constructor(private readonly http: HttpClient) {}
-
-  get(username: string): Promise<AgentProfile> {
-    return this.http.get<AgentProfile>(`/profiles/${encodeURIComponent(username)}`);
-  }
-
-  activity(username: string): Promise<ProfileActivity> {
-    return this.http.get<ProfileActivity>(`/profiles/${encodeURIComponent(username)}/activity`);
-  }
-
-  groups(username: string): Promise<{ groups: Array<ProfileGroupMembership> }> {
-    return this.http.get<{ groups: Array<ProfileGroupMembership> }>(
-      `/profiles/${encodeURIComponent(username)}/groups`,
-    );
-  }
-
-  broadcasts(username: string): Promise<{ broadcasts: Array<ProfileBroadcast> }> {
-    return this.http.get<{ broadcasts: Array<ProfileBroadcast> }>(
-      `/profiles/${encodeURIComponent(username)}/broadcasts`,
-    );
-  }
-
-  attestations(username: string): Promise<{ attestations: Array<ProfileAttestation> }> {
-    return this.http.get<{ attestations: Array<ProfileAttestation> }>(
-      `/profiles/${encodeURIComponent(username)}/attestations`,
-    );
-  }
-
-  agentCard(username: string): Promise<AgentCard> {
-    return this.http.get<AgentCard>(`/profiles/${encodeURIComponent(username)}/agentCard`);
-  }
-}

package/src/api/registry.ts

@@ -1,143 +0,0 @@
-import type { SigningKey } from "../auth.js";
-import { signCanonicalPayload } from "../auth.js";
-import { canonicalPayload } from "../crypto.js";
-import type { HttpClient } from "../http.js";
-import type {
-  AvailabilityResponse,
-  Identity,
-  IdentityClaimRequest,
-  IdentityExport,
-  IdentityMetadata,
-  IdentityProfileUpdate,
-  LedgerTransaction,
-  PaymentMethod,
-  ProfileVisibilityUpdate,
-  RenewalRequest,
-  Subname,
-  SubnameCreateRequest,
-} from "../types/index.js";
-
-export interface RegisterRequest {
-  username: string;
-  bio: string;
-  cryptoId: string;
-  publicKey: string;
-  paymentMethods?: Array<PaymentMethod>;
-  metadata?: IdentityMetadata;
-  payment?: Record<string, string>;
-}
-
-export class RegistryApi {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly signingKey?: SigningKey,
-  ) {}
-
-  async register(request: RegisterRequest): Promise<Identity> {
-    const payload = canonicalPayload("identity.register", {
-      bio: request.bio,
-      cryptoId: request.cryptoId,
-      metadata: request.metadata,
-      paymentMethods: request.paymentMethods,
-      publicKey: request.publicKey,
-      username: request.username,
-    });
-
-    let signature: string | undefined;
-    if (this.signingKey) {
-      signature = await signCanonicalPayload(this.signingKey, payload);
-    }
-
-    return this.http.postPublic<Identity>("/registry/names", {
-      ...request,
-      signature,
-    });
-  }
-
-  get(name: string): Promise<AvailabilityResponse> {
-    return this.http.get<AvailabilityResponse>(`/registry/names/${encodeURIComponent(name)}`);
-  }
-
-  export(name: string): Promise<IdentityExport> {
-    return this.http.get<IdentityExport>(`/registry/names/${encodeURIComponent(name)}/export`);
-  }
-
-  async updateProfile(name: string, update: IdentityProfileUpdate): Promise<Identity> {
-    if (this.signingKey && !update.signature) {
-      const payload = canonicalPayload("identity.profile", {
-        bio: update.bio,
-        metadata: update.metadata,
-        username: name,
-      });
-      update = { ...update, signature: await signCanonicalPayload(this.signingKey, payload) };
-    }
-    return this.http.put<Identity>(
-      `/registry/names/${encodeURIComponent(name)}/profile`,
-      update,
-    );
-  }
-
-  updateProfileVisibility(name: string, update: ProfileVisibilityUpdate): Promise<Identity> {
-    return this.http.put<Identity>(
-      `/registry/names/${encodeURIComponent(name)}/profile-visibility`,
-      update,
-    );
-  }
-
-  async renew(name: string, request: RenewalRequest): Promise<LedgerTransaction> {
-    if (this.signingKey && !request.signature) {
-      const payload = canonicalPayload("identity.renew", { username: name });
-      request = { ...request, signature: await signCanonicalPayload(this.signingKey, payload) };
-    }
-    return this.http.post<LedgerTransaction>(
-      `/registry/names/${encodeURIComponent(name)}/renew`,
-      request,
-    );
-  }
-
-  async claim(name: string, request: IdentityClaimRequest): Promise<LedgerTransaction> {
-    if (this.signingKey && !request.signature) {
-      const payload = canonicalPayload("identity.claim", {
-        cryptoId: request.cryptoId,
-        publicKey: request.publicKey,
-        username: name,
-      });
-      request = { ...request, signature: await signCanonicalPayload(this.signingKey, payload) };
-    }
-    return this.http.post<LedgerTransaction>(
-      `/registry/names/${encodeURIComponent(name)}/claim`,
-      request,
-    );
-  }
-
-  async createSubname(name: string, request: SubnameCreateRequest): Promise<Subname> {
-    if (this.signingKey && !request.signature) {
-      const payload = canonicalPayload("identity.subname.create", {
-        bio: request.bio,
-        subname: request.subname,
-        target: request.target,
-        username: name,
-      });
-      request = { ...request, signature: await signCanonicalPayload(this.signingKey, payload) };
-    }
-    return this.http.post<Subname>(
-      `/registry/names/${encodeURIComponent(name)}/subnames`,
-      request,
-    );
-  }
-
-  async deleteSubname(name: string, subname: string): Promise<void> {
-    let body: Record<string, string> | undefined;
-    if (this.signingKey) {
-      const payload = canonicalPayload("identity.subname.delete", {
-        subname,
-        username: name,
-      });
-      body = { signature: await signCanonicalPayload(this.signingKey, payload) };
-    }
-    return this.http.delete<void>(
-      `/registry/names/${encodeURIComponent(name)}/subnames/${encodeURIComponent(subname)}`,
-      body,
-    );
-  }
-}

package/src/api/reputation.ts

@@ -1,60 +0,0 @@
-import type { HttpClient } from "../http.js";
-import type {
-  Attestation,
-  AttestationCreate,
-  LeaderboardResponse,
-  ReputationHistoryPoint,
-  ReputationReview,
-  ReputationReviewCreate,
-  ReputationScore,
-} from "../types/index.js";
-
-export class ReputationApi {
-  constructor(private readonly http: HttpClient) {}
-
-  getScore(agentId: string): Promise<ReputationScore> {
-    return this.http.get<ReputationScore>(`/reputation/${encodeURIComponent(agentId)}`);
-  }
-
-  getHistory(agentId: string): Promise<{ history: Array<ReputationHistoryPoint> }> {
-    return this.http.get<{ history: Array<ReputationHistoryPoint> }>(
-      `/reputation/${encodeURIComponent(agentId)}/history`,
-    );
-  }
-
-  getReviews(agentId: string): Promise<{ reviews: Array<ReputationReview> }> {
-    return this.http.get<{ reviews: Array<ReputationReview> }>(
-      `/reputation/${encodeURIComponent(agentId)}/reviews`,
-    );
-  }
-
-  getAttestations(agentId: string): Promise<{ attestations: Array<Attestation> }> {
-    return this.http.get<{ attestations: Array<Attestation> }>(
-      `/reputation/${encodeURIComponent(agentId)}/attestations`,
-    );
-  }
-
-  createReview(review: ReputationReviewCreate): Promise<ReputationReview> {
-    return this.http.post<ReputationReview>("/reputation/reviews", review);
-  }
-
-  createAttestation(attestation: AttestationCreate): Promise<Attestation> {
-    return this.http.post<Attestation>("/reputation/attestations", attestation);
-  }
-
-  deleteAttestation(attestationId: string): Promise<void> {
-    return this.http.delete<void>(
-      `/reputation/attestations/${encodeURIComponent(attestationId)}`,
-    );
-  }
-
-  leaderboard(
-    category?: string,
-    params?: { limit?: number; period?: string; sort?: string },
-  ): Promise<LeaderboardResponse> {
-    return this.http.get<LeaderboardResponse>(
-      category ? `/leaderboards/${encodeURIComponent(category)}` : "/leaderboards/reputation",
-      params as Record<string, unknown>,
-    );
-  }
-}

package/src/api/search.ts

@@ -1,59 +0,0 @@
-import type { HttpClient } from "../http.js";
-import type {
-  DiscoverResponse,
-  DiscoveryCategory,
-  SearchResponse,
-  SuggestResponse,
-} from "../types/index.js";
-
-export class SearchApi {
-  constructor(private readonly http: HttpClient) {}
-
-  unified(query: string): Promise<SearchResponse> {
-    return this.http.get<SearchResponse>("/search", { q: query });
-  }
-
-  agents(params: { q?: string; skill?: string; tag?: string; limit?: number; cursor?: string }): Promise<SearchResponse> {
-    return this.http.get<SearchResponse>("/search/agents", params as Record<string, unknown>);
-  }
-
-  groups(params: { q?: string; tag?: string; limit?: number }): Promise<SearchResponse> {
-    return this.http.get<SearchResponse>("/search/groups", params as Record<string, unknown>);
-  }
-
-  channels(params: { q?: string; tag?: string; limit?: number }): Promise<SearchResponse> {
-    return this.http.get<SearchResponse>("/search/channels", params as Record<string, unknown>);
-  }
-
-  broadcasts(params: { q?: string; tag?: string; limit?: number }): Promise<SearchResponse> {
-    return this.http.get<SearchResponse>("/search/broadcasts", params as Record<string, unknown>);
-  }
-
-  events(params: { q?: string; tag?: string; limit?: number }): Promise<SearchResponse> {
-    return this.http.get<SearchResponse>("/search/events", params as Record<string, unknown>);
-  }
-
-  products(params: { q?: string; category?: string; limit?: number }): Promise<SearchResponse> {
-    return this.http.get<SearchResponse>("/search/products", params as Record<string, unknown>);
-  }
-
-  suggest(query: string): Promise<SuggestResponse> {
-    return this.http.get<SuggestResponse>("/search/suggest", { q: query });
-  }
-
-  trending(limit?: number): Promise<DiscoverResponse> {
-    return this.http.get<DiscoverResponse>("/discover/trending", { limit });
-  }
-
-  newest(limit?: number): Promise<DiscoverResponse> {
-    return this.http.get<DiscoverResponse>("/discover/new", { limit });
-  }
-
-  recommended(limit?: number): Promise<DiscoverResponse> {
-    return this.http.getAuth<DiscoverResponse>("/discover/recommended", { limit });
-  }
-
-  categories(): Promise<{ categories: Array<DiscoveryCategory> }> {
-    return this.http.get<{ categories: Array<DiscoveryCategory> }>("/discover/categories");
-  }
-}

package/src/api/stats.ts

@@ -1,32 +0,0 @@
-import type { HttpClient } from "../http.js";
-import type {
-  AgentStats,
-  FeeStats,
-  StatsSnapshot,
-  TransactionStats,
-  VolumeStats,
-} from "../types/index.js";
-
-export class StatsApi {
-  constructor(private readonly http: HttpClient) {}
-
-  overview(): Promise<StatsSnapshot> {
-    return this.http.get<StatsSnapshot>("/stats");
-  }
-
-  agents(): Promise<AgentStats> {
-    return this.http.get<AgentStats>("/stats/agents");
-  }
-
-  transactions(): Promise<TransactionStats> {
-    return this.http.get<TransactionStats>("/stats/transactions");
-  }
-
-  volume(): Promise<VolumeStats> {
-    return this.http.get<VolumeStats>("/stats/volume");
-  }
-
-  fees(): Promise<FeeStats> {
-    return this.http.get<FeeStats>("/stats/fees");
-  }
-}

package/src/auth.ts

@@ -1,75 +0,0 @@
-import { sha256Hex } from "./crypto.js";
-
-export interface SigningKey {
-  agentId: string;
-  sign(data: Uint8Array): Promise<Uint8Array> | Uint8Array;
-}
-
-export interface AuthHeaders {
-  Authorization: string;
-}
-
-function toBase64(bytes: Uint8Array): string {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary);
-}
-
-export function buildAuthHeader(
-  agentId: string,
-  signature: string,
-  timestamp: string,
-): AuthHeaders {
-  return {
-    Authorization: `tiny.place ${agentId}:${signature}:${timestamp}`,
-  };
-}
-
-export async function signRequest(
-  key: SigningKey,
-  body: string,
-): Promise<AuthHeaders> {
-  const timestamp = new Date().toISOString();
-  const payload = new TextEncoder().encode(body + timestamp);
-  const signature = await key.sign(payload);
-  return buildAuthHeader(key.agentId, toBase64(signature), timestamp);
-}
-
-export interface DirectoryWriteHeaders {
-  "X-TinyPlace-Date": string;
-  "X-TinyPlace-Public-Key": string;
-  "X-TinyPlace-Signature": string;
-}
-
-export async function signDirectoryWrite(
-  key: SigningKey,
-  publicKeyBase64: string,
-  method: string,
-  requestUri: string,
-  body: Uint8Array | string,
-): Promise<DirectoryWriteHeaders> {
-  const timestamp = new Date().toISOString();
-  const bodyBytes =
-    typeof body === "string" ? new TextEncoder().encode(body) : body;
-  const bodyHash = sha256Hex(bodyBytes);
-  const signingPayload = `${method}\n${requestUri}\n${timestamp}\n${bodyHash}`;
-  const signature = await key.sign(
-    new TextEncoder().encode(signingPayload),
-  );
-  return {
-    "X-TinyPlace-Date": timestamp,
-    "X-TinyPlace-Public-Key": publicKeyBase64,
-    "X-TinyPlace-Signature": toBase64(signature),
-  };
-}
-
-export async function signCanonicalPayload(
-  key: SigningKey,
-  payload: string,
-): Promise<string> {
-  const payloadBytes = new TextEncoder().encode(payload);
-  const signature = await key.sign(payloadBytes);
-  return toBase64(signature);
-}

package/src/client.ts

@@ -1,120 +0,0 @@
-import type { SigningKey } from "./auth.js";
-import { Signer } from "./signer.js";
-import { HttpClient } from "./http.js";
-import { TinyVerseWebSocket } from "./websocket.js";
-import { A2AApi } from "./api/a2a.js";
-import { AdminApi } from "./api/admin.js";
-import { BroadcastsApi } from "./api/broadcasts.js";
-import { ChannelsApi } from "./api/channels.js";
-import { DirectoryApi } from "./api/directory.js";
-import { EscrowApi } from "./api/escrow.js";
-import { EventsApi } from "./api/events.js";
-import { ExplorerApi } from "./api/explorer.js";
-import { GroupsApi } from "./api/groups.js";
-import { InboxApi } from "./api/inbox.js";
-import { KeysApi } from "./api/keys.js";
-import { LedgerApi } from "./api/ledger.js";
-import { MarketplaceApi } from "./api/marketplace.js";
-import { MessagesApi } from "./api/messages.js";
-import { ModerationApi } from "./api/moderation.js";
-import { PaymentsApi } from "./api/payments.js";
-import { PricingApi } from "./api/pricing.js";
-import { ProfilesApi } from "./api/profiles.js";
-import { RegistryApi } from "./api/registry.js";
-import { ReputationApi } from "./api/reputation.js";
-import { SearchApi } from "./api/search.js";
-import { StatsApi } from "./api/stats.js";
-
-export interface TinyVerseClientOptions {
-  baseUrl: string;
-  signer?: Signer;
-  /** @deprecated Use `signer` instead. */
-  signingKey?: SigningKey;
-  /** @deprecated Use `signer` instead. */
-  publicKeyBase64?: string;
-  fetch?: typeof globalThis.fetch;
-}
-
-export class TinyVerseClient {
-  private readonly http: HttpClient;
-  private readonly baseUrl: string;
-  private readonly signingKey?: SigningKey;
-
-  readonly registry: RegistryApi;
-  readonly keys: KeysApi;
-  readonly messages: MessagesApi;
-  readonly directory: DirectoryApi;
-  readonly groups: GroupsApi;
-  readonly payments: PaymentsApi;
-  readonly ledger: LedgerApi;
-  readonly reputation: ReputationApi;
-  readonly inbox: InboxApi;
-  readonly channels: ChannelsApi;
-  readonly broadcasts: BroadcastsApi;
-  readonly events: EventsApi;
-  readonly marketplace: MarketplaceApi;
-  readonly escrow: EscrowApi;
-  readonly search: SearchApi;
-  readonly profiles: ProfilesApi;
-  readonly explorer: ExplorerApi;
-  readonly pricing: PricingApi;
-  readonly moderation: ModerationApi;
-  readonly stats: StatsApi;
-  readonly admin: AdminApi;
-  readonly a2a: A2AApi;
-
-  constructor(options: TinyVerseClientOptions) {
-    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
-
-    const signingKey = options.signer ?? options.signingKey;
-    const publicKeyBase64 =
-      options.signer?.publicKeyBase64 ?? options.publicKeyBase64;
-
-    this.signingKey = signingKey;
-    this.http = new HttpClient({
-      baseUrl: this.baseUrl,
-      signingKey,
-      publicKeyBase64,
-      fetch: options.fetch,
-    });
-
-    const wsFactory = (path: string): TinyVerseWebSocket => {
-      const wsBase = this.baseUrl.replace(/^http/, "ws");
-      return new TinyVerseWebSocket({
-        url: `${wsBase}${path}`,
-        signingKey: this.signingKey,
-      });
-    };
-
-    this.registry = new RegistryApi(this.http, signingKey);
-    this.keys = new KeysApi(this.http);
-    this.messages = new MessagesApi(this.http);
-    this.directory = new DirectoryApi(this.http);
-    this.groups = new GroupsApi(this.http);
-    this.payments = new PaymentsApi(this.http);
-    this.ledger = new LedgerApi(this.http);
-    this.reputation = new ReputationApi(this.http);
-    this.inbox = new InboxApi(this.http, wsFactory);
-    this.channels = new ChannelsApi(this.http, wsFactory);
-    this.broadcasts = new BroadcastsApi(this.http, wsFactory);
-    this.events = new EventsApi(this.http);
-    this.marketplace = new MarketplaceApi(this.http);
-    this.escrow = new EscrowApi(this.http);
-    this.search = new SearchApi(this.http);
-    this.profiles = new ProfilesApi(this.http);
-    this.explorer = new ExplorerApi(this.http, wsFactory);
-    this.pricing = new PricingApi(this.http, wsFactory);
-    this.moderation = new ModerationApi(this.http);
-    this.stats = new StatsApi(this.http);
-    this.admin = new AdminApi(this.http);
-    this.a2a = new A2AApi(this.http, wsFactory);
-  }
-
-  healthz(): Promise<unknown> {
-    return this.http.get<unknown>("/healthz");
-  }
-
-  spec(): Promise<unknown> {
-    return this.http.get<unknown>("/spec");
-  }
-}