@tineon/t9n 0.1.4 → 0.1.6

package/README.md

@@ -26,7 +26,7 @@ npm i @tineon/t9n
 ## Quickstart
 
 ```ts
-import { initializeT9n } from "@tineon/t9n";
+import { initializeT9n, verifyT9nTransaction } from "@tineon/t9n";
 
 const checkout = initializeT9n({
   publicKey: "pk_live_xxx",
@@ -41,11 +41,17 @@ const checkout = initializeT9n({
   },
 });
 
-checkout.mountButton("#pay-btn-slot", {
-  text: "Pay with Crypto",
-  theme: "solid",
-});
-```
+checkout.mountButton("#pay-btn-slot", {
+  text: "Pay with Crypto",
+  theme: "solid",
+});
+
+const verification = await verifyT9nTransaction(
+  { publicKey: "pk_live_xxx" },
+  { reference: "order-123" }
+);
+console.log("verified", verification.status);
+```
 
 ## Triggers
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { type CheckoutConfig, type T9nButtonOptions } from "./types.js";
+import { type CheckoutConfig, type T9nButtonOptions, type VerifyTransactionParams, type VerifyTransactionResult } from "./types.js";
 export declare class T9nCheckout {
     private cfg;
     private currencies;
@@ -10,6 +10,8 @@ export declare class T9nCheckout {
     private isOpen;
     private lastResultFailed;
     private hasAttemptedConfirm;
+    private successNotified;
+    private failureNotified;
     constructor(config: CheckoutConfig);
     createButton(options?: T9nButtonOptions): HTMLButtonElement;
     bindTrigger(target: string | HTMLElement, eventName?: keyof HTMLElementEventMap): () => void;
@@ -21,6 +23,7 @@ export declare class T9nCheckout {
     private confirmPayment;
     private startTimer;
     private startStatusPolling;
+    verifyTransaction(params: VerifyTransactionParams): Promise<VerifyTransactionResult>;
     private defaultNetworkFor;
     private fetchWithTimeout;
     private assertSecureConfig;
@@ -30,6 +33,9 @@ export declare class T9nCheckout {
     private markFailed;
     private markClosed;
     private emitStatus;
+    private emitSuccessOnce;
+    private emitFailOnce;
     private getApiBaseUrl;
 }
 export declare function initializeT9n(config: CheckoutConfig): T9nCheckout;
+export declare function verifyT9nTransaction(config: Pick<CheckoutConfig, "publicKey" | "requestTimeoutMs">, params: VerifyTransactionParams): Promise<VerifyTransactionResult>;

package/dist/index.js

@@ -8,6 +8,8 @@ export class T9nCheckout {
         this.isOpen = false;
         this.lastResultFailed = false;
         this.hasAttemptedConfirm = false;
+        this.successNotified = false;
+        this.failureNotified = false;
         this.cfg = checkoutConfigSchema.parse(config);
         this.cfg.apiBaseUrl = this.cfg.apiBaseUrl || resolveDefaultApiBaseUrl();
         this.currencies = this.cfg.currencies;
@@ -47,6 +49,8 @@ export class T9nCheckout {
         this.isOpen = true;
         this.lastResultFailed = false;
         this.hasAttemptedConfirm = false;
+        this.successNotified = false;
+        this.failureNotified = false;
         try {
             this.cfg.hooks?.onOpen?.();
             const session = await this.createSession();
@@ -84,6 +88,8 @@ export class T9nCheckout {
         this.sessionId = "";
         this.expiresAt = undefined;
         this.isOpen = false;
+        this.successNotified = false;
+        this.failureNotified = false;
         this.emitStatus("closed");
         this.cfg.hooks?.onClose?.();
     }
@@ -186,13 +192,17 @@ export class T9nCheckout {
             this.lastResultFailed = true;
             this.modal?.setConfirmLabel("Retry check");
             this.emitStatus("pending_confirmation");
-            this.cfg.hooks?.onFail?.({ sessionId: this.sessionId || undefined, error: "confirm request failed" });
+            this.emitFailOnce({ sessionId: this.sessionId || undefined, error: "confirm request failed" });
             throw new Error("T9N: failed to confirm payment");
         }
         const payload = (await res.json());
         this.modal?.setConfirmPending(false);
-        this.emitStatus(this.normalizeStatus(payload.status));
-        if (payload.status === "pending" || payload.status === "processing") {
+        const normalized = this.normalizeStatus(payload.status);
+        this.emitStatus(normalized);
+        if (payload.status === "pending" ||
+            payload.status === "processing" ||
+            normalized === "pending_confirmation" ||
+            normalized === "awaiting_payment") {
             this.modal?.showResult("failed", "No payment detected yet. Please try again.");
             this.lastResultFailed = true;
             this.modal?.setConfirmLabel("Retry check");
@@ -202,11 +212,12 @@ export class T9nCheckout {
         if (payload.status === "settled") {
             this.modal?.showResult("success", "Payment received successfully.");
             this.lastResultFailed = false;
-            this.cfg.hooks?.onSuccess?.({ sessionId: this.sessionId, status: payload.status });
+            this.emitSuccessOnce({ sessionId: this.sessionId, status: payload.status });
         }
         if (payload.status === "expired") {
             this.modal?.showResult("failed", "This session has expired.");
             this.lastResultFailed = true;
+            this.emitFailOnce({ sessionId: this.sessionId, error: "checkout expired" });
         }
     }
     startTimer() {
@@ -251,13 +262,19 @@ export class T9nCheckout {
                             window.clearInterval(this.intervalId);
                         if (this.statusPollId)
                             window.clearInterval(this.statusPollId);
-                        this.cfg.hooks?.onSuccess?.({ sessionId: this.sessionId, status: payload.status });
+                        this.emitSuccessOnce({ sessionId: this.sessionId, status: payload.status || "settled" });
                     }
                     if (normalized === "failed") {
                         if (this.hasAttemptedConfirm) {
                             this.modal?.showResult("failed", "No payment detected yet. Please try again.");
                             this.lastResultFailed = true;
-                            this.cfg.hooks?.onFail?.({ sessionId: this.sessionId, error: "checkout failed" });
+                            this.emitFailOnce({ sessionId: this.sessionId, error: "checkout failed" });
+                        }
+                    }
+                    if (normalized === "pending_confirmation" || normalized === "awaiting_payment") {
+                        if (this.hasAttemptedConfirm) {
+                            this.modal?.showResult("failed", "No payment detected yet. Please try again.");
+                            this.lastResultFailed = true;
                         }
                     }
                 }
@@ -268,14 +285,52 @@ export class T9nCheckout {
                         window.clearInterval(this.intervalId);
                     if (this.statusPollId)
                         window.clearInterval(this.statusPollId);
+                    this.emitFailOnce({ sessionId: this.sessionId, error: "checkout expired" });
                 }
             }
             catch (_) {
                 // keep modal alive even if one poll fails
-                this.cfg.hooks?.onFail?.({ sessionId: this.sessionId || undefined, error: "session status poll failed" });
             }
         }, this.cfg.pollIntervalMs);
     }
+    async verifyTransaction(params) {
+        const sessionId = params?.sessionId?.trim();
+        const reference = params?.reference?.trim();
+        if (!sessionId && !reference) {
+            throw new Error("T9N: sessionId or reference is required for verification");
+        }
+        const search = new URLSearchParams();
+        if (sessionId)
+            search.set("sessionId", sessionId);
+        if (reference)
+            search.set("reference", reference);
+        const res = await this.fetchWithTimeout(`${this.getApiBaseUrl()}/api/merchant/checkout/verify?${search.toString()}`, {
+            method: "GET",
+            headers: {
+                "x-public-key": this.cfg.publicKey,
+            },
+        });
+        if (!res.ok) {
+            let message = "T9N: failed to verify transaction";
+            try {
+                const data = await res.json();
+                if (data?.message)
+                    message = data.message;
+            }
+            catch (_) {
+                try {
+                    const text = await res.text();
+                    if (text)
+                        message = text;
+                }
+                catch (_) {
+                    // ignore
+                }
+            }
+            throw new Error(`T9N_VERIFY_ERROR_${res.status}: ${message}`);
+        }
+        return (await res.json());
+    }
     defaultNetworkFor(currency) {
         const map = {
             BTC: "bitcoin",
@@ -391,6 +446,18 @@ export class T9nCheckout {
     emitStatus(status) {
         this.cfg.hooks?.onStatusChange?.(status);
     }
+    emitSuccessOnce(payload) {
+        if (this.successNotified)
+            return;
+        this.successNotified = true;
+        this.cfg.hooks?.onSuccess?.(payload);
+    }
+    emitFailOnce(payload) {
+        if (this.successNotified || this.failureNotified)
+            return;
+        this.failureNotified = true;
+        this.cfg.hooks?.onFail?.(payload);
+    }
     getApiBaseUrl() {
         return this.cfg.apiBaseUrl || resolveDefaultApiBaseUrl();
     }
@@ -401,3 +468,58 @@ function resolveDefaultApiBaseUrl() {
 export function initializeT9n(config) {
     return new T9nCheckout(config);
 }
+export async function verifyT9nTransaction(config, params) {
+    const publicKey = config.publicKey?.trim();
+    if (!publicKey || !/^pk_(live|test)_[a-zA-Z0-9_]+$/.test(publicKey)) {
+        throw new Error("T9N: publicKey must follow pk_live_* or pk_test_* format");
+    }
+    const sessionId = params?.sessionId?.trim();
+    const reference = params?.reference?.trim();
+    if (!sessionId && !reference) {
+        throw new Error("T9N: sessionId or reference is required for verification");
+    }
+    const apiBaseUrl = resolveDefaultApiBaseUrl().trim();
+    const parsedURL = new URL(apiBaseUrl);
+    if (parsedURL.protocol !== "https:" && parsedURL.hostname !== "localhost" && parsedURL.hostname !== "127.0.0.1") {
+        throw new Error("T9N: apiBaseUrl must use HTTPS");
+    }
+    const search = new URLSearchParams();
+    if (sessionId)
+        search.set("sessionId", sessionId);
+    if (reference)
+        search.set("reference", reference);
+    const controller = new AbortController();
+    const timeout = window.setTimeout(() => controller.abort(), config.requestTimeoutMs || 12000);
+    try {
+        const res = await fetch(`${apiBaseUrl}/api/merchant/checkout/verify?${search.toString()}`, {
+            method: "GET",
+            headers: {
+                "x-public-key": publicKey,
+            },
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            let message = "T9N: failed to verify transaction";
+            try {
+                const data = await res.json();
+                if (data?.message)
+                    message = data.message;
+            }
+            catch (_) {
+                try {
+                    const text = await res.text();
+                    if (text)
+                        message = text;
+                }
+                catch (_) {
+                    // ignore
+                }
+            }
+            throw new Error(`T9N_VERIFY_ERROR_${res.status}: ${message}`);
+        }
+        return (await res.json());
+    }
+    finally {
+        window.clearTimeout(timeout);
+    }
+}

package/dist/types.d.ts

@@ -33,6 +33,23 @@ export type T9nHooks = {
         error: string;
     }) => void;
 };
+export type VerifyTransactionParams = {
+    sessionId?: string;
+    reference?: string;
+};
+export type VerifyTransactionResult = {
+    sessionId: string;
+    reference?: string;
+    status: string;
+    selectedCurrency?: string;
+    selectedNetwork?: string;
+    depositAddress?: string;
+    expectedAmountCrypto?: string;
+    expiresAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    settledAt?: string;
+};
 export declare const T9N_DEFAULT_API_BASE_URL = "https://slimepay-server.up.railway.app";
 export declare const checkoutConfigSchema: z.ZodObject<{
     publicKey: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tineon/t9n",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",