SDK Reference

import { configureApi, getSDKInfo, SDK_NAME, SDK_VERSION, api } from '@coin-communities/sdk';

function configureApi(options: ConfigureApiOptions): void

import { configureApi } from '@coin-communities/sdk';
 
configureApi({
  baseUrl: 'https://api.coin-communities.xyz',
  headers: { 'x-api-key': 'YOUR_API_KEY' },
});

function getSDKInfo(): SDKInfo

import { getSDKInfo } from '@coin-communities/sdk';
 
const info = getSDKInfo();
// { name: '@coin-communities/sdk', version: '0.0.8', platform: 'react' }

configureApi({
  baseUrl: 'https://api.coin-communities.xyz',
  headers: { 'x-api-key': process.env.CC_API_KEY },
});

configureApi({
  baseUrl: 'https://api.coin-communities.xyz',
  auth: () => sessionStorage.getItem('token') ?? '',
});

type ConfigureApiOptions = Pick<Config, 'baseUrl' | 'fetch' | 'headers' | 'auth'>;

interface SDKInfo {
  name: string;
  version: string;
  platform: Platform;
}

type Platform = 'react' | 'react-native' | 'node';

const SDK_NAME: string

const SDK_VERSION: string

import { configureApi, api } from '@coin-communities/sdk';
 
configureApi({
  baseUrl: 'https://api.coin-communities.xyz',
  headers: { 'x-api-key': 'YOUR_KEY' },
});
 
const { data, error } = await api.getCommunity({
  path: { token_address: '7eYw...' },
});
 
if (error) {
  console.error('failed', error.message);
} else {
  console.log(data.community.tokenAddress);
}

// Path params
await api.getCommunity({ path: { token_address: '7eYw...' } });
 
// Query params
await api.getMessages({ path: { token_address: '7eYw...' }, query: { limit: 50 } });
 
// Body
await api.postMessage({
  path: { token_address: '7eYw...' },
  body: { content: 'gm', chainId: 'solana', walletAddress: 'YourWalletPubkey' },
});

import { CommunityRealtimeClient } from '@coin-communities/sdk/react-query';
// or
import { CommunityRealtimeClient } from '@coin-communities/sdk/react';

const client = CommunityRealtimeClient.getOrCreate({
  baseUrl: 'https://api.coin-communities.xyz',
  tokenAddress: '7eYw...',
  auth: async () => {
    const { data } = await api.getWsTicket({ path: { token_address: '7eYw...' } });
    return data?.ticket ?? null;
  },
});
 
const dispose = client.subscribe({
  onMessage: (event) => console.log('new message', event),
  onLike:    (event) => console.log('like update', event),
  onConnect:    () => console.log('connected'),
  onDisconnect: () => console.log('disconnected'),
});
 
// Later:
dispose(); // unsubscribe this handler (connection shared with other subscribers)

import { useCommunityEvents } from '@coin-communities/sdk/react-query';
 
useCommunityEvents(tokenAddress, {
  auth: async () => { /* return ws ticket */ },
  onMessage: (event) => { /* ... */ },
  onLike:    (event) => { /* ... */ },
});

type Community = {
  id: string;
  tokenAddress: string;
  createdAt: string;
};

type TopCommunity = {
  tokenAddress: string;
  tokenSymbol?: string | null;
  tokenImageUrl?: string | null;
  memberCount: number;
  postCount: number;
  totalLikes: number;
  latestPostAt: number; // Unix ms
};

type Message = {
  id: string;
  communityId: string;
  businessId: string;
  userId: string;
  tokenAddress: string;
  content: string;
  mediaUrl?: string | null;
  walletAddress: string;
  username: string;
  userTwitterUrl: string;
  profileImageUrl?: string | null;
  followerCount: number;
  likeCount: number;
  liked: boolean;
  replyCount: number;
  parentMessageId?: string | null;
  isSpam: boolean;
  isHarmful: boolean;
  createdAt: string;
};

type FeedItem = {
  id: string;
  communityId: string;
  tokenAddress: string;
  tokenSymbol?: string | null;
  tokenImageUrl?: string | null;
  content: string;
  mediaUrl?: string | null;
  username: string;
  profileImageUrl?: string | null;
  userTwitterUrl: string;
  followerCount: number;
  likeCount: number;
  liked: boolean;
  replyCount: number;
  createdAt: string;
};

type User = {
  id: string;
  twitterId: string;
  username: string;
  profileImageUrl?: string | null;
  followerCount: number;
  followerCountSyncedAt?: string | null;
  nativeFollowerCount: number;
  nativeFollowingCount: number;
  createdAt: string;
};

type UserProfile = {
  id: string;
  username: string;
  profileImageUrl?: string | null;
  followerCount: number;
  nativeFollowerCount: number;
  nativeFollowingCount: number;
  createdAt: string;
};

type CommunityMember = {
  userId: string;
  username: string;
  profileImageUrl?: string | null;
  twitterUrl: string;
  followerCount: number;
  messageCount: number;
};

type WalletLink = {
  id: string;
  userId: string;
  businessId: string;
  address: string;
  chainType: ChainType;
  createdAt: string;
};

type ApiKey = {
  id: string;
  businessId: string;
  createdBy: string;
  name: string;
  keyPrefix: string;
  keyHash: string;
  lastUsedAt?: string | null;
  revokedAt?: string | null;
  createdAt: string;
};

type ApiKeyOrigin = {
  id: string;
  apiKeyId: string;
  origin: string;
  createdAt: string;
};

type WhitelistedCallback = {
  id: string;
  businessId: string;
  url: string;
  createdAt: string;
};

type MediaProvider = {
  id: string;
  name: string;
  logoUrl: string;
  searchUrl: string;
  domains: string[];
};

type ApiLogEvent = {
  apiKeyId: string;
  businessId: string;
  method: string;
  path: string;
  statusCode: number;
  latencyMs: number;
  createdAt: string;
};

type ChainId = 'solana' | 'ethereum' | 'base' | 'bsc';

type ChainType = 'evm' | 'svm';

type MessageSortField = 'time' | 'likes';

type MessageSortOrder = 'desc' | 'asc';

type ReportReason =
  | 'spam'
  | 'harassment'
  | 'hate_speech'
  | 'inappropriate_content'
  | 'other';

type PostMessageRequest = {
  content: string;           // required
  chainId: ChainId;          // required
  walletAddress: string;     // required — must be a linked wallet
  mediaUrl?: string | null;  // must be a URL from uploadCommunityMedia
};

type GetMessagesQuery = {
  before?: string | null;          // cursor (message id) for time-sorted pagination
  offset?: number | null;          // offset for likes-sorted pagination
  limit?: number | null;           // default 50, max 100
  sort?: MessageSortField | null;  // default 'time'
  order?: MessageSortOrder | null; // default 'desc'
  filterIsSpam?: boolean | null;   // exclude spam-classified messages
  filterIsHarm?: boolean | null;   // exclude harm-classified messages
};

type GetRepliesQuery = {
  before?: string | null;          // cursor (reply id) for pagination
  limit?: number | null;
  order?: MessageSortOrder | null; // default 'desc'
};

type ReportMessageRequest = {
  reason: ReportReason;  // required
  text?: string | null;  // required when reason is 'other'
};

type GetLogsParams = {
  apiKeyId?: string | null;    // filter to a specific API key
  method?: string | null;      // HTTP method e.g. 'GET'
  path?: string | null;        // request path prefix
  statusClass?: number | null; // 2 = 2xx, 4 = 4xx, 5 = 5xx
  startTime?: string | null;   // ISO-8601 lower bound
  endTime?: string | null;     // ISO-8601 upper bound
  limit?: number;
  offset?: number;             // default 0
};

type LinkWalletRequest = {
  address: string;      // required — wallet public address
  chainType: ChainType; // required
  signature: string;    // required — signature over the nonce from walletChallenge
};

type WalletChallengeRequest = {
  address: string;      // required
  chainType: ChainType; // required
};

type TwitterAuthUrlQuery = {
  redirectUrl: string; // required — must be whitelisted in your business dashboard
};

type TwitterChallengeExchangeRequest = {
  challengeCode: string; // single-use, short-lived
};

type UploadMediaRequest = {
  contentType: string; // e.g. 'image/jpeg'
  data: string;        // base64-encoded file content
};

type AddOriginRequest = {
  origin: string; // e.g. 'https://app.example.com' — no path, no trailing slash
};