pay_hash 1.0.2 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+import { WalletClient, Transport, Chain, Account, WalletActions, PublicActions, Client, RpcSchema, Address, Hex } from 'viem';
+import { TempoActions, Actions } from 'viem/tempo';
+
+type PayHashViemClient = WalletClient<Transport, Chain, Account> & WalletActions<Chain, Account> & PublicActions<Transport, Chain> & TempoActions<Chain, Account> & Omit<Client<Transport, Chain, Account, RpcSchema>, "cacheTime">;
+interface PayHashSDKConfig {
+    client: PayHashViemClient;
+}
+interface PayParams {
+    token: Address;
+    amount: string;
+    memo: Hex;
+    orgAddress: Address;
+    orgName: string;
+    orgMail: string;
+    clientMail: string;
+    additionalInfo?: Hex;
+}
+interface SMTPConfig {
+    host: string;
+    port: number;
+    secure?: boolean;
+    user: string;
+    pass: string;
+}
+type EmailTemplate = {
+    pdfFileName?: string;
+    pdfTemplatePath?: string;
+    pdfTemplateName?: string;
+    emailTemplatePath?: string;
+    emailTemplateName?: string;
+    subject?: string;
+    brandName: string;
+    logoUrl?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    fontFamily?: "inter" | "roboto" | "poppins";
+    titleFontSize?: number;
+    bodyFontSize?: number;
+    footerFontSize?: number;
+    layout?: "compact" | "standard" | "spacious";
+    align?: "left" | "center";
+    receiptTitle?: string;
+    footerText?: string;
+    showTxHash?: boolean;
+    showTimestamp?: boolean;
+};
+
+declare class PayHashClient {
+    private client;
+    private transporter;
+    private emailTemplate;
+    constructor(client: PayHashViemClient, smtp: SMTPConfig, emailTemplate: EmailTemplate);
+    verifyTransporter(): Promise<true>;
+    pay(params: PayParams): Promise<{
+        success: boolean;
+        receipt: Actions.token.transferSync.ReturnValue;
+        account: `0x${string}`;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        receipt?: undefined;
+        account?: undefined;
+    }>;
+    batchPay(params: PayParams[]): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    batchPayAsync(params: PayParams[]): Promise<{
+        success: boolean;
+        results: ({
+            success: boolean;
+            index: number;
+            orgAddress: `0x${string}`;
+            txHash: `0x${string}`;
+            error?: undefined;
+        } | {
+            success: boolean;
+            index: number;
+            orgAddress: `0x${string}`;
+            error: any;
+            txHash?: undefined;
+        })[];
+    }>;
+    private sendReceiptAndEmail;
+}
+
+export { type EmailTemplate, PayHashClient, type PayHashSDKConfig, type PayHashViemClient, type PayParams, type SMTPConfig };

package/dist/index.js

@@ -1,2 +1,255 @@
-export { PayHashClient } from "./client";
-export * from "./types";
+// src/client.ts
+import { parseUnits, stringToHex } from "viem";
+
+// src/pdf.ts
+import puppeteer from "puppeteer";
+import Handlebars from "handlebars";
+import fs from "fs";
+async function generateReceiptPDF(templatePath, data) {
+  const html = fs.readFileSync(templatePath, "utf8");
+  const compiled = Handlebars.compile(html);
+  const content = compiled(data);
+  const browser = await puppeteer.launch({
+    args: ["--no-sandbox"]
+  });
+  const page = await browser.newPage();
+  await page.setContent(content, { waitUntil: "networkidle0" });
+  const pdf = await page.pdf({
+    format: "A4",
+    printBackground: true
+  });
+  await browser.close();
+  return pdf;
+}
+
+// src/mailer.ts
+import nodemailer from "nodemailer";
+function createTransporter(smtp) {
+  return nodemailer.createTransport({
+    host: smtp.host,
+    port: smtp.port,
+    secure: smtp.secure ?? smtp.port === 465,
+    auth: {
+      user: smtp.user,
+      pass: smtp.pass
+    }
+  });
+}
+
+// src/client.ts
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/constants.ts
+var TEMPO_TESTNET_CHAIN_ID = 42429;
+
+// src/render.ts
+import Handlebars2 from "handlebars";
+import fs2 from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function renderReceiptHtml({
+  receipt,
+  template,
+  params,
+  tokenName
+}) {
+  const templateSource = fs2.readFileSync(
+    path.join(
+      template.emailTemplatePath ?? __dirname,
+      template.emailTemplateName ?? "mailTemplate.hbs"
+    ),
+    "utf8"
+  );
+  const templates = Handlebars2.compile(templateSource);
+  return templates({
+    brandName: template.brandName || params.orgName,
+    logoUrl: template.logoUrl || "",
+    primaryColor: template.primaryColor || "#b5a8b0ff",
+    titleFontSize: template.titleFontSize || 20,
+    bodyFontSize: template.bodyFontSize || 14,
+    receiptTitle: template.subject || "Payment Receipt",
+    footerText: template.footerText || "Powered by PayHash",
+    txHash: receipt.transactionHash,
+    payer: receipt.from,
+    timestamp: new Date(receipt.timestamp).toUTCString(),
+    year: (/* @__PURE__ */ new Date()).getFullYear(),
+    amount: params.amount,
+    token: tokenName
+  });
+}
+
+// src/client.ts
+import { Actions } from "viem/tempo";
+var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
+var pdfPath = path2.join(__dirname2, "./receipt.hbs");
+var PayHashClient = class {
+  client;
+  transporter;
+  emailTemplate;
+  constructor(client, smtp, emailTemplate) {
+    this.client = client;
+    this.transporter = createTransporter(smtp);
+    this.emailTemplate = emailTemplate;
+  }
+  async verifyTransporter() {
+    return await this.transporter.verify();
+  }
+  // private loadEmailTemplate(filePath: string, fileName: string) {
+  //   const templatePath = path.join(filePath, fileName);
+  //   const html = fs.readFileSync(templatePath, "utf-8");
+  //   return html;
+  // }
+  async pay(params) {
+    try {
+      const [account] = await this.client?.getAddresses();
+      const metadata = await this.client.token.getMetadata({
+        token: params.token
+      });
+      const tokenName = metadata.symbol;
+      const decimals = metadata.decimals;
+      const chainId = this.client.chain.id;
+      let receipt = null;
+      if (chainId == TEMPO_TESTNET_CHAIN_ID) {
+        receipt = await this.client.token.transferSync({
+          amount: parseUnits(params.amount, decimals),
+          memo: stringToHex(params.memo || "0x"),
+          token: params.token,
+          to: params.orgAddress
+        });
+      }
+      if (receipt == null) {
+        throw new Error("Receipt not found");
+      }
+      await this.sendReceiptAndEmail({
+        params,
+        receipt,
+        txHash: receipt.receipt.transactionHash,
+        tokenName: metadata.symbol
+      });
+      return {
+        success: true,
+        receipt,
+        account
+      };
+    } catch (error) {
+      console.error("[PayHashClient Error]", error);
+      return {
+        success: false,
+        error: error?.message || "Unknown error occurred"
+      };
+    }
+  }
+  // bathch Pay sync to multiple addresses at once
+  async batchPay(params) {
+    for (const param of params) {
+      await this.pay(param);
+    }
+    return {
+      success: true,
+      message: "Batch payment successful"
+    };
+  }
+  // batch Pay async to multiple addresses at once
+  async batchPayAsync(params) {
+    const [account] = await this.client.getAddresses();
+    const nonceKeys = params.map((_, i) => BigInt(i + 1));
+    const nonces = await Promise.all(
+      nonceKeys.map(
+        (nonceKey) => Actions.nonce.getNonce(this.client, { account, nonceKey })
+      )
+    );
+    const results = await Promise.all(
+      params.map(async (param, i) => {
+        try {
+          const metadata = await this.client.token.getMetadata({
+            token: param.token
+          });
+          const decimals = metadata.decimals;
+          const receipt = await Actions.token.transferSync(this.client, {
+            amount: parseUnits(param.amount, decimals),
+            to: param.orgAddress,
+            token: param.token,
+            // memo: stringToHex(param.memo || "0x"),
+            nonceKey: nonceKeys[i],
+            nonce: Number(nonces[i])
+          });
+          await this.sendReceiptAndEmail({
+            params: param,
+            receipt,
+            txHash: receipt.receipt.transactionHash,
+            tokenName: metadata.symbol
+          });
+          return {
+            success: true,
+            index: i,
+            orgAddress: param.orgAddress,
+            txHash: receipt.receipt.transactionHash
+          };
+        } catch (error) {
+          console.error(
+            `[BatchPay Error] index=${i}, org=${param.orgAddress}`,
+            error
+          );
+          return {
+            success: false,
+            index: i,
+            orgAddress: param.orgAddress,
+            error: error?.message ?? "Unknown error"
+          };
+        }
+      })
+    );
+    return {
+      success: true,
+      results
+    };
+  }
+  async sendReceiptAndEmail({
+    params,
+    receipt,
+    txHash,
+    tokenName
+  }) {
+    const pdf = await generateReceiptPDF(
+      path2.join(
+        this.emailTemplate?.pdfTemplatePath ?? __dirname2,
+        this.emailTemplate?.pdfTemplateName ?? "receipt.hbs"
+      ),
+      {
+        brandName: this.emailTemplate?.brandName ?? params.orgName,
+        primaryColor: this.emailTemplate?.primaryColor ?? "#000",
+        receiptTitle: this.emailTemplate?.receiptTitle ?? "Payment Receipt",
+        amount: params.amount,
+        token: tokenName,
+        txHash,
+        date: (/* @__PURE__ */ new Date()).toUTCString(),
+        footerText: this.emailTemplate?.footerText ?? "Powered by PayHash",
+        fontFamily: this.emailTemplate?.fontFamily ?? "Inter",
+        titleFontSize: this.emailTemplate?.titleFontSize ?? 24
+      }
+    );
+    const html = renderReceiptHtml({
+      receipt,
+      template: this.emailTemplate,
+      params,
+      tokenName
+    });
+    await this.transporter.sendMail({
+      from: `${params.orgName} <${params.orgMail}>`,
+      to: `${params.clientMail}, ${params.orgMail}`,
+      subject: this.emailTemplate?.subject ?? "Payment Receipt",
+      html,
+      attachments: [
+        {
+          filename: this.emailTemplate?.pdfFileName ?? "receipt.pdf",
+          content: pdf
+        }
+      ]
+    });
+  }
+};
+export {
+  PayHashClient
+};

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "pay_hash",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "PayHash SDK is a professional TypeScript library designed to streamline blockchain payments, receipt generation, and automated email notifications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/the-first-elder/pay_hash"
@@ -17,9 +23,9 @@
   "author": "the-first-elder",
   "twitter": "https://x.com/The_First_Elder",
   "scripts": {
-    "build": "tsc && npm run copy-templates",
+    "build": "tsup src/index.ts --format esm --dts && npm run copy-templates",
     "copy-templates": "cpy 'src/**/*.hbs' 'dist'",
-    "dev": "tsc --watch"
+    "dev": "tsup src/index.ts --format esm --dts --watch"
   },
   "license": "ISC",
   "type": "module",

package/src/viem.config.ts

@@ -1,13 +1,13 @@
-import { createClient, http, publicActions, walletActions } from 'viem'
-import { privateKeyToAccount } from 'viem/accounts'
-import { tempoTestnet } from 'viem/chains'
-import { tempoActions } from 'viem/tempo'
- 
+import { createClient, http, publicActions, walletActions } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { tempoTestnet } from "viem/chains";
+import { tempoActions } from "viem/tempo";
+
 export const client = createClient({
-  account: privateKeyToAccount('0x...'),
+  account: privateKeyToAccount("0x..."),
   chain: tempoTestnet,
   transport: http(),
 })
   .extend(publicActions)
   .extend(walletActions)
-  .extend(tempoActions())
+  .extend(tempoActions());

package/dist/client.js

@@ -1,163 +0,0 @@
-import { parseUnits, stringToHex } from "viem";
-import { generateReceiptPDF } from "./pdf";
-import { createTransporter } from "./mailer";
-import path from "path";
-import { fileURLToPath } from "url";
-import { TEMPO_TESTNET_CHAIN_ID } from "./constants";
-import { renderReceiptHtml } from "./render";
-import { Actions } from "viem/tempo";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const pdfPath = path.join(__dirname, "./receipt.hbs");
-export class PayHashClient {
-    client;
-    transporter;
-    emailTemplate;
-    constructor(client, smtp, emailTemplate) {
-        this.client = client;
-        this.transporter = createTransporter(smtp);
-        this.emailTemplate = emailTemplate;
-    }
-    async verifyTransporter() {
-        return await this.transporter.verify();
-    }
-    // private loadEmailTemplate(filePath: string, fileName: string) {
-    //   const templatePath = path.join(filePath, fileName);
-    //   const html = fs.readFileSync(templatePath, "utf-8");
-    //   return html;
-    // }
-    async pay(params) {
-        try {
-            const [account] = await this.client?.getAddresses();
-            const metadata = await this.client.token.getMetadata({
-                token: params.token,
-            });
-            const tokenName = metadata.symbol;
-            const decimals = metadata.decimals;
-            const chainId = this.client.chain.id;
-            let receipt = null;
-            if (chainId == TEMPO_TESTNET_CHAIN_ID) {
-                receipt = await this.client.token.transferSync({
-                    amount: parseUnits(params.amount, decimals),
-                    memo: stringToHex(params.memo || "0x"),
-                    token: params.token,
-                    to: params.orgAddress,
-                });
-            }
-            if (receipt == null) {
-                throw new Error("Receipt not found");
-            }
-            await this.sendReceiptAndEmail({
-                params: params,
-                receipt: receipt,
-                txHash: receipt.receipt.transactionHash,
-                tokenName: metadata.symbol,
-            });
-            return {
-                success: true,
-                receipt,
-                account,
-            };
-        }
-        catch (error) {
-            console.error("[PayHashClient Error]", error);
-            return {
-                success: false,
-                error: error?.message || "Unknown error occurred",
-            };
-        }
-    }
-    // bathch Pay sync to multiple addresses at once
-    async batchPay(params) {
-        for (const param of params) {
-            await this.pay(param);
-        }
-        return {
-            success: true,
-            message: "Batch payment successful",
-        };
-    }
-    // batch Pay async to multiple addresses at once
-    async batchPayAsync(params) {
-        const [account] = await this.client.getAddresses();
-        // 1️⃣ unique nonce key per tx
-        const nonceKeys = params.map((_, i) => BigInt(i + 1));
-        // 2️⃣ fetch all nonces in parallel
-        const nonces = await Promise.all(nonceKeys.map((nonceKey) => Actions.nonce.getNonce(this.client, { account, nonceKey })));
-        // 3️⃣ send all txs in parallel with per-item error handling
-        const results = await Promise.all(params.map(async (param, i) => {
-            try {
-                const metadata = await this.client.token.getMetadata({
-                    token: param.token,
-                });
-                const decimals = metadata.decimals;
-                const receipt = await Actions.token.transferSync(this.client, {
-                    amount: parseUnits(param.amount, decimals),
-                    to: param.orgAddress,
-                    token: param.token,
-                    // memo: stringToHex(param.memo || "0x"),
-                    nonceKey: nonceKeys[i],
-                    nonce: Number(nonces[i]),
-                });
-                await this.sendReceiptAndEmail({
-                    params: param,
-                    receipt: receipt,
-                    txHash: receipt.receipt.transactionHash,
-                    tokenName: metadata.symbol,
-                });
-                return {
-                    success: true,
-                    index: i,
-                    orgAddress: param.orgAddress,
-                    txHash: receipt.receipt.transactionHash,
-                };
-            }
-            catch (error) {
-                console.error(`[BatchPay Error] index=${i}, org=${param.orgAddress}`, error);
-                return {
-                    success: false,
-                    index: i,
-                    orgAddress: param.orgAddress,
-                    error: error?.message ?? "Unknown error",
-                };
-            }
-        }));
-        return {
-            success: true,
-            results,
-        };
-    }
-    async sendReceiptAndEmail({ params, receipt, txHash, tokenName, }) {
-        /* Generate PDF */
-        const pdf = await generateReceiptPDF(path.join(this.emailTemplate?.pdfTemplatePath ?? __dirname, this.emailTemplate?.pdfTemplateName ?? "receipt.hbs"), {
-            brandName: this.emailTemplate?.brandName ?? params.orgName,
-            primaryColor: this.emailTemplate?.primaryColor ?? "#000",
-            receiptTitle: this.emailTemplate?.receiptTitle ?? "Payment Receipt",
-            amount: params.amount,
-            token: tokenName,
-            txHash,
-            date: new Date().toUTCString(),
-            footerText: this.emailTemplate?.footerText ?? "Powered by PayHash",
-            fontFamily: this.emailTemplate?.fontFamily ?? "Inter",
-            titleFontSize: this.emailTemplate?.titleFontSize ?? 24,
-        });
-        const html = renderReceiptHtml({
-            receipt,
-            template: this.emailTemplate,
-            params,
-            tokenName,
-        });
-        /* Send email */
-        await this.transporter.sendMail({
-            from: `${params.orgName} <${params.orgMail}>`,
-            to: `${params.clientMail}, ${params.orgMail}`,
-            subject: this.emailTemplate?.subject ?? "Payment Receipt",
-            html,
-            attachments: [
-                {
-                    filename: this.emailTemplate?.pdfFileName ?? "receipt.pdf",
-                    content: pdf,
-                },
-            ],
-        });
-    }
-}

package/dist/constants.js

@@ -1 +0,0 @@
-export const TEMPO_TESTNET_CHAIN_ID = 42429;

package/dist/contracts.js

@@ -1,2 +0,0 @@
-export const STABLE_TOKEN = "0x0000000000000000000000000000000000000000"; // Replace with actual address
-export const PAYHASH_CONTRACT = "0x0000000000000000000000000000000000000000"; // Replace with actual address

package/dist/mailer.js

@@ -1,13 +0,0 @@
-// mailer.ts
-import nodemailer from "nodemailer";
-export function createTransporter(smtp) {
-    return nodemailer.createTransport({
-        host: smtp.host,
-        port: smtp.port,
-        secure: smtp.secure ?? smtp.port === 465,
-        auth: {
-            user: smtp.user,
-            pass: smtp.pass,
-        },
-    });
-}

package/dist/pdf.js

@@ -1,19 +0,0 @@
-import puppeteer from "puppeteer";
-import Handlebars from "handlebars";
-import fs from "fs";
-export async function generateReceiptPDF(templatePath, data) {
-    const html = fs.readFileSync(templatePath, "utf8");
-    const compiled = Handlebars.compile(html);
-    const content = compiled(data);
-    const browser = await puppeteer.launch({
-        args: ["--no-sandbox"],
-    });
-    const page = await browser.newPage();
-    await page.setContent(content, { waitUntil: "networkidle0" });
-    const pdf = await page.pdf({
-        format: "A4",
-        printBackground: true,
-    });
-    await browser.close();
-    return pdf;
-}

package/dist/render.js

@@ -1,24 +0,0 @@
-import Handlebars from "handlebars";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export function renderReceiptHtml({ receipt, template, params, tokenName, }) {
-    const templateSource = fs.readFileSync(path.join(template.emailTemplatePath ?? __dirname, template.emailTemplateName ?? "mailTemplate.hbs"), "utf8");
-    const templates = Handlebars.compile(templateSource);
-    return templates({
-        brandName: template.brandName || params.orgName,
-        logoUrl: template.logoUrl || "",
-        primaryColor: template.primaryColor || "#b5a8b0ff",
-        titleFontSize: template.titleFontSize || 20,
-        bodyFontSize: template.bodyFontSize || 14,
-        receiptTitle: template.subject || "Payment Receipt",
-        footerText: template.footerText || "Powered by PayHash",
-        txHash: receipt.transactionHash,
-        payer: receipt.from,
-        timestamp: new Date(receipt.timestamp).toUTCString(),
-        year: new Date().getFullYear(),
-        amount: params.amount,
-        token: tokenName,
-    });
-}

package/dist/types.js

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

package/dist/utils.js

@@ -1 +0,0 @@
-"use strict";

package/dist/viem.config.js

@@ -1,12 +0,0 @@
-import { createClient, http, publicActions, walletActions } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { tempoTestnet } from 'viem/chains';
-import { tempoActions } from 'viem/tempo';
-export const client = createClient({
-    account: privateKeyToAccount('0x...'),
-    chain: tempoTestnet,
-    transport: http(),
-})
-    .extend(publicActions)
-    .extend(walletActions)
-    .extend(tempoActions());