@bropump/sdk 0.2.1

package/README.md

@@ -0,0 +1,56 @@
+# @bropump/sdk
+
+TypeScript SDK for the BroPump API.
+
+## Install
+
+Install from public npmjs:
+
+```bash
+npm install @bropump/sdk
+```
+
+## Example
+
+```ts
+import { BroPumpClient } from '@bropump/sdk'
+
+const client = new BroPumpClient({
+  network: 'mainnet',
+})
+
+const token = await client.tokens.create({
+  name: 'Bro Pump',
+  symbol: 'BRO',
+  description: 'Simple token flow',
+  deployer: 'YOUR_WALLET',
+  migrationThreshold: 35,
+  image: new Blob(['demo'], { type: 'image/png' }),
+})
+
+const ready = await client.tokens.waitForReadyToSign(token.id)
+
+await client.tokens.submitSigned(token.id, {
+  submitId: ready.submit.id,
+  signedTransactions: ready.submit.transactions.map((tx) => tx),
+})
+```
+
+Use `network: 'devnet'` for the dev environment:
+
+```ts
+const client = new BroPumpClient({
+  network: 'devnet',
+})
+```
+
+`baseUrl` remains available as an override for local or preview environments.
+
+## Publish
+
+This package is set up to publish publicly to npmjs under `@bropump/sdk`.
+
+```bash
+cd packages/sdk
+npm publish --access public --registry=https://registry.npmjs.org
+```

package/dist/client.d.ts

@@ -0,0 +1,56 @@
+import { BroPumpRealtimeStream } from './realtime.js';
+import type { BroPumpClientOptions, BroPumpRequestOptions, BroPumpWaitOptions, BroPumpWatchOptions, BuildWithdrawRequest, BuildWithdrawView, CreateTokenInput, CurvePreview, FeePreviewRequest, HealthView, LaunchConfigView, SubmitAction, SubmitGoLiveInput, SubmitSignedTransactionsInput, SubmitTokenInput, TokenView, WalletBalanceView } from './types.js';
+export declare class BroPumpClient {
+    readonly baseUrl: string;
+    readonly network: 'mainnet' | 'devnet';
+    private readonly defaultHeaders;
+    private readonly fetchImpl;
+    private readonly webSocketImpl;
+    readonly tokens: {
+        create: (input: CreateTokenInput, options?: BroPumpRequestOptions) => Promise<TokenView>;
+        get: (id: string, options?: BroPumpRequestOptions) => Promise<TokenView>;
+        submit: (id: string, input: SubmitTokenInput, options?: BroPumpRequestOptions) => Promise<TokenView>;
+        submitSigned: (id: string, input: SubmitSignedTransactionsInput, options?: BroPumpRequestOptions) => Promise<TokenView>;
+        goLive: (id: string, input: Omit<SubmitGoLiveInput, "action">, options?: BroPumpRequestOptions) => Promise<TokenView>;
+        watch: (id: string, options?: BroPumpWatchOptions) => Promise<BroPumpRealtimeStream<TokenView>>;
+        watchPool: (pool: string, options?: BroPumpWatchOptions) => Promise<BroPumpRealtimeStream<TokenView>>;
+        waitFor: (id: string, predicate: (token: TokenView) => boolean, options?: BroPumpWaitOptions) => Promise<TokenView>;
+        waitForReadyToSign: (id: string, options?: BroPumpWaitOptions) => Promise<TokenView & {
+            submit: SubmitAction;
+        }>;
+        waitForLive: (id: string, options?: BroPumpWaitOptions) => Promise<TokenView & {
+            status: "live";
+        }>;
+    };
+    readonly fees: {
+        preview: (input?: FeePreviewRequest, options?: BroPumpRequestOptions) => Promise<CurvePreview>;
+    };
+    readonly launchConfig: {
+        get: (options?: BroPumpRequestOptions) => Promise<LaunchConfigView>;
+    };
+    readonly experimental: {
+        wallet: {
+            getBalance: (address: string, options?: BroPumpRequestOptions) => Promise<WalletBalanceView>;
+            buildWithdraw: (input: BuildWithdrawRequest, options?: BroPumpRequestOptions) => Promise<BuildWithdrawView>;
+        };
+    };
+    constructor(options?: BroPumpClientOptions);
+    health(options?: BroPumpRequestOptions): Promise<HealthView>;
+    createToken(input: CreateTokenInput, options?: BroPumpRequestOptions): Promise<TokenView>;
+    getToken(id: string, options?: BroPumpRequestOptions): Promise<TokenView>;
+    submitToken(id: string, input: SubmitTokenInput, options?: BroPumpRequestOptions): Promise<TokenView>;
+    waitForToken(id: string, predicate: (token: TokenView) => boolean, options?: BroPumpWaitOptions): Promise<TokenView>;
+    waitForReadyToSign(id: string, options?: BroPumpWaitOptions): Promise<TokenView & {
+        submit: SubmitAction;
+    }>;
+    waitForLive(id: string, options?: BroPumpWaitOptions): Promise<TokenView & {
+        status: 'live';
+    }>;
+    watchToken(id: string, options?: BroPumpWatchOptions): Promise<BroPumpRealtimeStream<TokenView>>;
+    watchPool(pool: string, options?: BroPumpWatchOptions): Promise<BroPumpRealtimeStream<TokenView>>;
+    previewFees(input?: FeePreviewRequest, options?: BroPumpRequestOptions): Promise<CurvePreview>;
+    getLaunchConfig(options?: BroPumpRequestOptions): Promise<LaunchConfigView>;
+    getWalletBalance(address: string, options?: BroPumpRequestOptions): Promise<WalletBalanceView>;
+    buildWithdraw(input: BuildWithdrawRequest, options?: BroPumpRequestOptions): Promise<BuildWithdrawView>;
+    private request;
+}

package/dist/client.js

@@ -0,0 +1,263 @@
+import { BROPUMP_API_URL_BY_NETWORK, DEFAULT_BROPUMP_API_URL, DEFAULT_POLL_INTERVAL_MS, DEFAULT_WAIT_TIMEOUT_MS, } from './constants.js';
+import { BroPumpApiError, BroPumpTokenFailedError } from './errors.js';
+import { hasSubmitAction, isTokenFailed, isTokenLive } from './guards.js';
+import { BroPumpRealtimeStream } from './realtime.js';
+import { encodePathSegment, ensureNotAborted, isApiEnvelope, mergeHeaders, normalizeBaseUrl, sleep, } from './utils.js';
+export class BroPumpClient {
+    baseUrl;
+    network;
+    defaultHeaders;
+    fetchImpl;
+    webSocketImpl;
+    tokens = {
+        create: (input, options) => this.createToken(input, options),
+        get: (id, options) => this.getToken(id, options),
+        submit: (id, input, options) => this.submitToken(id, input, options),
+        submitSigned: (id, input, options) => this.submitToken(id, input, options),
+        goLive: (id, input, options) => this.submitToken(id, { action: 'go_live', ...input }, options),
+        watch: (id, options) => this.watchToken(id, options),
+        watchPool: (pool, options) => this.watchPool(pool, options),
+        waitFor: (id, predicate, options) => this.waitForToken(id, predicate, options),
+        waitForReadyToSign: (id, options) => this.waitForReadyToSign(id, options),
+        waitForLive: (id, options) => this.waitForLive(id, options),
+    };
+    fees = {
+        preview: (input, options) => this.previewFees(input, options),
+    };
+    launchConfig = {
+        get: (options) => this.getLaunchConfig(options),
+    };
+    experimental = {
+        wallet: {
+            getBalance: (address, options) => this.getWalletBalance(address, options),
+            buildWithdraw: (input, options) => this.buildWithdraw(input, options),
+        },
+    };
+    constructor(options = {}) {
+        this.network = options.network || 'mainnet';
+        this.baseUrl = normalizeBaseUrl(options.baseUrl || BROPUMP_API_URL_BY_NETWORK[this.network] || DEFAULT_BROPUMP_API_URL);
+        this.defaultHeaders = options.headers;
+        this.fetchImpl = options.fetch;
+        this.webSocketImpl = options.WebSocket;
+    }
+    async health(options) {
+        return this.request({
+            path: '/health',
+            method: 'GET',
+            options,
+        });
+    }
+    async createToken(input, options) {
+        const form = buildCreateTokenFormData(input);
+        return this.request({
+            path: '/tokens/create',
+            method: 'POST',
+            body: form,
+            options,
+        });
+    }
+    async getToken(id, options) {
+        return this.request({
+            path: `/tokens/${encodePathSegment(id)}`,
+            method: 'GET',
+            options,
+        });
+    }
+    async submitToken(id, input, options) {
+        return this.request({
+            path: `/tokens/${encodePathSegment(id)}/submit`,
+            method: 'POST',
+            body: input,
+            options,
+        });
+    }
+    async waitForToken(id, predicate, options = {}) {
+        const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const stopOnFailed = options.stopOnFailed ?? true;
+        const deadline = Date.now() + timeoutMs;
+        while (true) {
+            ensureNotAborted(options.signal);
+            const token = await this.getToken(id, options);
+            if (predicate(token)) {
+                return token;
+            }
+            if (stopOnFailed && isTokenFailed(token)) {
+                throw new BroPumpTokenFailedError(token);
+            }
+            const remainingMs = deadline - Date.now();
+            if (remainingMs <= 0) {
+                throw new Error(`Timed out waiting for token ${id}`);
+            }
+            await sleep(Math.min(pollIntervalMs, remainingMs), options.signal);
+        }
+    }
+    async waitForReadyToSign(id, options) {
+        const token = await this.waitForToken(id, hasSubmitAction, options);
+        if (!hasSubmitAction(token)) {
+            throw new Error(`Token ${id} is missing submit instructions`);
+        }
+        return token;
+    }
+    async waitForLive(id, options) {
+        const token = await this.waitForToken(id, isTokenLive, options);
+        if (!isTokenLive(token)) {
+            throw new Error(`Token ${id} did not reach live status`);
+        }
+        return token;
+    }
+    async watchToken(id, options) {
+        return BroPumpRealtimeStream.connect({
+            baseUrl: this.baseUrl,
+            pathname: `/tokens/${encodePathSegment(id)}/ws`,
+            WebSocket: this.webSocketImpl,
+            options,
+        });
+    }
+    async watchPool(pool, options) {
+        return BroPumpRealtimeStream.connect({
+            baseUrl: this.baseUrl,
+            pathname: `/pools/${encodePathSegment(pool)}/ws`,
+            WebSocket: this.webSocketImpl,
+            options,
+        });
+    }
+    async previewFees(input, options) {
+        return this.request({
+            path: '/fees/preview',
+            method: 'POST',
+            body: input ?? {},
+            options,
+        });
+    }
+    async getLaunchConfig(options) {
+        return this.request({
+            path: '/launch-config',
+            method: 'GET',
+            options,
+        });
+    }
+    async getWalletBalance(address, options) {
+        return this.request({
+            path: `/wallet/${encodePathSegment(address)}/balance`,
+            method: 'GET',
+            options,
+        });
+    }
+    async buildWithdraw(input, options) {
+        return this.request({
+            path: '/wallet/build-withdraw',
+            method: 'POST',
+            body: input,
+            options,
+        });
+    }
+    async request(params) {
+        const fetchImpl = this.fetchImpl ?? globalThis.fetch;
+        if (!fetchImpl) {
+            throw new Error('fetch is not available in this runtime');
+        }
+        const headers = mergeHeaders(this.defaultHeaders, params.options?.headers);
+        let body;
+        if (params.body instanceof FormData) {
+            body = params.body;
+        }
+        else if (params.body !== undefined) {
+            headers.set('Content-Type', 'application/json');
+            body = JSON.stringify(params.body);
+        }
+        const response = await fetchImpl(new URL(params.path, `${this.baseUrl}/`), {
+            method: params.method,
+            headers,
+            body,
+            signal: params.options?.signal,
+        });
+        const text = await response.text();
+        let parsed = null;
+        if (text) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = text;
+            }
+        }
+        if (!response.ok) {
+            throw BroPumpApiError.fromResponse(response, parsed);
+        }
+        if (isApiEnvelope(parsed)) {
+            return parsed.data;
+        }
+        return parsed;
+    }
+}
+function buildCreateTokenFormData(input) {
+    const form = new FormData();
+    appendFormValue(form, 'mode', input.mode);
+    appendFormValue(form, 'name', input.name);
+    appendFormValue(form, 'symbol', input.symbol);
+    appendFormValue(form, 'description', input.description);
+    appendFormValue(form, 'deployer', input.deployer);
+    appendFormValue(form, 'migrationThreshold', input.migrationThreshold);
+    appendFormValue(form, 'firstBuyAmount', input.firstBuyAmount);
+    appendFormValue(form, 'x', input.x);
+    appendFormValue(form, 'website', input.website);
+    appendFormValue(form, 'telegram', input.telegram);
+    const image = toImagePart(input.image);
+    form.set('image', image.blob, image.filename);
+    return form;
+}
+function appendFormValue(form, key, value) {
+    if (value == null)
+        return;
+    form.set(key, String(value));
+}
+function toImagePart(image) {
+    if (isBlob(image)) {
+        return {
+            blob: image,
+            filename: defaultFilename(image.type),
+        };
+    }
+    if (image instanceof ArrayBuffer) {
+        return {
+            blob: new Blob([image], { type: 'image/png' }),
+            filename: 'token.png',
+        };
+    }
+    if (ArrayBuffer.isView(image)) {
+        return {
+            blob: new Blob([toOwnedArrayBuffer(image)], { type: 'image/png' }),
+            filename: 'token.png',
+        };
+    }
+    const filename = image.filename || defaultFilename(image.contentType);
+    const data = isBlob(image.data)
+        ? image.data
+        : new Blob([image.data], {
+            type: image.contentType || 'image/png',
+        });
+    return {
+        blob: data,
+        filename,
+    };
+}
+function defaultFilename(contentType) {
+    if (!contentType)
+        return 'token.png';
+    if (contentType.includes('jpeg'))
+        return 'token.jpg';
+    if (contentType.includes('webp'))
+        return 'token.webp';
+    if (contentType.includes('gif'))
+        return 'token.gif';
+    return 'token.png';
+}
+function isBlob(value) {
+    return typeof Blob !== 'undefined' && value instanceof Blob;
+}
+function toOwnedArrayBuffer(view) {
+    const bytes = new Uint8Array(view.byteLength);
+    bytes.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+    return bytes.buffer;
+}

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+import type { BroPumpNetwork } from './types.js';
+export declare const DEFAULT_BROPUMP_API_URL = "https://api.bropump.run";
+export declare const DEFAULT_BROPUMP_DEVNET_API_URL = "https://dev.bropump.run";
+export declare const DEFAULT_POLL_INTERVAL_MS = 1000;
+export declare const DEFAULT_WAIT_TIMEOUT_MS = 120000;
+export declare const DEFAULT_WS_OPEN_TIMEOUT_MS = 10000;
+export declare const BROPUMP_API_URL_BY_NETWORK: Record<BroPumpNetwork, string>;

package/dist/constants.js

@@ -0,0 +1,9 @@
+export const DEFAULT_BROPUMP_API_URL = 'https://api.bropump.run';
+export const DEFAULT_BROPUMP_DEVNET_API_URL = 'https://dev.bropump.run';
+export const DEFAULT_POLL_INTERVAL_MS = 1_000;
+export const DEFAULT_WAIT_TIMEOUT_MS = 120_000;
+export const DEFAULT_WS_OPEN_TIMEOUT_MS = 10_000;
+export const BROPUMP_API_URL_BY_NETWORK = {
+    mainnet: DEFAULT_BROPUMP_API_URL,
+    devnet: DEFAULT_BROPUMP_DEVNET_API_URL,
+};

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+import type { TokenView } from './types.js';
+export declare class BroPumpApiError extends Error {
+    readonly status: number;
+    readonly code: string | null;
+    readonly body: unknown;
+    constructor(params: {
+        message: string;
+        status: number;
+        code?: string | null;
+        body?: unknown;
+    });
+    static fromResponse(response: Response, body: unknown): BroPumpApiError;
+}
+export declare class BroPumpTokenFailedError extends Error {
+    readonly token: TokenView;
+    constructor(token: TokenView);
+}

package/dist/errors.js

@@ -0,0 +1,32 @@
+export class BroPumpApiError extends Error {
+    status;
+    code;
+    body;
+    constructor(params) {
+        super(params.message);
+        this.name = 'BroPumpApiError';
+        this.status = params.status;
+        this.code = params.code ?? null;
+        this.body = params.body ?? null;
+    }
+    static fromResponse(response, body) {
+        const payload = body;
+        const message = typeof payload?.error === 'string'
+            ? payload.error
+            : `Request failed with status ${response.status}`;
+        return new BroPumpApiError({
+            message,
+            status: response.status,
+            code: typeof payload?.code === 'string' ? payload.code : null,
+            body,
+        });
+    }
+}
+export class BroPumpTokenFailedError extends Error {
+    token;
+    constructor(token) {
+        super(token.error?.message || `Token ${token.id} failed`);
+        this.name = 'BroPumpTokenFailedError';
+        this.token = token;
+    }
+}

package/dist/guards.d.ts

@@ -0,0 +1,10 @@
+import type { SubmitAction, TokenView } from './types.js';
+export declare function hasSubmitAction(token: TokenView): token is TokenView & {
+    submit: SubmitAction;
+};
+export declare function isTokenFailed(token: TokenView): token is TokenView & {
+    status: 'failed';
+};
+export declare function isTokenLive(token: TokenView): token is TokenView & {
+    status: 'live';
+};

package/dist/guards.js

@@ -0,0 +1,9 @@
+export function hasSubmitAction(token) {
+    return Boolean(token.submit?.id && token.submit.transactions?.length);
+}
+export function isTokenFailed(token) {
+    return token.status === 'failed';
+}
+export function isTokenLive(token) {
+    return token.status === 'live';
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './client.js';
+export * from './constants.js';
+export * from './errors.js';
+export * from './guards.js';
+export * from './realtime.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './client.js';
+export * from './constants.js';
+export * from './errors.js';
+export * from './guards.js';
+export * from './realtime.js';
+export * from './types.js';

package/dist/realtime.d.ts

@@ -0,0 +1,28 @@
+import type { BroPumpWatchOptions, RealtimeMessage } from './types.js';
+export declare function buildWebSocketUrl(baseUrl: string, pathname: string): string;
+export declare class BroPumpRealtimeStream<T> implements AsyncIterable<RealtimeMessage<T>> {
+    readonly messages: RealtimeMessage<T>[];
+    private readonly socket;
+    private readonly waiters;
+    private readonly pendingIterators;
+    private readonly queue;
+    private closedError;
+    private closedCleanly;
+    private manuallyClosed;
+    private constructor();
+    static connect<T>(params: {
+        baseUrl: string;
+        pathname: string;
+        WebSocket?: typeof globalThis.WebSocket;
+        options?: BroPumpWatchOptions;
+    }): Promise<BroPumpRealtimeStream<T>>;
+    waitFor(predicate: (message: RealtimeMessage<T>) => boolean, timeoutMs: number, fromIndex?: number): Promise<RealtimeMessage<T>>;
+    close(code?: number, reason?: string): void;
+    [Symbol.asyncIterator](): AsyncIterator<RealtimeMessage<T>>;
+    private next;
+    private enqueue;
+    private flushWaiters;
+    private fail;
+    private failWaiters;
+    private finishIterators;
+}

package/dist/realtime.js

@@ -0,0 +1,224 @@
+import { DEFAULT_WS_OPEN_TIMEOUT_MS } from './constants.js';
+import { createAbortError } from './utils.js';
+export function buildWebSocketUrl(baseUrl, pathname) {
+    const url = new URL(pathname, `${baseUrl.replace(/\/+$/, '')}/`);
+    url.protocol = url.protocol === 'https:' || url.protocol === 'wss:' ? 'wss:' : 'ws:';
+    return url.toString();
+}
+export class BroPumpRealtimeStream {
+    messages = [];
+    socket;
+    waiters = new Set();
+    pendingIterators = new Set();
+    queue = [];
+    closedError = null;
+    closedCleanly = false;
+    manuallyClosed = false;
+    constructor(socket) {
+        this.socket = socket;
+        this.socket.addEventListener('message', (event) => {
+            try {
+                const parsed = JSON.parse(String(event.data));
+                this.messages.push(parsed);
+                this.enqueue(parsed);
+                this.flushWaiters();
+            }
+            catch (error) {
+                this.fail(error instanceof Error ? error : new Error('Failed parsing realtime payload'));
+            }
+        });
+        this.socket.addEventListener('close', (event) => {
+            const error = this.manuallyClosed || event.code === 1000
+                ? null
+                : new Error(`WebSocket closed${event.code ? ` (${event.code})` : ''}${event.reason ? `: ${event.reason}` : ''}`);
+            if (error) {
+                this.fail(error);
+                return;
+            }
+            this.closedCleanly = true;
+            this.failWaiters(new Error('WebSocket closed'));
+            this.finishIterators();
+        });
+        this.socket.addEventListener('error', () => {
+            this.fail(new Error('WebSocket error'));
+        });
+    }
+    static async connect(params) {
+        const WebSocketCtor = params.WebSocket ?? globalThis.WebSocket;
+        if (!WebSocketCtor) {
+            throw new Error('WebSocket is not available in this runtime');
+        }
+        const url = buildWebSocketUrl(params.baseUrl, params.pathname);
+        const socket = new WebSocketCtor(url);
+        const timeoutMs = params.options?.timeoutMs ?? DEFAULT_WS_OPEN_TIMEOUT_MS;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const timeout = setTimeout(() => {
+                cleanup();
+                settled = true;
+                try {
+                    socket.close(1000, 'open timeout');
+                }
+                catch {
+                    // no-op
+                }
+                reject(new Error(`Timed out opening WebSocket ${url}`));
+            }, timeoutMs);
+            const onAbort = () => {
+                if (settled)
+                    return;
+                cleanup();
+                settled = true;
+                try {
+                    socket.close(1000, 'aborted');
+                }
+                catch {
+                    // no-op
+                }
+                reject(createAbortError());
+            };
+            const onOpen = () => {
+                if (settled)
+                    return;
+                cleanup();
+                settled = true;
+                resolve();
+            };
+            const onError = () => {
+                if (settled)
+                    return;
+                cleanup();
+                settled = true;
+                reject(new Error(`Failed opening WebSocket ${url}`));
+            };
+            const onClose = (event) => {
+                if (settled)
+                    return;
+                cleanup();
+                settled = true;
+                const closeEvent = event;
+                reject(new Error(`WebSocket closed before open${closeEvent.code ? ` (${closeEvent.code})` : ''}`));
+            };
+            const cleanup = () => {
+                clearTimeout(timeout);
+                params.options?.signal?.removeEventListener('abort', onAbort);
+                socket.removeEventListener('open', onOpen);
+                socket.removeEventListener('error', onError);
+                socket.removeEventListener('close', onClose);
+            };
+            params.options?.signal?.addEventListener('abort', onAbort, { once: true });
+            socket.addEventListener('open', onOpen, { once: true });
+            socket.addEventListener('error', onError, { once: true });
+            socket.addEventListener('close', onClose, { once: true });
+        });
+        return new BroPumpRealtimeStream(socket);
+    }
+    async waitFor(predicate, timeoutMs, fromIndex = 0) {
+        const existing = this.messages.slice(fromIndex).find(predicate);
+        if (existing)
+            return existing;
+        if (this.closedError)
+            throw this.closedError;
+        if (this.closedCleanly) {
+            throw new Error('WebSocket closed');
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                predicate,
+                resolve: (message) => {
+                    clearTimeout(waiter.timeout);
+                    this.waiters.delete(waiter);
+                    resolve(message);
+                },
+                reject: (error) => {
+                    clearTimeout(waiter.timeout);
+                    this.waiters.delete(waiter);
+                    reject(error);
+                },
+                timeout: setTimeout(() => {
+                    this.waiters.delete(waiter);
+                    reject(new Error('Timed out waiting for realtime message'));
+                }, timeoutMs),
+                fromIndex,
+            };
+            this.waiters.add(waiter);
+        });
+    }
+    close(code, reason) {
+        this.manuallyClosed = true;
+        try {
+            this.socket.close(code, reason);
+        }
+        catch {
+            // no-op
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => this.next(),
+        };
+    }
+    next() {
+        if (this.queue.length > 0) {
+            return Promise.resolve({
+                value: this.queue.shift(),
+                done: false,
+            });
+        }
+        if (this.closedError) {
+            return Promise.reject(this.closedError);
+        }
+        if (this.closedCleanly) {
+            return Promise.resolve({
+                value: undefined,
+                done: true,
+            });
+        }
+        return new Promise((resolve, reject) => {
+            const pending = { resolve, reject };
+            this.pendingIterators.add(pending);
+        });
+    }
+    enqueue(message) {
+        const pending = this.pendingIterators.values().next().value;
+        if (pending) {
+            this.pendingIterators.delete(pending);
+            pending.resolve({
+                value: message,
+                done: false,
+            });
+            return;
+        }
+        this.queue.push(message);
+    }
+    flushWaiters() {
+        for (const waiter of Array.from(this.waiters)) {
+            const message = this.messages.slice(waiter.fromIndex).find(waiter.predicate);
+            if (message) {
+                waiter.resolve(message);
+            }
+        }
+    }
+    fail(error) {
+        this.closedError = this.closedError || error;
+        this.failWaiters(this.closedError);
+        for (const pending of Array.from(this.pendingIterators)) {
+            this.pendingIterators.delete(pending);
+            pending.reject(this.closedError);
+        }
+    }
+    failWaiters(error) {
+        for (const waiter of Array.from(this.waiters)) {
+            waiter.reject(error);
+        }
+    }
+    finishIterators() {
+        for (const pending of Array.from(this.pendingIterators)) {
+            this.pendingIterators.delete(pending);
+            pending.resolve({
+                value: undefined,
+                done: true,
+            });
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,224 @@
+export type ApiEnvelope<T> = {
+    success: true;
+    data: T;
+};
+export type BroPumpErrorResponse = {
+    error: string;
+    code: string;
+};
+export type BroPumpNetwork = 'mainnet' | 'devnet';
+export type BroPumpClientOptions = {
+    network?: BroPumpNetwork;
+    baseUrl?: string;
+    fetch?: typeof globalThis.fetch;
+    WebSocket?: typeof globalThis.WebSocket;
+    headers?: HeadersInit;
+};
+export type BroPumpRequestOptions = {
+    signal?: AbortSignal;
+    headers?: HeadersInit;
+};
+export type BroPumpWaitOptions = BroPumpRequestOptions & {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    stopOnFailed?: boolean;
+};
+export type BroPumpWatchOptions = {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+};
+export type UploadableImage = Blob | ArrayBuffer | ArrayBufferView | {
+    data: BlobPart | Blob;
+    filename?: string;
+    contentType?: string;
+};
+export type CreateTokenInput = {
+    mode?: 'live' | 'offchain';
+    name: string;
+    symbol: string;
+    description: string;
+    deployer: string;
+    migrationThreshold?: number;
+    firstBuyAmount?: number;
+    x?: string;
+    website?: string;
+    telegram?: string;
+    image: UploadableImage;
+};
+export type SubmitSignedTransactionsInput = {
+    submitId: string;
+    signedTransactions: string[];
+};
+export type SubmitGoLiveInput = {
+    action: 'go_live';
+    wallet: string;
+    firstBuyAmount?: number;
+};
+export type SubmitTokenInput = SubmitSignedTransactionsInput | SubmitGoLiveInput;
+export type HealthView = {
+    ok: boolean;
+    role: string;
+    api?: string;
+};
+export type LaunchCostBreakdown = {
+    baseTxFeesSol: number;
+    priorityFeesSol: number;
+    senderTipsSol: number;
+    firstBuyAmountSol: number;
+    otherLamportSpendsSol: number;
+    bufferSol: number;
+};
+export type LaunchCostPhaseQuote = {
+    phase: 'tx1' | 'tx2';
+    mode: 'estimated' | 'exact';
+    estimatedChainCostSol: number;
+    breakdown: Omit<LaunchCostBreakdown, 'bufferSol'>;
+};
+export type LaunchCostQuote = {
+    currency: 'SOL';
+    generatedAt: string;
+    validUntil: string;
+    estimatedTotalChainCostSol: number;
+    recommendedMinBalanceSol: number;
+    remainingChainCostSol: number;
+    walletBalanceSol: number | null;
+    sufficientBalance: boolean | null;
+    shortfallSol: number | null;
+    phases: {
+        tx1: LaunchCostPhaseQuote;
+        tx2?: LaunchCostPhaseQuote;
+    };
+    breakdown: LaunchCostBreakdown;
+};
+export type MigrationThresholdOption = {
+    migrationThreshold: number;
+    presetBinding: string;
+    configAddress: string | null;
+    deploymentMode: 'predeployed-config' | 'per-launch-config';
+};
+export type LaunchConfigView = {
+    network: 'devnet' | 'mainnet';
+    defaultMigrationThreshold: number;
+    allowedMigrationThresholds: number[];
+    availableMigrationThresholds: number[];
+    migrationThresholdOptions: MigrationThresholdOption[];
+    availableMigrationThresholdOptions: MigrationThresholdOption[];
+};
+export type SubmitAction = {
+    id: string;
+    phase: 'tx1' | 'tx2';
+    transactions: string[];
+    expiresAt: string | null;
+};
+export type TokenRuntime = {
+    mintAddress: string;
+    poolAddress: string | null;
+    configAddress: string | null;
+    launchId: string | null;
+    phase: 'offchain' | 'live' | 'migrated';
+    isTrading: boolean;
+    isMigrated: boolean;
+    completionPercent: number | null;
+    migrationTargetQuote: number | null;
+    currentQuoteReserve: number | null;
+    updatedAt: string;
+};
+export type TokenMarket = {
+    holderCount: number | null;
+    isVerified: boolean | null;
+    usdPrice: number | null;
+    mcap: number | null;
+    volume24h: number | null;
+    updatedAt: string;
+};
+export type TokenStatus = 'processing' | 'offchain_ready' | 'ready_to_sign' | 'submitting' | 'needs_resign' | 'live' | 'failed';
+export type TokenView = {
+    id: string;
+    mode: 'live' | 'offchain';
+    status: TokenStatus;
+    name: string;
+    symbol: string;
+    imageUrl: string | null;
+    mint: string | null;
+    pool: string | null;
+    submit?: SubmitAction;
+    runtime?: TokenRuntime | null;
+    market?: TokenMarket | null;
+    error?: {
+        code: string | null;
+        message: string | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+    liveAt: string | null;
+    expiresAt: string | null;
+};
+export type RealtimeMessage<T> = {
+    type: string;
+    at: string;
+    data: T | null;
+};
+export type CurvePreview = {
+    allowedMigrationThresholds: number[];
+    migrationThresholdOptions: MigrationThresholdOption[];
+    selectedMigrationThreshold: number;
+    curve: {
+        startingMC: number;
+        endingMC: number;
+        migrationThreshold: number;
+        migrationThresholdUSD: number;
+        solPrice: number;
+    };
+    realMarketCap: {
+        startQuote: number;
+        startUSD: number;
+        migrationQuote: number;
+        migrationUSD: number;
+    };
+    priceRange: {
+        startQuotePerToken: number;
+        startUSDPerToken: number;
+        migrationQuotePerToken: number;
+        migrationUSDPerToken: number;
+    };
+    lockedLiquidity: {
+        lockedPercent: number;
+        baseLocked: number;
+        quoteLocked: number;
+        quoteLockedUSD: number;
+    };
+    raiseSummary: {
+        targetQuote: number;
+        targetUSD: number;
+        curveQuoteAfterTradingFee: number;
+        curveUsdAfterTradingFee: number;
+        deepLiquidityQuote: number;
+        deepLiquidityUSD: number;
+        lpTokenPercent: number;
+        lpTokenAmount: number;
+        lpLockedPercent: number;
+    };
+    costQuote: LaunchCostQuote;
+};
+export type FeePreviewRequest = {
+    totalSupply?: string;
+    migrationThreshold?: number;
+    firstBuyAmount?: number;
+    deployerWallet?: string;
+};
+export type WalletBalanceView = {
+    address: string;
+    sol: number;
+    rentReserveLamports: number;
+    maxWithdrawSol: number;
+};
+export type BuildWithdrawRequest = {
+    address: string;
+    destination: string;
+    amountSol: number;
+};
+export type BuildWithdrawView = {
+    transaction: string;
+    lamports: number;
+    maxWithdrawable: number;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+import type { ApiEnvelope } from './types.js';
+export declare function normalizeBaseUrl(baseUrl: string): string;
+export declare function mergeHeaders(...sets: Array<HeadersInit | undefined>): Headers;
+export declare function isApiEnvelope<T>(value: unknown): value is ApiEnvelope<T>;
+export declare function encodePathSegment(value: string): string;
+export declare function createAbortError(): Error;
+export declare function ensureNotAborted(signal?: AbortSignal): void;
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/utils.js

@@ -0,0 +1,57 @@
+export function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '');
+}
+export function mergeHeaders(...sets) {
+    const headers = new Headers();
+    for (const set of sets) {
+        if (!set)
+            continue;
+        new Headers(set).forEach((value, key) => {
+            headers.set(key, value);
+        });
+    }
+    return headers;
+}
+export function isApiEnvelope(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    return 'success' in value && 'data' in value;
+}
+export function encodePathSegment(value) {
+    return encodeURIComponent(value);
+}
+export function createAbortError() {
+    try {
+        return new DOMException('The operation was aborted', 'AbortError');
+    }
+    catch {
+        const error = new Error('The operation was aborted');
+        error.name = 'AbortError';
+        return error;
+    }
+}
+export function ensureNotAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError();
+    }
+}
+export async function sleep(ms, signal) {
+    ensureNotAborted(signal);
+    if (ms <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            cleanup();
+            reject(createAbortError());
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@bropump/sdk",
+  "version": "0.2.1",
+  "description": "TypeScript SDK for the BroPump API",
+  "license": "UNLICENSED",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bropump/bropumplauncher.git",
+    "directory": "packages/sdk"
+  },
+  "keywords": [
+    "bropump",
+    "sdk",
+    "typescript",
+    "api",
+    "cloudflare"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "test": "bun test ./tests/*.test.ts",
+    "prepack": "tsc -p tsconfig.build.json"
+  }
+}