@autogames/sdk 1.1.1

package/dist/main.d.ts

@@ -0,0 +1,342 @@
+import { PersistOptions } from 'zustand/middleware';
+import { PrivyClientConfig } from '@privy-io/react-auth';
+import { StoreApi } from 'zustand';
+import { UseBoundStore } from 'zustand';
+
+export declare interface AuthState {
+    isAuthenticated: boolean;
+    isReady: boolean;
+    user: AutoGamesSDKUser | null;
+}
+
+/**
+ * Auth store state
+ */
+declare interface AuthStoreState {
+    accessToken: string | null;
+    accessTokenUpdatedAt: string | null;
+    user: AutoGamesSDKUser | null;
+    isAuthenticated: boolean;
+    isReady: boolean;
+    error: string | null;
+    isLoggingIn: boolean;
+    _privyInstance: PrivyInstance | null;
+    login: () => Promise<void>;
+    logout: () => Promise<void>;
+    setAccessToken: (token: string) => void;
+    setUser: (user: AutoGamesSDKUser) => void;
+    _setAuthState: (state: {
+        isReady: boolean;
+    }) => void;
+    _setPrivyInstance: (instance: PrivyInstance) => void;
+    _resolveLogin: (accessToken: string, user: AutoGamesSDKUser) => void;
+    _rejectLogin: (error: string) => void;
+}
+
+export declare const AutoGamesSDK: AutoGamesSDKClass;
+
+declare class AutoGamesSDKClass {
+    private static readonly DEFAULT_PRIVY_APP_ID;
+    private config;
+    private initPromise;
+    private unsubscribe;
+    /**
+     * Initialize the SDK with optional configuration
+     * @param config - Optional SDK configuration. If privyAppId is not provided, uses bundled default.
+     */
+    init(config: SDKConfig): Promise<void>;
+    /**
+     * Trigger login flow
+     * Note: With OAuth providers (e.g., Google), the page may reload during authentication.
+     * Use the onAuthStateChange callback in init() or poll isAuthenticated()/getProfile() to detect when login completes.
+     */
+    login(): Promise<void>;
+    /**
+     * Logout the current user
+     */
+    logout(): Promise<void>;
+    /**
+     * Get current user profile (cached)
+     */
+    getProfile(): AutoGamesSDKUser | null;
+    /**
+     * Fetch fresh user profile from backend and update cache
+     * @returns User profile or null if not authenticated
+     */
+    fetchProfile(): Promise<AutoGamesSDKUser | null>;
+    /**
+     * Vote on a voting
+     * @param votingId - The ID of the voting
+     * @param body - Vote request body containing option_id and votingID
+     * @returns Vote response with message
+     */
+    vote(votingId: number, body: VoteRequest): Promise<VoteResponse>;
+    /**
+     * Recall a vote on a voting
+     * @param votingId - The ID of the voting
+     * @returns Recall response with message
+     */
+    recall(votingId: number): Promise<RecallResponse>;
+    /**
+     * Fetch user assets
+     * @param userId - The ID of the user
+     * @param params - Optional query parameters (limit, prev_user_token, next_user_token)
+     * @returns User assets response with array of assets
+     */
+    fetchUserAssets(userId: number, params?: UserAssetsParams): Promise<UserAssetsResponse>;
+    /**
+     * Fetch user created tokens
+     * @param userId - The ID of the user
+     * @param params - Optional query parameters (limit, prev_token, next_token)
+     * @returns User created tokens response with array of created tokens
+     */
+    fetchUserCreatedTokens(userId: number, params?: UserCreatedTokensParams): Promise<UserCreatedTokensResponse>;
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Check if SDK is ready
+     */
+    isReady(): boolean;
+    /**
+     * Get current authentication state
+     */
+    getAuthState(): AuthState;
+    /**
+     * Clean up subscriptions
+     */
+    destroy(): void;
+    /* Excluded from this release type: waitForReady */
+    /* Excluded from this release type: mountBridge */
+    private ensureInitialized;
+}
+
+export declare type AutoGamesSDKUser = BaseEntity & {
+    BalanceUSD: number;
+    Email: string;
+    GeoInfo: string;
+    ImageThumbnailURL: string;
+    ImageURL: string;
+    IsEmailVerified: boolean;
+    Name: string;
+    PrivyUserID: string;
+    WalletPublicKey: string;
+    EthereumAddress: string;
+    SolanaAddress: string;
+    SolanaBalanceLamports: number;
+};
+
+declare interface BaseEntity {
+    ID: number;
+    CreatedAt: string;
+    UpdatedAt: string;
+}
+
+declare type CreatedToken = {
+    token: Token;
+    user_token: UserToken;
+};
+
+declare type Game = BaseEntity & {
+    Color: string;
+    CoverImage: string;
+    Description: string;
+    DescriptionPreview: string;
+    Icon: string;
+    Metrics: GameMetrics;
+    TickInterval: number;
+    Title: string;
+    TokenAgentPrice: number;
+    TokenLaunchMinStart: number;
+    TokensPerLvl: number;
+    URL: string;
+};
+
+declare type GameMetrics = BaseEntity & {
+    game_id: number;
+    holders_count: number;
+    market_cap_change_1h: number;
+    market_cap_change_24h: number;
+    market_cap_change_5m: number;
+    market_cap_change_6h: number;
+    token_count: number;
+    total_market_cap: number;
+    trades_count_24h: number;
+    volume_24h: number;
+};
+
+export { PrivyClientConfig }
+
+/**
+ * Privy instance interface (minimal subset we need)
+ */
+declare interface PrivyInstance {
+    login: () => Promise<void>;
+    logout: () => Promise<void>;
+    ready: boolean;
+}
+
+declare type RecallResponse = {
+    message: string;
+};
+
+export declare interface SDKConfig {
+    /**
+     * Agent ID. Game ID in the AutoGames platform.
+     */
+    agentId: number;
+    /**
+     * Optional: Privy App ID. If not provided, uses the bundled default.
+     * Only needed if you want to use a different Privy app for isolated user base.
+     */
+    privyAppId?: string;
+    /**
+     * Optional: Customize the appearance of Privy UI elements.
+     * Uses Privy's native appearance configuration.
+     * @see https://docs.privy.io/reference/react-auth/modules#privyclientconfig
+     */
+    appearance?: PrivyClientConfig['appearance'];
+    /**
+     * Optional: Configure which login methods are available.
+     * Pass an array of enabled methods, e.g. ['email', 'wallet', 'google']
+     * Uses Privy's native login methods configuration.
+     * @see https://docs.privy.io/reference/react-auth/modules#privyclientconfig
+     */
+    loginMethods?: PrivyClientConfig['loginMethods'];
+    /**
+     * Optional: Advanced login methods configuration with ordering.
+     * If both loginMethodsAndOrder and loginMethods are defined, loginMethodsAndOrder takes precedence.
+     * @see https://docs.privy.io/reference/react-auth/modules#privyclientconfig
+     */
+    loginMethodsAndOrder?: PrivyClientConfig['loginMethodsAndOrder'];
+    /**
+     * Optional: Additional Privy client configuration options.
+     * This allows you to pass any other PrivyClientConfig options directly.
+     * @see https://docs.privy.io/reference/react-auth/modules#privyclientconfig
+     */
+    config?: Omit<PrivyClientConfig, 'appearance' | 'loginMethods' | 'loginMethodsAndOrder'>;
+    /**
+     * Optional: Callback fired when authentication state changes
+     */
+    onAuthStateChange?: (user: AutoGamesSDKUser | null) => void;
+}
+
+declare type Token = BaseEntity & {
+    AgentLaunchPrice: number;
+    AgentLaunchPriceCollected: number;
+    CirculatingSupply: number;
+    CreatorUserID: number;
+    Description: string;
+    Game: Game;
+    GameID: number;
+    HoldersCount: number;
+    IsAgent: boolean;
+    MarketCap: number;
+    MaxSupply: number;
+    Meta: Record<string, unknown>;
+    Metrics: TokenMetrics;
+    MintAddress: string;
+    PriceUsd: number;
+    Status: string;
+    TelegramURL: string;
+    Ticker: string;
+    Title: string;
+    TwitterURL: string;
+    WebsiteURL: string;
+};
+
+declare type TokenMetrics = BaseEntity & {
+    current_price: number;
+    holders_count: number;
+    market_cap: number;
+    market_cap_change_1h: number;
+    market_cap_change_24h: number;
+    market_cap_change_5m: number;
+    market_cap_change_6h: number;
+    price_change_1h: number;
+    price_change_24h: number;
+    price_change_5m: number;
+    price_change_6h: number;
+    token_id: number;
+    trades_count_24h: number;
+    volume_24h: number;
+};
+
+/**
+ * Create auth store with Zustand
+ */
+export declare const useAuthStore: UseBoundStore<Omit<Omit<StoreApi<AuthStoreState>, "setState" | "persist"> & {
+setState(partial: AuthStoreState | Partial<AuthStoreState> | ((state: AuthStoreState) => AuthStoreState | Partial<AuthStoreState>), replace?: false | undefined): unknown;
+setState(state: AuthStoreState | ((state: AuthStoreState) => AuthStoreState), replace: true): unknown;
+persist: {
+setOptions: (options: Partial<PersistOptions<AuthStoreState, {
+accessToken: string | null;
+accessTokenUpdatedAt: string | null;
+user: AutoGamesSDKUser | null;
+isAuthenticated: boolean;
+}, unknown>>) => void;
+clearStorage: () => void;
+rehydrate: () => Promise<void> | void;
+hasHydrated: () => boolean;
+onHydrate: (fn: (state: AuthStoreState) => void) => () => void;
+onFinishHydration: (fn: (state: AuthStoreState) => void) => () => void;
+getOptions: () => Partial<PersistOptions<AuthStoreState, {
+accessToken: string | null;
+accessTokenUpdatedAt: string | null;
+user: AutoGamesSDKUser | null;
+isAuthenticated: boolean;
+}, unknown>>;
+};
+}, "subscribe"> & {
+subscribe: {
+(listener: (selectedState: AuthStoreState, previousSelectedState: AuthStoreState) => void): () => void;
+<U>(selector: (state: AuthStoreState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+equalityFn?: ((a: U, b: U) => boolean) | undefined;
+fireImmediately?: boolean;
+} | undefined): () => void;
+};
+}>;
+
+declare type UserAsset = {
+    token: Token;
+    user_token: UserToken;
+};
+
+export declare type UserAssetsParams = {
+    limit?: number;
+    prev_user_token?: string;
+    next_user_token?: string;
+};
+
+export declare type UserAssetsResponse = {
+    assets: UserAsset[];
+};
+
+export declare type UserCreatedTokensParams = {
+    limit?: number;
+    prev_token?: string;
+    next_token?: string;
+};
+
+export declare type UserCreatedTokensResponse = {
+    created_tokens: CreatedToken[];
+};
+
+declare type UserToken = BaseEntity & {
+    Amount: number;
+    LastUpdatedAt: string;
+    TokenID: number;
+    UserID: number;
+};
+
+declare type VoteRequest = {
+    option_id: number;
+    votingID: number;
+};
+
+declare type VoteResponse = {
+    message: string;
+};
+
+export { }

package/dist/parseSignature-DFDCc7FD.js

@@ -0,0 +1,131 @@
+import { K as b, bP as y, bD as w, a3 as x, bR as p, cd as z, ca as M, d6 as k, cc as f, d7 as P, X as T, d8 as $, a2 as E, d9 as N, bs as S, c6 as B, da as L } from "./bridge-mount-Bhf05oeO.js";
+function _(t, e) {
+  if (t.length !== e.length)
+    throw new b({
+      expectedLength: t.length,
+      givenLength: e.length
+    });
+  const i = [];
+  for (let n = 0; n < t.length; n++) {
+    const u = t[n], o = e[n];
+    i.push(m(u, o));
+  }
+  return y(i);
+}
+function m(t, e, i = !1) {
+  if (t === "address") {
+    const r = e;
+    if (!w(r))
+      throw new x({ address: r });
+    return p(r.toLowerCase(), {
+      size: i ? 32 : null
+    });
+  }
+  if (t === "string")
+    return z(e);
+  if (t === "bytes")
+    return e;
+  if (t === "bool")
+    return p(M(e), { size: i ? 32 : 1 });
+  const n = t.match(k);
+  if (n) {
+    const [r, s, a = "256"] = n, c = Number.parseInt(a, 10) / 8;
+    return f(e, {
+      size: i ? 32 : c,
+      signed: s === "int"
+    });
+  }
+  const u = t.match(P);
+  if (u) {
+    const [r, s] = u;
+    if (Number.parseInt(s, 10) !== (e.length - 2) / 2)
+      throw new T({
+        expectedSize: Number.parseInt(s, 10),
+        givenSize: (e.length - 2) / 2
+      });
+    return p(e, { dir: "right", size: i ? 32 : null });
+  }
+  const o = t.match($);
+  if (o && Array.isArray(e)) {
+    const [r, s] = o, a = [];
+    for (let c = 0; c < e.length; c++)
+      a.push(m(s, e[c], !0));
+    return a.length === 0 ? "0x" : y(a);
+  }
+  throw new E(t);
+}
+function C(t) {
+  return {
+    formatters: void 0,
+    fees: void 0,
+    serializers: void 0,
+    ...t
+  };
+}
+function H(t) {
+  const { source: e } = t, i = /* @__PURE__ */ new Map(), n = new N(8192), u = /* @__PURE__ */ new Map(), o = ({ address: r, chainId: s }) => `${r}.${s}`;
+  return {
+    async consume({ address: r, chainId: s, client: a }) {
+      const c = o({ address: r, chainId: s }), d = this.get({ address: r, chainId: s, client: a });
+      this.increment({ address: r, chainId: s });
+      const g = await d;
+      return await e.set({ address: r, chainId: s }, g), n.set(c, g), g;
+    },
+    async increment({ address: r, chainId: s }) {
+      const a = o({ address: r, chainId: s }), c = i.get(a) ?? 0;
+      i.set(a, c + 1);
+    },
+    async get({ address: r, chainId: s, client: a }) {
+      const c = o({ address: r, chainId: s });
+      let d = u.get(c);
+      return d || (d = (async () => {
+        try {
+          const l = await e.get({ address: r, chainId: s, client: a }), h = n.get(c) ?? 0;
+          return h > 0 && l <= h ? h + 1 : (n.delete(c), l);
+        } finally {
+          this.reset({ address: r, chainId: s });
+        }
+      })(), u.set(c, d)), (i.get(c) ?? 0) + await d;
+    },
+    reset({ address: r, chainId: s }) {
+      const a = o({ address: r, chainId: s });
+      i.delete(a), u.delete(a);
+    }
+  };
+}
+const A = "0x6492649264926492649264926492649264926492649264926492649264926492";
+function I(t) {
+  const { address: e, data: i, signature: n, to: u = "hex" } = t, o = y([
+    S([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [e, i, n]),
+    A
+  ]);
+  return u === "hex" ? o : B(o);
+}
+function K(t) {
+  const { r: e, s: i } = L.Signature.fromCompact(t.slice(2, 130)), n = +`0x${t.slice(130)}`, [u, o] = (() => {
+    if (n === 0 || n === 1)
+      return [void 0, n];
+    if (n === 27)
+      return [BigInt(n), 0];
+    if (n === 28)
+      return [BigInt(n), 1];
+    throw new Error("Invalid yParityOrV value");
+  })();
+  return typeof u < "u" ? {
+    r: f(e, { size: 32 }),
+    s: f(i, { size: 32 }),
+    v: u,
+    yParity: o
+  } : {
+    r: f(e, { size: 32 }),
+    s: f(i, { size: 32 }),
+    yParity: o
+  };
+}
+export {
+  H as c,
+  C as d,
+  _ as e,
+  K as p,
+  I as s
+};