@swirepay-developer/swirepay-ach-sdk 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swirepay-developer/swirepay-ach-sdk",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Swirepay Ach Payment SDK (Web Component with Modal UI)",
   "main": "index.js",
   "type": "module",

package/web-component/swirepay-checkout.js

@@ -3,7 +3,8 @@ import { isValidPhoneNumber } from "libphonenumber-js";
 
 const SDK_CONFIG = {
     elliptic: "https://cdnjs.cloudflare.com/ajax/libs/elliptic/6.3.1/elliptic.js",
-    crypto: "https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.2.0/crypto-js.min.js"
+    crypto: "https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.2.0/crypto-js.min.js",
+    plaid: "https://cdn.plaid.com/link/v2/stable/link-initialize.js"
 };
 class EventEmitter {
     constructor() { this.events = {}; }
@@ -108,133 +109,8 @@ const USA_STATES = [
 ];
 
 const COUNTRIES_LIST = [
-    { "name": "Afghanistan", "code": "AF" },
-    { "name": "Albania", "code": "AL" },
-    { "name": "Algeria", "code": "DZ" },
-    { "name": "Andorra", "code": "AD" },
-    { "name": "Angola", "code": "AO" },
-    { "name": "Antigua and Barbuda", "code": "AG" },
-    { "name": "Argentina", "code": "AR" },
-    { "name": "Armenia", "code": "AM" },
-    { "name": "Australia", "code": "AU" },
-    { "name": "Austria", "code": "AT" },
-    { "name": "Azerbaijan", "code": "AZ" },
-    { "name": "Bahamas", "code": "BS" },
-    { "name": "Bahrain", "code": "BH" },
-    { "name": "Bangladesh", "code": "BD" },
-    { "name": "Barbados", "code": "BB" },
-    { "name": "Belarus", "code": "BY" },
-    { "name": "Belgium", "code": "BE" },
-    { "name": "Belize", "code": "BZ" },
-    { "name": "Benin", "code": "BJ" },
-    { "name": "Bhutan", "code": "BT" },
-    { "name": "Bolivia", "code": "BO" },
-    { "name": "Bosnia and Herzegovina", "code": "BA" },
-    { "name": "Botswana", "code": "BW" },
-    { "name": "Brazil", "code": "BR" },
-    { "name": "Brunei", "code": "BN" },
-    { "name": "Bulgaria", "code": "BG" },
-    { "name": "Burkina Faso", "code": "BF" },
-    { "name": "Burundi", "code": "BI" },
-    { "name": "Cambodia", "code": "KH" },
-    { "name": "Cameroon", "code": "CM" },
-    { "name": "Canada", "code": "CA" },
-    { "name": "Cape Verde", "code": "CV" },
-    { "name": "Central African Republic", "code": "CF" },
-    { "name": "Chad", "code": "TD" },
-    { "name": "Chile", "code": "CL" },
-    { "name": "China", "code": "CN" },
-    { "name": "Colombia", "code": "CO" },
-    { "name": "Comoros", "code": "KM" },
-    { "name": "Congo", "code": "CG" },
-    { "name": "Costa Rica", "code": "CR" },
-    { "name": "Croatia", "code": "HR" },
-    { "name": "Cuba", "code": "CU" },
-    { "name": "Cyprus", "code": "CY" },
-    { "name": "Czech Republic", "code": "CZ" },
-    { "name": "Denmark", "code": "DK" },
-    { "name": "Djibouti", "code": "DJ" },
-    { "name": "Dominica", "code": "DM" },
-    { "name": "Dominican Republic", "code": "DO" },
-    { "name": "Ecuador", "code": "EC" },
-    { "name": "Egypt", "code": "EG" },
-    { "name": "El Salvador", "code": "SV" },
-    { "name": "Equatorial Guinea", "code": "GQ" },
-    { "name": "Eritrea", "code": "ER" },
-    { "name": "Estonia", "code": "EE" },
-    { "name": "Ethiopia", "code": "ET" },
-    { "name": "Fiji", "code": "FJ" },
-    { "name": "Finland", "code": "FI" },
-    { "name": "France", "code": "FR" },
-    { "name": "Gabon", "code": "GA" },
-    { "name": "Gambia", "code": "GM" },
-    { "name": "Georgia", "code": "GE" },
-    { "name": "Germany", "code": "DE" },
-    { "name": "Ghana", "code": "GH" },
-    { "name": "Greece", "code": "GR" },
-    { "name": "Grenada", "code": "GD" },
-    { "name": "Guatemala", "code": "GT" },
-    { "name": "Guinea", "code": "GN" },
-    { "name": "Guyana", "code": "GY" },
-    { "name": "Haiti", "code": "HT" },
-    { "name": "Honduras", "code": "HN" },
-    { "name": "Hungary", "code": "HU" },
-    { "name": "Iceland", "code": "IS" },
     { "name": "India", "code": "IN" },
-    { "name": "Indonesia", "code": "ID" },
-    { "name": "Iran", "code": "IR" },
-    { "name": "Iraq", "code": "IQ" },
-    { "name": "Ireland", "code": "IE" },
-    { "name": "Israel", "code": "IL" },
-    { "name": "Italy", "code": "IT" },
-    { "name": "Jamaica", "code": "JM" },
-    { "name": "Japan", "code": "JP" },
-    { "name": "Jordan", "code": "JO" },
-    { "name": "Kazakhstan", "code": "KZ" },
-    { "name": "Kenya", "code": "KE" },
-    { "name": "Korea, South", "code": "KR" },
-    { "name": "Kuwait", "code": "KW" },
-    { "name": "Laos", "code": "LA" },
-    { "name": "Latvia", "code": "LV" },
-    { "name": "Lebanon", "code": "LB" },
-    { "name": "Libya", "code": "LY" },
-    { "name": "Lithuania", "code": "LT" },
-    { "name": "Luxembourg", "code": "LU" },
-    { "name": "Malaysia", "code": "MY" },
-    { "name": "Maldives", "code": "MV" },
-    { "name": "Mexico", "code": "MX" },
-    { "name": "Monaco", "code": "MC" },
-    { "name": "Morocco", "code": "MA" },
-    { "name": "Nepal", "code": "NP" },
-    { "name": "Netherlands", "code": "NL" },
-    { "name": "New Zealand", "code": "NZ" },
-    { "name": "Nigeria", "code": "NG" },
-    { "name": "Norway", "code": "NO" },
-    { "name": "Oman", "code": "OM" },
-    { "name": "Pakistan", "code": "PK" },
-    { "name": "Panama", "code": "PA" },
-    { "name": "Peru", "code": "PE" },
-    { "name": "Philippines", "code": "PH" },
-    { "name": "Poland", "code": "PL" },
-    { "name": "Portugal", "code": "PT" },
-    { "name": "Qatar", "code": "QA" },
-    { "name": "Romania", "code": "RO" },
-    { "name": "Russia", "code": "RU" },
-    { "name": "Saudi Arabia", "code": "SA" },
-    { "name": "Singapore", "code": "SG" },
-    { "name": "South Africa", "code": "ZA" },
-    { "name": "Spain", "code": "ES" },
-    { "name": "Sri Lanka", "code": "LK" },
-    { "name": "Sweden", "code": "SE" },
-    { "name": "Switzerland", "code": "CH" },
-    { "name": "Thailand", "code": "TH" },
-    { "name": "Turkey", "code": "TR" },
-    { "name": "Ukraine", "code": "UA" },
-    { "name": "United Arab Emirates", "code": "AE" },
-    { "name": "United Kingdom", "code": "GB" },
     { "name": "United States", "code": "US" },
-    { "name": "Vietnam", "code": "VN" },
-    { "name": "Zimbabwe", "code": "ZW" }
 ];
 
 const DEFAULT_THEME = {
@@ -279,20 +155,121 @@ export class SwirepayCheckout extends HTMLElement {
         this.theme = DEFAULT_THEME;
     }
 
+    getEndpoints() {
+        if (this.test) {
+            return { gateway: 'https://staging-backend.swirepay.com' };
+        }
+        return { gateway: 'https://api.swirepay.com' };
+    }
+
+    async getSplitUpDetails(inventoryOrder) {
+        const payload = {
+            shopGid: inventoryOrder?.shopGid,
+            items: inventoryOrder?.inventoryOrderLineItems,
+            tipType: "AMOUNT",
+            tip: inventoryOrder?.totalTip
+        }
+        const gateway = this.getEndpoints().gateway;
+        let url = `${gateway}/v1/inventory/order/inventory-order-split-up`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify(payload)
+        })
+        return await response.json();
+    }
+
+    async updateFromAttributes() {
+        try {
+            this.amount = parseInt(this.getAttribute("amount")) || 0;
+            this.test = this.getAttribute("mode") === "test";
+            this.currencyCode = this.getAttribute("currencycode");
+            this.apiKey = this.getAttribute("api-key");
+            this.isAddressRequired = this.getAttribute("isaddressrequired") === "true";
+            this.inventory = this.getAttribute("inventory") === "true";
+            this.planGid = this.getAttribute("plangid");
+            this.productName = this.getAttribute("productname");
+            this.frequency = this.getAttribute("frequency");
+            this.description = this.getAttribute("description");
+            this.totalPayments = this.getAttribute("totalpayments");
+            this.accountGid = this.getAttribute("accountgid");
+            const customerAttr = this.getAttribute("customer");
+            this.customer = customerAttr ? JSON.parse(customerAttr) : {};
+
+            const inventoryOrders = this.getAttribute("inventoryorders");
+            this.inventoryOrder = inventoryOrders ? JSON.parse(inventoryOrders) : {};
+            if (this.inventory && this.inventoryOrder) {
+                const splitUpInfo = await this.getSplitUpDetails(this.inventoryOrder);
+                this.splitUp = splitUpInfo?.entity;
+            }
+
+        } catch (e) {
+            console.error("Attribute parsing error:", e);
+        }
+    }
+
     async connectedCallback() {
-        this.amount = parseInt(this.getAttribute("amount")) || 0;
-        this.test = this.getAttribute("mode") === "test";
-        this.amount = parseInt(this.getAttribute("amount")) || 0;
-        this.currencyCode = this.getAttribute("currencyCode");
-        this.apiKey = this.getAttribute("api-key");
+        await this.updateFromAttributes();
+
         await Promise.all([
             loadScript(SDK_CONFIG.elliptic),
-            loadScript(SDK_CONFIG.crypto)
+            loadScript(SDK_CONFIG.crypto),
+            loadScript(SDK_CONFIG.plaid)
         ]);
 
         this.render();
     }
 
+    static get observedAttributes() {
+        return [
+            "amount",
+            "mode",
+            "currencycode",
+            "api-key",
+            "isaddressrequired",
+            "inventory",
+            "plangid",
+            "productname",
+            "frequency",
+            "description",
+            "totalpayments",
+            "customer",
+            "inventoryorders"
+        ];
+    }
+
+    async attributeChangedCallback(name, oldValue, newValue) {
+        if (oldValue === newValue) return;
+
+        await this.updateFromAttributes();
+
+        if (this.shadowRoot) {
+            this.render();
+        }
+    }
+
+    setError(id, message) {
+        const input = this.shadow.getElementById(id);
+        const errorEl = this.shadow.getElementById(`error-${id}`);
+
+        if (errorEl) errorEl.textContent = message || "";
+
+        if (input) {
+            if (message) input.classList.add("input-error");
+            else input.classList.remove("input-error");
+        }
+    }
+
+    clearErrors() {
+        this.shadow.querySelectorAll(".error").forEach(e => e.textContent = "");
+        this.shadow.querySelectorAll("input, select").forEach(el => {
+            el.classList.remove("input-error");
+        });
+    }
+
     async encryptData(data, serverPublicKey, clientPrivateKey, keyId) {
         try {
             const EC = window.elliptic.ec;
@@ -347,13 +324,6 @@ export class SwirepayCheckout extends HTMLElement {
         }
     }
 
-    getEndpoints() {
-        if (this.test) {
-            return { gateway: 'https://staging-backend.swirepay.com' };
-        }
-        return { gateway: 'https://api.swirepay.com' };
-    }
-
     async createCustomer(payload) {
         const gateway = this.getEndpoints().gateway;
         let url = `${gateway}/v3/customer`;
@@ -371,6 +341,31 @@ export class SwirepayCheckout extends HTMLElement {
         return await response.json();
     }
 
+    async initPlaid() {
+        const gateway = this.getEndpoints().gateway;
+        let url = `${gateway}/v1/integration/plaid/${this.accountGid}/create-secure-link-token?isTest=${!this.test}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify({})
+        })
+        const response = await res.json();
+
+        this.plaidHandler = Plaid.create({
+            token: response?.entity?.token,
+
+            onSuccess: async (public_token, metadata) => {
+                this.processorToken = public_token;
+
+                this.shadow.getElementById("bank-status").textContent =
+                    `Connected: ${metadata.institution.name}`;
+            }
+        });
+    }
+
     async addPaymentMethod(payload) {
         const gateway = this.getEndpoints().gateway;
         let url = `${gateway}/v3/payment-method`;
@@ -388,6 +383,109 @@ export class SwirepayCheckout extends HTMLElement {
         return await response.json();
     }
 
+    async createOrder() {
+        const gateway = this.getEndpoints().gateway;
+        let url = `${gateway}/v1/inventory/order`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify(this.inventoryOrder)
+        })
+        return await response.json();
+    }
+
+    async getSubScription(payload) {
+        const gateway = this.getEndpoints().gateway;
+        let url = `${gateway}/v2/subscription`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify(payload)
+        })
+        return await response.json();
+    }
+
+    async getPlan() {
+        const gateway = this.getEndpoints().gateway;
+        let url = `${gateway}/v2/plan?isInternal.EQ=false&name.EQ=Recurring%20Plan`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            }
+        })
+        return await response.json();
+    }
+
+    async addedPlanInfo() {
+        const payload = {
+            "currencyCode": this.currencyCode,
+            "name": "Recurring Plan",
+            "description": "Recurring Plan",
+            "note": "Recurring Plan",
+            "billingFrequency": this.frequency,
+            "billingPeriod": 1
+        }
+        const gateway = this.getEndpoints().gateway;
+        let url = `${gateway}/v2/plan`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify(payload)
+        })
+        return await response.json();
+    }
+
+    async getItemInfo() {
+        const gateway = this.getEndpoints().gateway;
+        let url = `${gateway}/v1/inventory/item?name.EQ=Recurring%20item&priceType.EQ=VARIABLE&isRecurring.EQ=true`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+        })
+        return await response.json();
+    }
+
+    async addedItemInfo() {
+        const payload = {
+            "name": "Recurring item",
+            "alternateName": "Recurring item",
+            "onlineName": "Recurring item",
+            "onlineEnabled": true,
+            "price": 100,
+            "priceType": "VARIABLE",
+            "includeTax": true,
+            "available": true,
+            "recurring": true,
+            "onKiosk": true
+        }
+        const gateway = this.getEndpoints().gateway;
+        let url = `${gateway}/v1/inventory/item`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+            },
+            body: JSON.stringify(payload)
+        })
+        return await response.json();
+    }
+
+
     async getServerEncription() {
         try {
             const gateway = this.getEndpoints().gateway;
@@ -443,9 +541,11 @@ export class SwirepayCheckout extends HTMLElement {
         return v.replace(/\D/g, "").slice(0, 10);
     }
     handleCountryChange() {
-        const country = this.shadow.getElementById("country").value;
+        const countryEl = this.shadow.getElementById("country");
         const phoneCodeEl = this.shadow.getElementById("phone-code");
         const stateEl = this.shadow.getElementById("state");
+        if (!countryEl || !phoneCodeEl || !stateEl) return;
+        const country = countryEl.value;
         phoneCodeEl.value = COUNTRY_PHONE_MAP[country] || "";
         const states = getStates(country);
         stateEl.innerHTML = states.map(
@@ -453,50 +553,134 @@ export class SwirepayCheckout extends HTMLElement {
         ).join("");
     }
 
+    detectCardType(number) {
+        const n = number.replace(/\s/g, "");
+
+        if (/^4/.test(n)) return "VISA";
+        if (/^5[1-5]/.test(n)) return "MASTERCARD";
+        if (/^3[47]/.test(n)) return "AMEX";
+        if (/^6(?:011|5)/.test(n)) return "DISCOVER";
+
+        return "";
+    }
+
+    getAddressFields() {
+        if (!this.isAddressRequired) return "";
+
+        return `
+        <div class="section">
+  <div class="section-title">Address</div>
+
+  <div class="field">
+    <input id="street" required placeholder=" " />
+    <label>Street *</label>
+  </div>
+  <div class="error" id="error-street"></div>
+
+  <div class="field">
+    <input id="city" required placeholder=" " />
+    <label>City *</label>
+  </div>
+  <div class="error" id="error-city"></div>
+
+  <div class="field">
+  <select id="state"></select>
+  <label class="floating">State *</label>
+</div>
+  <div class="error" id="error-state"></div>
+
+  <div class="field">
+    <select id="country" required>
+      ${COUNTRIES_LIST.map(c =>
+            `<option value="${c.code}" ${c.code === "US" ? "selected" : ""}>${c.name}</option>`
+        ).join("")}
+    </select>
+    <label class="floating">Country *</label>
+  </div>
+  <div class="error" id="error-country"></div>
+
+  <div class="field">
+    <input id="zip" required placeholder=" " />
+    <label>ZIP Code *</label>
+  </div>
+  <div class="error" id="error-zip"></div>
+
+</div>
+    `;
+    }
+
     validate() {
+        this.clearErrors();
+        let isValid = true;
+
         const get = id => this.shadow.getElementById(id)?.value?.trim();
+        if (!get("name")) {
+            this.setError("name", "Name required");
+            isValid = false;
+        }
 
-        const name = get("name");
         const email = get("email");
-        const phone = get("phone");
-        const code = get("phone-code");
-        const zip = get("zip");
-        const country = get("country");
-
-        const accountName = get("account-name");
-        const accountNumber = get("account-number");
-        const routingNumber = get("routing-number");
-        const accountType = get("account-type");
-        const bankName = get("bank-name");
-        const businessType = get("business-type");
-        const street = get("street");
-        if (!name) return "Name required";
-        if (!email) return "Email required";
-        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) return "Invalid email address";
-        if (!accountName) return "Account holder name required";
-
-        if (!accountNumber || !/^\d{6,18}$/.test(accountNumber)) {
-            return "Invalid account number";
+        if (!email) {
+            this.setError("email", "Email required");
+            isValid = false;
+        } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+            this.setError("email", "Invalid email");
+            isValid = false;
         }
 
-        if (!routingNumber || !/^\d{9}$/.test(routingNumber)) {
-            return "Invalid routing number (must be 9 digits)";
+        const phone = get("phone")?.replace(/\D/g, "");
+        const code = get("phone-code");
+        if (!phone || !code) {
+            this.setError("phone", "Phone number required");
+            isValid = false;
+        } else {
+            const fullNumber = `${code}${phone}`;
+            if (!isValidPhoneNumber(fullNumber)) {
+                this.setError("phone", "Invalid phone number");
+                isValid = false;
+            }
+        }
+        if (!this.processorToken) {
+            this.setError("bank", "Please link bank account");
+            isValid = false;
+        }
+        if (!get("business-type")) {
+            this.setError("business-type", "Select business type");
+            isValid = false;
         }
+        if (this.isAddressRequired) {
+            if (!get("street")) {
+                this.setError("street", "Street required");
+                isValid = false;
+            }
 
-        if (!accountType) return "Select account type";
+            if (!get("city")) {
+                this.setError("city", "City required");
+                isValid = false;
+            }
 
-        if (!bankName) return "Bank name required";
+            if (!get("state")) {
+                this.setError("state", "State required");
+                isValid = false;
+            }
 
-        if (!businessType) return "Select business type";
-        if (!street) return "Street address required";
-        if (phone && !isValidPhoneNumber(code + phone)) {
-            return "Invalid phone";
-        }
-        if (zip && postalCodes.validate(country, zip) !== true) {
-            return "Invalid ZIP";
+            if (!get("country")) {
+                this.setError("country", "Country required");
+                isValid = false;
+            }
+
+            const zip = get("zip");
+
+            if (!zip) {
+                this.setError("zip", "ZIP required");
+                isValid = false;
+            } else if (postalCodes.validate(get("country"), zip) !== true) {
+                this.setError("zip", "Invalid ZIP code");
+                isValid = false;
+            }
         }
 
-        return null;
+        return isValid;
     }
 
     formatAccountNumber(v) {
@@ -507,21 +691,7 @@ export class SwirepayCheckout extends HTMLElement {
         return v.replace(/\D/g, "").slice(0, 9);
     }
 
-    async handleSubmit(e) {
-        e.preventDefault();
-
-        const payButton = this.shadow.getElementById("form").querySelector(".btn");
-        payButton.disabled = true;
-        payButton.textContent = "Processing...";
-
-        const err = this.validate();
-        if (err) {
-            alert(err);
-            payButton.disabled = false;
-            payButton.textContent = `Pay $${(this.amount / 100).toFixed(2)}`;
-            return;
-        }
-
+    async oneTimePayment() {
         try {
             const values = await this.getServerEncription();
             if (values?.public_key) {
@@ -533,11 +703,7 @@ export class SwirepayCheckout extends HTMLElement {
                     const phone = getVal("phone");
 
                     const bankDetails = {
-                        name: getVal("account-name"),
-                        accountNumber: getVal("account-number"),
-                        routingNumber: getVal("routing-number"),
-                        accountType: getVal("account-type"),
-                        bankName: getVal("bank-name"),
+                        plaidPublicToken: this.processorToken,
                         businessType: getVal("business-type"),
                     };
 
@@ -547,13 +713,17 @@ export class SwirepayCheckout extends HTMLElement {
                         phone: phone ? `${phoneCode}${phone}` : null
                     };
 
-                    const address = {
-                        street: getVal("street"),
-                        city: getVal("city"),
-                        state: getVal("state"),
-                        countryCode: getVal("country"),
-                        postalCode: getVal("zip")
-                    };
+                    let address = null;
+
+                    if (this.isAddressRequired) {
+                        address = {
+                            street: getVal("street"),
+                            city: getVal("city"),
+                            state: getVal("state"),
+                            countryCode: getVal("country"),
+                            postalCode: getVal("zip")
+                        };
+                    }
 
                     const encriptedData = await this.encryptData(JSON.stringify(customer), values.public_key, keys.privateKey, values.key_id);
                     const payload = {
@@ -568,7 +738,7 @@ export class SwirepayCheckout extends HTMLElement {
                     const pmPayload = {
                         type: 'ACH_LEGACY',
                         bank: bankDetails,
-                        postalCode: address?.zip,
+                        postalCode: address?.postalCode,
                         paymentMethodBillingAddress: address,
                         customerGid: customerGid
                     };
@@ -614,20 +784,272 @@ export class SwirepayCheckout extends HTMLElement {
                         body: JSON.stringify({ data: payload2?.data })
                     });
                     const resData = await res.json();
-                    if (resData?.entity?.errorCode === null){
-                        this.events.emit("success", resData);
-                        this.close();
-                    } else if (resData?.entity?.errorCode !== null){
-                        console.error("Payment Error:", resData?.entity?.errorDescription);
-                        this.events.emit("error", resData?.entity?.errorDescription);
-                        alert(resData?.entity?.errorDescription || "Payment failed");
-                    } 
+                    return resData;
+                }
+            }
+        } catch (error) {
+            console.error("Payment Error:", error);
+            this.events.emit("error", error);
+        }
+    }
+
+    async recurringPayment() {
+        try {
+            const values = await this.getServerEncription();
+            if (values?.public_key) {
+                const keys = await this.generateClientKeyPair();
+                if (keys?.privateKey) {
+                    const getVal = id => this.shadow.getElementById(id)?.value?.trim();
+                    const phoneCode = getVal("phone-code") || "";
+                    const phone = getVal("phone");
+
+                    const bankDetails = {
+                        plaidPublicToken: this.processorToken,
+                        businessType: getVal("business-type"),
+                    };
+
+                    const customer = {
+                        name: getVal("name"),
+                        email: getVal("email"),
+                        phone: phone ? `${phoneCode}${phone}` : null
+                    };
+
+                    let address = null;
+
+                    if (this.isAddressRequired) {
+                        address = {
+                            street: getVal("street"),
+                            city: getVal("city"),
+                            state: getVal("state"),
+                            countryCode: getVal("country"),
+                            postalCode: getVal("zip")
+                        };
+                    }
+
+                    const encriptedData = await this.encryptData(JSON.stringify(customer), values.public_key, keys.privateKey, values.key_id);
+                    const payload = {
+                        publicKey: keys?.publicKey,
+                        keyId: encriptedData?.keyId,
+                        iv: encriptedData?.iv,
+                        data: encriptedData?.encryptedData,
+                    }
+                    const newCustomer = await this.createCustomer(payload);
+                    const customerGid = newCustomer.entity?.gid;
+                    let product;
+                    const itemInfo = await this.getItemInfo();
+                    if (itemInfo?.entity?.content[0]?.gid) {
+                        product = itemInfo?.entity?.content[0];
+                    } else {
+                        const newItemInfo = await this.addedItemInfo();
+                        product = newItemInfo?.entity;
+                    }
+                    let plan;
+                    const planInfo = await this.getPlan();
+                    if (planInfo?.entity?.content[0]?.gid) {
+                        plan = planInfo?.entity?.content[0];
+                    } else {
+                        const newPlanInfo = await this.addedPlanInfo();
+                        plan = newPlanInfo?.entity;
+                    }
+
+                    const subscriptionData = {
+                        currencyCode: this.currencyCode,
+                        customerGid: customerGid,
+                        plan2Gid: plan?.gid,
+                        plan2BillingPeriod: 1,
+                        plan2BillingFrequency: this.frequency,
+                        plan2StartDate: new Date().toISOString(),
+                        plan2TotalPayments: this.totalPayments,
+                        description: this.description,
+                        notificationType: "ALL",
+                        emailRecipientList: [
+                            customer.email
+                        ],
+                        canCustomerCancelOrPause: true,
+                        subscription2LineItems: [
+                            {
+                                itemGid: product?.gid,
+                                quantity: 1,
+                                upfront: false,
+                                currencyCode: this.currencyCode,
+                                amount: this.amount
+                            }
+                        ]
+                    }
+                    const subscriptionDetails = await this.getSubScription(subscriptionData);
+                    const subscription = subscriptionDetails?.entity;
+                    const sessionData = {
+                        link: subscription?.subscription2Links[0]?.link,
+                        customer: subscription?.customer,
+                        type: 'ACH_LEGACY',
+                        bank: bankDetails,
+                        postalCode: address?.postalCode,
+                        paymentMethodBillingAddress: address
+                    }
+                    const encriptedData4 = await this.encryptData(JSON.stringify(sessionData), values.public_key, keys.privateKey, values.key_id);
+                    const payload2 = {
+                        publicKey: keys?.publicKey,
+                        keyId: encriptedData4?.keyId,
+                        iv: encriptedData4?.iv,
+                        data: encriptedData4?.encryptedData,
+                    }
+                    const gateway = this.getEndpoints().gateway;
+                    const url = `${gateway}/v2/subscription-link/${subscription?.subscription2Links[0]?.gid}/payment-method`;
+                    const res = await fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'x-enc-public-key': payload2?.publicKey,
+                            'x-enc-key-id': payload2?.keyId,
+                            'x-enc-iv': payload2?.iv,
+                            'Content-Type': 'application/json',
+                            'x-api-key': this.apiKey,
+                        },
+                        body: JSON.stringify({ data: payload2?.data })
+                    });
+                    const resData = await res.json();
+                    return resData;
+                }
+            }
+        } catch (error) {
+            console.error("Payment Error:", error);
+            this.events.emit("error", error);
+        }
+    }
+
+
+    async inventoryCharge() {
+        try {
+            const values = await this.getServerEncription();
+            if (values?.public_key) {
+                const keys = await this.generateClientKeyPair();
+                if (keys?.privateKey) {
+                    const getVal = id => this.shadow.getElementById(id)?.value?.trim();
+                    const phoneCode = getVal("phone-code") || "";
+                    const phone = getVal("phone");
+
+                    const bankDetails = {
+                        plaidPublicToken: this.processorToken,
+                        businessType: getVal("business-type"),
+                    };
+
+                    const customer = {
+                        name: getVal("name"),
+                        email: getVal("email"),
+                        phone: phone ? `${phoneCode}${phone}` : null
+                    };
+
+                    let address = null;
+
+                    if (this.isAddressRequired) {
+                        address = {
+                            street: getVal("street"),
+                            city: getVal("city"),
+                            state: getVal("state"),
+                            countryCode: getVal("country"),
+                            postalCode: getVal("zip")
+                        };
+                    }
+
+                    const encriptedData = await this.encryptData(JSON.stringify(customer), values.public_key, keys.privateKey, values.key_id);
+                    const payload = {
+                        publicKey: keys?.publicKey,
+                        keyId: encriptedData?.keyId,
+                        iv: encriptedData?.iv,
+                        data: encriptedData?.encryptedData,
+                    }
+                    const newCustomer = await this.createCustomer(payload);
+                    const customerGid = newCustomer.entity?.gid;
+                    const orderDetails = await this.createOrder();
+                    const order = orderDetails?.entity;
+                    const sessionData = {
+                        customer: customer,
+                        customerGid: customerGid,
+                        paymentMethod: {
+                            bank: bankDetails,
+                            postalCode: address?.postalCode,
+                            type: "ACH_LEGACY",
+                            paymentMethodBillingAddress: address,
+                        }
+                    }
+                    const encriptedData1 = await this.encryptData(JSON.stringify(sessionData), values.public_key, keys.privateKey, values.key_id);
+                    const payload2 = {
+                        publicKey: keys?.publicKey,
+                        keyId: encriptedData1?.keyId,
+                        iv: encriptedData1?.iv,
+                        data: encriptedData1?.encryptedData,
+                    }
+                    const gateway = this.getEndpoints().gateway;
+                    const url = `${gateway}/v1/inventory/order-link/${order?.inventoryOrderLink?.gid}/charge`;
+                    const res = await fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'x-enc-public-key': payload2?.publicKey,
+                            'x-enc-key-id': payload2?.keyId,
+                            'x-enc-iv': payload2?.iv,
+                            'Content-Type': 'application/json',
+                            'x-api-key': this.apiKey,
+                        },
+                        body: JSON.stringify({ data: payload2?.data })
+                    });
+                    const resData = await res.json();
+                    return resData;
+                }
+            }
+
+        } catch (error) {
+            console.error("Payment Error:", error);
+            this.events.emit("error", error);
+        }
+    }
+
+    async handleSubmit(e) {
+        e.preventDefault();
+
+        const payButton = this.shadow.getElementById("form").querySelector(".btn");
+        payButton.disabled = true;
+        payButton.textContent = "Processing...";
+
+        const isValid = this.validate();
+        if (!isValid) {
+            payButton.disabled = false;
+            payButton.textContent = `Pay $${(this.amount / 100).toFixed(2)}`;
+            return;
+        }
+
+        try {
+            if (this.frequency === "ONE-TIME" && !this.inventory) {
+                const resData = await this.oneTimePayment();
+                if (resData?.entity?.errorCode === null) {
+                    this.events.emit("success", resData);
+                    this.close();
+                } else {
+                    const errorMsg = resData?.entity?.errorDescription || "Payment failed";
+                    console.error("Payment Error:", errorMsg);
+                    this.events.emit("error", errorMsg);
+                }
+            } else if (this.frequency !== "ONE-TIME" && !this.inventory) {
+                const resData = await this.recurringPayment();
+                if (resData?.entity?.setupSession?.errorCode === null) {
+                    this.events.emit("success", resData);
+                    this.close();
+                } else {
+                    const errorMsg = resData?.entity?.setupSession?.errorDescription || "Payment failed";
+                    console.error("Payment Error:", errorMsg);
+                    this.events.emit("error", errorMsg);
+                }
+            } else if (this.inventory) {
+                const resData = await this.inventoryCharge();
+                if (resData?.responseCode === 200) {
+                    this.events.emit("success", resData);
+                    this.close();
+                } else {
+                    console.error("Payment Error:", resData?.message || 'Payment failed');
+                    this.events.emit("error", resData?.message);
                 }
             }
         } catch (error) {
             console.error("Payment Error:", error);
             this.events.emit("error", error);
-            alert(error.message || "Payment failed");
         } finally {
             payButton.disabled = false;
             payButton.textContent = `Pay $${(this.amount / 100).toFixed(2)}`;
@@ -636,6 +1058,7 @@ export class SwirepayCheckout extends HTMLElement {
     render() {
         const t = this.theme;
         const amountText = (this.amount / 100).toFixed(2);
+        const inventoryAmountText = ((this.splitUp?.netPayable) / 100).toFixed(2);
         this.shadow.innerHTML = `
 <style>
 :host {
@@ -656,26 +1079,44 @@ export class SwirepayCheckout extends HTMLElement {
   background:rgba(0,0,0,0.6);
   justify-content:center;
   align-items:center;
+  z-index:9999;
 }
 
 .modal {
-  width:420px;
+  width: 520px;
+  height: auto;
+  max-height: 650px;
   background:var(--bg);
   color:var(--text);
   border-radius:16px;
-  padding:20px;
+  padding:28px;
   font-family:sans-serif;
 }
 
+.modal-body {
+  overflow-y: auto;
+  flex: 1;
+  height: 530px;
+}
+
+form {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
 input, select {
-  width:100%;
-  padding:10px;
-  margin:6px 0;
-  border:1px solid var(--border);
-  background: white;
-  color: black;
-  border-radius:8px;
-  outline:none;
+  width: 100%;
+  padding: 12px;
+  border: 1px solid var(--border);
+  background: #ffffff;
+  color: #000000;
+  border-radius: 8px;
+  outline: none;
+  height: 44px;
+  font-size: 14px;
+  box-sizing: border-box;
+  margin: 0 !important;
 }
 
 input::placeholder {
@@ -698,7 +1139,7 @@ input::placeholder {
 select {
   width:100%;
   padding:10px;
-  margin:6px 0;
+  margin: 0;
   border:1px solid var(--border);
   border-radius:8px;
 
@@ -714,94 +1155,238 @@ select option {
   color: #000000;
 }
 
-.row { display:flex; gap:10px; }
+.row {
+  display: flex;
+  gap: 16px;
+  align-items: center;
+}
+  .phone-code {
+  flex: 0 0 70px !important;
+}
+
+.row input,
+.row select {
+  flex: 1;
+}
 
-.phone-code { width:70px; }
+input, select {
+  box-sizing: border-box;
+  height: 40px;
+  padding: 10px;
+  font-size: 14px;
+}
 
 .btn {
-  background:var(--primary);
-  color:#fff;
-  padding:12px;
-  border:none;
-  border-radius:10px;
-  cursor:pointer;
-  width:100%;
+  background: var(--primary);
+  color: #fff;
+  padding: 14px;
+  border: none;
+  border-radius: 10px;
+  cursor: pointer;
+  width: 100%;
+  height: 48px;
+  font-size: 15px;
+}
+
+.btn1 {
+  background: var(--primary);
+  color: #fff;
+  padding: 14px;
+  border: none;
+  border-radius: 10px;
+  cursor: pointer;
+  width: 100%;
+  height: 48px;
+  font-size: 15px;
 }
 
 .close {
   float:right;
   cursor:pointer;
 }
+
+h3 {
+  margin-bottom: 16px;
+}
+
+.section {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.section-title {
+  font-size: 14px;
+  font-weight: 600;
+  margin: 0;
+}
+  .error {
+  font-size: 12px;
+  color: #dc2626;
+  margin-top: 0px;
+  margin-bottom: 0px;
+}
+
+.field {
+  position: relative;
+  width: 100%;
+}
+
+.field input,
+.field select {
+  width: 100%;
+  padding: 14px 12px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  font-size: 14px;
+  background: #fff;
+  outline: none;
+}
+.field label {
+  position: absolute;
+  left: 0px;
+  top: 50%;
+  transform: translateY(-50%);
+  padding: 0 4px;
+  color: #6b7280;
+  font-size: 14px;
+  pointer-events: none;
+  transition: 0.2s ease;
+}
+.field input:focus + label,
+.field input:not(:placeholder-shown) + label {
+  top: -8px;
+  font-size: 12px;
+  color: var(--primary);
+}
+.field select {
+  width: 100%;
+  height: 44px;
+  padding: 0 12px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: #fff;
+  color: #000;
+  font-size: 14px;
+  outline: none;
+  appearance: none;
+}
+.input-error {
+  border-color: #dc2626 !important;
+}
+
+.field input.input-error + label {
+  color: #dc2626;
+}
+
+.field label.floating {
+  top: -8px;
+  font-size: 12px;
+  color: var(--primary);
+}
 </style>
 
 <div class="overlay" id="overlay">
   <div class="modal">
+  <div class="modal-header">
     <span class="close" id="close">✕</span>
-
-    <h3>Pay by Bank</h3>
-
+    <h3>Pay By Bank</h3>
+  </div>
+  <div class="modal-body">
     <form id="form">
-      <input id="name" placeholder="Name"/>
-      <input id="email" placeholder="Email"/>
+    <div class="section">
+    <div class="section-title">Customer Details</div>
+      <div class="field">
+    <input id="name" required placeholder=" " />
+    <label>Name *</label>
+  </div>
+      <div class="error" id="error-name"></div>
+      <div class="field">
+    <input id="email" required placeholder=" " />
+    <label>Email *</label>
+  </div>
+      <div class="error" id="error-email"></div>
 
       <div class="row">
-        <input class="phone-code" id="phone-code" value="+1"/>
-        <input id="phone" placeholder="Phone"/>
+        <div class="field phone-code">
+      <input id="phone-code" placeholder=" " />
+      <label>Code</label>
+    </div>
+        <div class="field">
+      <input id="phone" required placeholder=" " />
+      <label>Phone *</label>
+    </div>
       </div>
-
-      <input id="account-name" placeholder="Account Holder Name"/>
-<input id="account-number" placeholder="Account Number"/>
-<input id="routing-number" placeholder="Routing Number"/>
-
-<select id="account-type">
-  <option value="">Account Type</option>
-  <option value="CURRENT">Current</option>
-  <option value="SAVINGS">Savings</option>
-</select>
-
-<input id="bank-name" placeholder="Bank Name"/>
-
+      <div class="error" id="error-phone"></div>
+      </div>
+      <div class="section">
+      <div class="section-title">Bank Details</div>
+      <button id="link-bank" class="btn1">Add Bank Account</button>
+    <div id="bank-status"></div>
+    <div class="error" id="error-bank"></div>
+<div class="field">
 <select id="business-type">
   <option value="">Business Type</option>
   <option value="INDIVIDUAL">Individual</option>
   <option value="BUSINESS">Business</option>
 </select>
+<label class="floating">Business Type *</label>
+</div>
+<div class="error" id="error-business-type"></div>
+</div>
 
-      <input id="street" placeholder="Street Address"/>
-      <input id="city" placeholder="City"/>
-
-      <!-- STATE FIRST -->
-      <select id="state"></select>
-
-      <!-- COUNTRY AFTER -->
-      <select id="country">
-  ${COUNTRIES_LIST.map(c =>
-            `<option value="${c.code}" ${c.code === "US" ? "selected" : ""}>
-      ${c.name}
-    </option>`
-        ).join("")}
-</select>
-
-      <input id="zip" placeholder="ZIP Code"/>
-
-      <button class="btn">Pay $${amountText}</button>
+      ${this.getAddressFields()}
+      <button class="btn">Pay $${this.inventory ? inventoryAmountText : amountText}</button>
+      </div> 
     </form>
   </div>
 </div>
 `;
 
         const $ = id => this.shadow.getElementById(id);
+        if (this.customer) {
+            if (this.customer.name) $("name").value = this.customer.name;
+            if (this.customer.email) $("email").value = this.customer.email;
+
+            if (this.customer.phone) {
+                let phone = this.customer.phone;
+                let code = "";
+                let number = phone;
+
+                if (phone.startsWith("+")) {
+                    if (phone.startsWith("+1")) {
+                        code = "+1";
+                        number = phone.slice(2);
+                    } else if (phone.startsWith("+91")) {
+                        code = "+91";
+                        number = phone.slice(3);
+                    }
+                }
+
+                if ($("phone-code")) $("phone-code").value = code;
+                if ($("phone")) $("phone").value = number;
+            }
+        }
+        this.shadow.getElementById("link-bank").onclick = async () => {
+            if (!this.plaidHandler) await this.initPlaid();
+            this.plaidHandler.open();
+        };
 
         $("close").onclick = () => this.close();
         $("form").onsubmit = e => this.handleSubmit(e);
 
-        $("country").onchange = () => this.handleCountryChange();
-
         const countryEl = $("country");
-        countryEl.value = "US";
-        this.handleCountryChange();
-        $("account-number").oninput = e => e.target.value = this.formatAccountNumber(e.target.value);
-        $("routing-number").oninput = e => e.target.value = this.formatRouting(e.target.value);
+        if (countryEl) {
+            countryEl.onchange = () => this.handleCountryChange();
+            if (!this.customer?.countryCode) {
+                countryEl.value = "US";
+            }
+            this.handleCountryChange();
+        }
+        const phoneCodeEl = $("phone-code");
+        if (phoneCodeEl) {
+            phoneCodeEl.dataset.auto = "true";
+        }
         $("phone").oninput = e => e.target.value = this.formatPhone(e.target.value);
     }
 }