@branta-ops/branta 2.0.0 → 3.0.1

package/dist/helpers/aes.d.ts

@@ -5,7 +5,7 @@ declare class AesEncryption {
      * @param secret - The secret key (will be hashed with SHA-256)
      * @returns Base64-encoded encrypted data (iv + ciphertext + tag)
      */
-    static encrypt(value: string, secret: string): Promise<string>;
+    static encrypt(value: string, secret: string, deterministicNonce?: boolean): Promise<string>;
     /**
      * Decrypts an encrypted string using AES-GCM with a secret key
      * @param encryptedValue - Base64-encoded encrypted data

package/dist/helpers/aes.js

@@ -5,12 +5,20 @@ class AesEncryption {
      * @param secret - The secret key (will be hashed with SHA-256)
      * @returns Base64-encoded encrypted data (iv + ciphertext + tag)
      */
-    static async encrypt(value, secret) {
+    static async encrypt(value, secret, deterministicNonce = false) {
         try {
             const encoder = new TextEncoder();
             const secretData = encoder.encode(secret);
             const keyData = await crypto.subtle.digest('SHA-256', secretData);
-            const iv = crypto.getRandomValues(new Uint8Array(12));
+            let iv;
+            if (deterministicNonce) {
+                const hmacKey = await crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+                const hmacBuffer = await crypto.subtle.sign('HMAC', hmacKey, encoder.encode(value));
+                iv = new Uint8Array(hmacBuffer).slice(0, 12);
+            }
+            else {
+                iv = crypto.getRandomValues(new Uint8Array(12));
+            }
             const key = await crypto.subtle.importKey('raw', keyData, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
             const plaintext = encoder.encode(value);
             const encrypted = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: iv, tagLength: 128 }, key, plaintext);

package/dist/helpers/hashZk.d.ts

@@ -0,0 +1,3 @@
+import { DestinationType } from '../v2/types.js';
+export declare function getHashZkType(value: string): DestinationType | null;
+export declare function toNormalizedHash(value: string): Promise<string>;

package/dist/helpers/hashZk.js

@@ -0,0 +1,13 @@
+export function getHashZkType(value) {
+    const lower = value.toLowerCase();
+    if (lower.startsWith('lnbc') || lower.startsWith('lntb') || lower.startsWith('lnbcrt'))
+        return 'bolt11';
+    if (lower.startsWith('ark1'))
+        return 'ark_address';
+    return null;
+}
+export async function toNormalizedHash(value) {
+    const normalized = value.toLowerCase();
+    const hashBuffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(normalized));
+    return Array.from(new Uint8Array(hashBuffer)).map(b => b.toString(16).padStart(2, '0')).join('');
+}

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-import V2BrantaClient from "./v2/client.js";
-import { Payment, Destination, DestinationType } from "./v2/client.js";
-import BrantaClientOptions from "./classes/brantaClientOptions.js";
-import BrantaServerBaseUrl from "./classes/brantaServerBaseUrl.js";
-export { V2BrantaClient, BrantaClientOptions, BrantaServerBaseUrl, Payment, Destination, DestinationType };
-export default V2BrantaClient;
+export { default as BrantaClientOptions } from "./classes/brantaClientOptions.js";
+export { default as BrantaServerBaseUrl } from "./classes/brantaServerBaseUrl.js";
+export type { PrivacyMode } from "./classes/brantaClientOptions.js";

package/dist/index.js

@@ -1,4 +1 @@
-import V2BrantaClient from "./v2/client.js";
-import BrantaServerBaseUrl from "./classes/brantaServerBaseUrl.js";
-export { V2BrantaClient, BrantaServerBaseUrl };
-export default V2BrantaClient;
+export { default as BrantaServerBaseUrl } from "./classes/brantaServerBaseUrl.js";

package/dist/v2/client.d.ts

@@ -1,47 +1,14 @@
 import BrantaClientOptions from "../classes/brantaClientOptions.js";
-export type DestinationType = 'bitcoin_address' | 'ln_address' | 'bolt11' | 'bolt12' | 'ln_url' | 'tether_address' | 'ark_address';
-export interface Destination {
-    value: string;
-    type?: DestinationType;
-    zk?: boolean;
-}
-export interface Payment {
-    destinations: Destination[];
-    ttl?: number;
-    description?: string;
-    metadata?: Record<string, string>;
-    verifyUrl?: string;
-    platform?: string;
-    platformLogoUrl?: string;
-    platformLogoLightUrl?: string;
-}
-interface PaymentResponse extends Payment {
-    createdAt: Date;
-    platform: string;
-}
-interface PaymentResult {
-    payment: PaymentResponse;
-    verifyLink: string;
-}
-interface ZKPaymentResult extends PaymentResult {
-    secret: string;
-}
-export declare class V2BrantaClient {
+import { IBrantaClient, Payment } from "./types.js";
+export declare class BrantaClient implements IBrantaClient {
     private _defaultOptions;
     constructor(brantaClientOptions: BrantaClientOptions);
     getPayments(address: string, options?: BrantaClientOptions | null): Promise<Payment[]>;
-    private _fetchPayments;
-    getZKPayment(address: string, secret: string, options?: BrantaClientOptions | null): Promise<Payment[]>;
-    addPayment(payment: Payment, options?: BrantaClientOptions | null): Promise<PaymentResult>;
-    addZKPayment(payment: Payment, options?: BrantaClientOptions | null): Promise<ZKPaymentResult>;
-    getPaymentsByQRCode(qrText: string, options?: BrantaClientOptions | null): Promise<Payment[]>;
-    private _getPlainPayments;
+    postPayment(payment: Payment, options?: BrantaClientOptions | null): Promise<Payment>;
     isApiKeyValid(options?: BrantaClientOptions | null): Promise<boolean>;
-    private _buildVerifyUrl;
     private _resolveBaseUrl;
-    private _normalizeAddress;
     private _createClient;
     private _setApiKey;
     private _setHmacHeaders;
 }
-export default V2BrantaClient;
+export default BrantaClient;

package/dist/v2/client.js

@@ -1,33 +1,26 @@
-import AesEncryption from "../helpers/aes.js";
 import BrantaPaymentException from "../classes/brantaPaymentException.js";
-export class V2BrantaClient {
+export class BrantaClient {
     constructor(brantaClientOptions) {
         this._defaultOptions = brantaClientOptions;
     }
     async getPayments(address, options = null) {
-        const privacy = options?.privacy ?? this._defaultOptions?.privacy;
-        if (privacy === 'strict') {
-            throw new BrantaPaymentException("privacy is set to 'strict': plain on-chain address lookups are not permitted");
-        }
-        return this._fetchPayments(address, options);
-    }
-    async _fetchPayments(address, options = null) {
         const httpClient = this._createClient(options);
         const response = await httpClient.get(`/v2/payments/${encodeURIComponent(address)}`);
         if (!response.ok || response.headers.get("content-length") === "0") {
             return [];
         }
         const raw = await response.json();
-        const data = raw.map(({ platform_logo_url: platformLogoUrl, platform_logo_light_url: platformLogoLightUrl, verify_url: verifyUrl, ...rest }) => ({
+        const data = raw.map(({ platform_logo_url: platformLogoUrl, platform_logo_light_url: platformLogoLightUrl, verify_url: verifyUrl, created_at: createdAt, destinations: rawDests, ...rest }) => ({
             ...rest,
             platformLogoUrl,
             platformLogoLightUrl,
             verifyUrl,
+            createdAt,
+            destinations: (rawDests ?? []).map(({ zk_id: zkId, primary: isPrimary, type, ...d }) => ({ ...d, type: type, zkId, isPrimary })),
         }));
         const baseUrl = this._resolveBaseUrl(options);
         const baseOrigin = new URL(baseUrl).origin;
         for (const payment of data) {
-            payment.verifyUrl = this._buildVerifyUrl(baseUrl, address);
             if (payment.platformLogoUrl) {
                 let valid = false;
                 try {
@@ -49,22 +42,7 @@ export class V2BrantaClient {
         }
         return data;
     }
-    async getZKPayment(address, secret, options = null) {
-        const payments = await this._fetchPayments(address, options);
-        for (const payment of payments) {
-            for (const destination of payment?.destinations || []) {
-                if (destination.zk === false)
-                    continue;
-                destination.value = await AesEncryption.decrypt(destination.value, secret);
-            }
-        }
-        const baseUrl = this._resolveBaseUrl(options);
-        for (const payment of payments) {
-            payment.verifyUrl = this._buildVerifyUrl(baseUrl, address, secret);
-        }
-        return payments;
-    }
-    async addPayment(payment, options = null) {
+    async postPayment(payment, options = null) {
         const httpClient = this._createClient(options);
         this._setApiKey(httpClient, options);
         await this._setHmacHeaders(httpClient, "POST", "/v2/payments", payment, options);
@@ -73,69 +51,7 @@ export class V2BrantaClient {
             throw new BrantaPaymentException(response.status.toString());
         }
         const responseBody = await response.text();
-        const paymentResponse = JSON.parse(responseBody);
-        paymentResponse.verifyUrl = this._buildVerifyUrl(httpClient.baseURL, payment.destinations[0].value);
-        const verifyLink = httpClient.baseURL + "/v2/verify/" + encodeURIComponent(payment.destinations[0].value);
-        return { payment: paymentResponse, verifyLink };
-    }
-    async addZKPayment(payment, options = null) {
-        const secret = crypto.randomUUID();
-        for (const destination of payment?.destinations || []) {
-            if (destination.zk === false)
-                continue;
-            destination.value = await AesEncryption.encrypt(destination.value, secret);
-        }
-        const responsePayment = (await this.addPayment(payment, options));
-        responsePayment.secret = secret;
-        responsePayment.verifyLink = responsePayment.verifyLink.replace('verify', 'zk-verify') + "#secret=" + secret;
-        responsePayment.payment.verifyUrl = this._buildVerifyUrl(this._resolveBaseUrl(options), payment.destinations[0].value, secret);
-        return responsePayment;
-    }
-    async getPaymentsByQRCode(qrText, options = null) {
-        const text = qrText.trim();
-        let url = null;
-        try {
-            url = new URL(text);
-        }
-        catch { /* not a URL */ }
-        if (!url)
-            return this._getPlainPayments(this._normalizeAddress(text), options);
-        const rawParams = new URLSearchParams(url.search.replace(/\+/g, '%2B'));
-        const brantaId = rawParams.get('branta_id');
-        const brantaSecret = rawParams.get('branta_secret');
-        if (brantaId && brantaSecret)
-            return this.getZKPayment(brantaId, brantaSecret, options);
-        if (url.protocol === 'bitcoin:') {
-            return this._getPlainPayments(this._normalizeAddress(url.pathname), options);
-        }
-        if (url.protocol === 'http:' || url.protocol === 'https:') {
-            const baseUrl = this._resolveBaseUrl(options);
-            if (!baseUrl || new URL(baseUrl).origin !== url.origin) {
-                return this._getPlainPayments(this._normalizeAddress(text), options);
-            }
-            const segments = url.pathname.split('/').filter(Boolean).map(decodeURIComponent);
-            const [version, type, id] = segments;
-            if (version === 'v2' && id) {
-                if (type === 'verify')
-                    return this._getPlainPayments(id, options);
-                if (type === 'zk-verify') {
-                    const secret = new URLSearchParams(url.hash.slice(1)).get('secret');
-                    if (secret)
-                        return this.getZKPayment(id, secret, options);
-                    return this._getPlainPayments(id, options);
-                }
-            }
-            const lastSegment = segments.at(-1);
-            if (lastSegment)
-                return this._getPlainPayments(lastSegment, options);
-        }
-        return this._getPlainPayments(this._normalizeAddress(text), options);
-    }
-    _getPlainPayments(address, options) {
-        const privacy = options?.privacy ?? this._defaultOptions?.privacy;
-        if (privacy === 'strict')
-            return Promise.resolve([]);
-        return this.getPayments(address, options);
+        return JSON.parse(responseBody);
     }
     async isApiKeyValid(options = null) {
         const httpClient = this._createClient(options);
@@ -143,30 +59,10 @@ export class V2BrantaClient {
         const response = await httpClient.get("/v2/api-keys/health-check");
         return response.ok;
     }
-    _buildVerifyUrl(baseUrl, address, secret) {
-        const encoded = encodeURIComponent(address);
-        if (secret) {
-            return `${baseUrl}/v2/zk-verify/${encoded}#secret=${secret}`;
-        }
-        return `${baseUrl}/v2/verify/${encoded}`;
-    }
     _resolveBaseUrl(options) {
         const baseUrl = options?.baseUrl ?? this._defaultOptions?.baseUrl;
         return typeof baseUrl === 'string' ? baseUrl : baseUrl?.url ?? '';
     }
-    _normalizeAddress(text) {
-        const lower = text.toLowerCase();
-        if (lower.startsWith('lightning:'))
-            return lower.slice('lightning:'.length);
-        if (lower.startsWith('bitcoin:')) {
-            const addr = text.slice('bitcoin:'.length);
-            const addrLower = addr.toLowerCase();
-            return addrLower.startsWith('bc1q') || addrLower.startsWith('bcrt') ? addrLower : addr;
-        }
-        if (lower.startsWith('lnbc') || lower.startsWith('bc1q'))
-            return lower;
-        return text;
-    }
     _createClient(options) {
         const baseUrl = options?.baseUrl ?? this._defaultOptions?.baseUrl;
         const timeout = options?.timeout ?? this._defaultOptions?.timeout ?? 10000;
@@ -262,4 +158,4 @@ export class V2BrantaClient {
         };
     }
 }
-export default V2BrantaClient;
+export default BrantaClient;

package/dist/v2/index.d.ts

@@ -0,0 +1,3 @@
+export { BrantaClient } from "./client.js";
+export { BrantaService } from "./service.js";
+export type { IBrantaClient, IBrantaService, Payment, PaymentResult, ZKPaymentResult, Destination, DestinationType } from "./types.js";

package/dist/v2/index.js

@@ -0,0 +1,2 @@
+export { BrantaClient } from "./client.js";
+export { BrantaService } from "./service.js";

package/dist/v2/service.d.ts

@@ -0,0 +1,19 @@
+import BrantaClientOptions from "../classes/brantaClientOptions.js";
+import { IBrantaClient, IBrantaService, Payment, ZKPaymentResult } from "./types.js";
+export declare class BrantaService implements IBrantaService {
+    private readonly _client;
+    private readonly _defaultOptions;
+    constructor(defaultOptions: BrantaClientOptions, client?: IBrantaClient);
+    getPayments(address: string, destinationEncryptionKey?: string | null, options?: BrantaClientOptions | null): Promise<Payment[]>;
+    addPayment(payment: Payment, options?: BrantaClientOptions | null): Promise<ZKPaymentResult>;
+    getPaymentsByQRCode(qrText: string, options?: BrantaClientOptions | null): Promise<Payment[]>;
+    isApiKeyValid(options?: BrantaClientOptions | null): Promise<boolean>;
+    private _getPaymentsForZk;
+    private _decryptDestinations;
+    private _decryptHashZkDestinations;
+    private _buildVerifyUrl;
+    private _getPlainPayments;
+    private _resolveBaseUrl;
+    private _normalizeAddress;
+}
+export default BrantaService;

package/dist/v2/service.js

@@ -0,0 +1,211 @@
+import AesEncryption from "../helpers/aes.js";
+import { getHashZkType, toNormalizedHash } from "../helpers/hashZk.js";
+import BrantaPaymentException from "../classes/brantaPaymentException.js";
+import { BrantaClient } from "./client.js";
+export class BrantaService {
+    constructor(defaultOptions, client) {
+        this._defaultOptions = defaultOptions;
+        this._client = client ?? new BrantaClient(defaultOptions);
+    }
+    async getPayments(address, destinationEncryptionKey = null, options = null) {
+        const hashZkType = getHashZkType(address);
+        if (!hashZkType && !destinationEncryptionKey) {
+            const privacy = options?.privacy ?? this._defaultOptions?.privacy;
+            if (privacy === 'strict') {
+                throw new BrantaPaymentException("privacy is set to 'strict': plain on-chain address lookups are not permitted");
+            }
+        }
+        let lookupValue = address;
+        if (hashZkType) {
+            const hash = await toNormalizedHash(address);
+            lookupValue = await AesEncryption.encrypt(address, hash, true);
+        }
+        let payments = await this._client.getPayments(lookupValue, options);
+        if (payments.length === 0 && hashZkType) {
+            const privacy = options?.privacy ?? this._defaultOptions?.privacy;
+            if (privacy !== 'strict') {
+                lookupValue = address;
+                payments = await this._client.getPayments(address, options);
+            }
+        }
+        const baseUrl = this._resolveBaseUrl(options);
+        for (const payment of payments) {
+            const keys = await this._decryptDestinations(payment.destinations, address, destinationEncryptionKey, hashZkType);
+            payment.verifyUrl = this._buildVerifyUrl(baseUrl, lookupValue, keys);
+        }
+        return payments;
+    }
+    async addPayment(payment, options = null) {
+        const privacy = options?.privacy ?? this._defaultOptions?.privacy;
+        if (privacy === 'strict' && payment.destinations.some(d => !d.zk)) {
+            throw new BrantaPaymentException("privacy is set to 'strict': all destinations must have zk enabled");
+        }
+        const secret = crypto.randomUUID();
+        const encryptedToKey = new Map();
+        for (const dest of payment.destinations) {
+            if (!dest.zk)
+                continue;
+            if (dest.type === 'bitcoin_address') {
+                dest.value = await AesEncryption.encrypt(dest.value, secret, false);
+                encryptedToKey.set(dest.value, secret);
+            }
+            else {
+                const hashZkType = getHashZkType(dest.value);
+                if (!hashZkType) {
+                    throw new BrantaPaymentException(`destination type '${dest.type}' does not support ZK`);
+                }
+                const hash = await toNormalizedHash(dest.value);
+                dest.value = await AesEncryption.encrypt(dest.value, hash, true);
+                encryptedToKey.set(dest.value, hash);
+            }
+        }
+        const responsePayment = await this._client.postPayment(payment, options);
+        const keys = new Map();
+        for (const dest of responsePayment.destinations) {
+            if (dest.zkId && encryptedToKey.has(dest.value)) {
+                keys.set(dest.zkId, encryptedToKey.get(dest.value));
+            }
+        }
+        const baseUrl = this._resolveBaseUrl(options);
+        const primaryValue = payment.destinations[0]?.value ?? '';
+        responsePayment.verifyUrl = this._buildVerifyUrl(baseUrl, primaryValue, keys);
+        const verifyLink = responsePayment.verifyUrl;
+        return { payment: responsePayment, verifyLink, secret };
+    }
+    async getPaymentsByQRCode(qrText, options = null) {
+        const text = qrText.trim();
+        let url = null;
+        try {
+            url = new URL(text);
+        }
+        catch { /* not a URL */ }
+        if (!url)
+            return this._getPlainPayments(this._normalizeAddress(text), options);
+        if (url.protocol === 'bitcoin:' || url.protocol === 'lightning:') {
+            const brantaId = url.searchParams.get('branta_id');
+            const brantaSecret = url.searchParams.get('branta_secret');
+            if (brantaId && brantaSecret) {
+                const additionalValues = [];
+                const lightning = url.searchParams.get('lightning');
+                const bolt12 = url.searchParams.get('bolt12');
+                const ark = url.searchParams.get('ark');
+                if (lightning)
+                    additionalValues.push(lightning);
+                if (bolt12)
+                    additionalValues.push(bolt12);
+                if (ark)
+                    additionalValues.push(ark);
+                return this._getPaymentsForZk(brantaId, brantaSecret, additionalValues, options);
+            }
+            return this._getPlainPayments(this._normalizeAddress(url.pathname), options);
+        }
+        const brantaId = url.searchParams.get('branta_id');
+        const brantaSecret = url.searchParams.get('branta_secret');
+        if (brantaId && brantaSecret)
+            return this.getPayments(brantaId, brantaSecret, options);
+        if (url.protocol === 'http:' || url.protocol === 'https:') {
+            const baseUrl = this._resolveBaseUrl(options);
+            if (!baseUrl || new URL(baseUrl).origin !== url.origin) {
+                return this._getPlainPayments(this._normalizeAddress(text), options);
+            }
+            const segments = url.pathname.split('/').filter(Boolean).map(decodeURIComponent);
+            const [version, type, id] = segments;
+            if (version === 'v2' && id) {
+                if (type === 'verify')
+                    return this._getPlainPayments(id, options);
+                if (type === 'zk-verify') {
+                    const secret = new URLSearchParams(url.hash.slice(1)).get('secret');
+                    if (secret)
+                        return this.getPayments(id, secret, options);
+                    return this._getPlainPayments(id, options);
+                }
+            }
+            const lastSegment = segments.at(-1);
+            if (lastSegment)
+                return this._getPlainPayments(lastSegment, options);
+        }
+        return this._getPlainPayments(this._normalizeAddress(text), options);
+    }
+    async isApiKeyValid(options = null) {
+        return this._client.isApiKeyValid(options);
+    }
+    async _getPaymentsForZk(lookupValue, encryptionKey, additionalHashValues, options) {
+        const payments = await this._client.getPayments(lookupValue, options);
+        const baseUrl = this._resolveBaseUrl(options);
+        for (const payment of payments) {
+            const keys = await this._decryptDestinations(payment.destinations, lookupValue, encryptionKey, null);
+            for (const value of additionalHashValues) {
+                await this._decryptHashZkDestinations(payment.destinations, value, keys);
+            }
+            payment.verifyUrl = this._buildVerifyUrl(baseUrl, lookupValue, keys);
+        }
+        return payments;
+    }
+    async _decryptDestinations(destinations, destinationValue, encryptionKey, hashZkType) {
+        const keys = new Map();
+        for (const dest of destinations) {
+            if (!dest.zk)
+                continue;
+            if (dest.type === 'bitcoin_address') {
+                if (!encryptionKey)
+                    throw new BrantaPaymentException("Payment is ZK but no destination encryption key was provided.");
+                dest.value = await AesEncryption.decrypt(dest.value, encryptionKey);
+                if (dest.zkId)
+                    keys.set(dest.zkId, encryptionKey);
+            }
+            else if (hashZkType && dest.type === hashZkType) {
+                const hash = await toNormalizedHash(destinationValue);
+                dest.value = await AesEncryption.decrypt(dest.value, hash);
+                if (dest.zkId)
+                    keys.set(dest.zkId, hash);
+            }
+        }
+        return keys;
+    }
+    async _decryptHashZkDestinations(destinations, plainValue, keys) {
+        const hashZkType = getHashZkType(plainValue);
+        if (!hashZkType)
+            return;
+        const hash = await toNormalizedHash(plainValue);
+        for (const dest of destinations) {
+            if (!dest.zk || dest.type !== hashZkType)
+                continue;
+            dest.value = await AesEncryption.decrypt(dest.value, hash);
+            if (dest.zkId)
+                keys.set(dest.zkId, hash);
+        }
+    }
+    _buildVerifyUrl(baseUrl, lookupValue, keys) {
+        const encoded = encodeURIComponent(lookupValue);
+        let url = `${baseUrl}/v2/verify/${encoded}`;
+        if (keys.size > 0) {
+            const fragment = Array.from(keys.entries()).map(([id, key]) => `k-${id}=${key}`).join('&');
+            url += `#${fragment}`;
+        }
+        return url;
+    }
+    _getPlainPayments(address, options) {
+        const privacy = options?.privacy ?? this._defaultOptions?.privacy;
+        if (privacy === 'strict' && !getHashZkType(address))
+            return Promise.resolve([]);
+        return this.getPayments(address, null, options);
+    }
+    _resolveBaseUrl(options) {
+        const baseUrl = options?.baseUrl ?? this._defaultOptions?.baseUrl;
+        return typeof baseUrl === 'string' ? baseUrl : baseUrl?.url ?? '';
+    }
+    _normalizeAddress(text) {
+        const lower = text.toLowerCase();
+        if (lower.startsWith('lightning:'))
+            return lower.slice('lightning:'.length);
+        if (lower.startsWith('bitcoin:')) {
+            const addr = text.slice('bitcoin:'.length);
+            const addrLower = addr.toLowerCase();
+            return addrLower.startsWith('bc1q') || addrLower.startsWith('bcrt') ? addrLower : addr;
+        }
+        if (lower.startsWith('lnbc') || lower.startsWith('lntb') || lower.startsWith('lnbcrt') || lower.startsWith('bc1q'))
+            return lower;
+        return text;
+    }
+}
+export default BrantaService;

package/dist/v2/types.d.ts

@@ -0,0 +1,38 @@
+import BrantaClientOptions from "../classes/brantaClientOptions.js";
+export type DestinationType = 'bitcoin_address' | 'ln_address' | 'bolt11' | 'bolt12' | 'ln_url' | 'tether_address' | 'ark_address';
+export interface Destination {
+    value: string;
+    type?: DestinationType;
+    zk?: boolean;
+    zkId?: string;
+    isPrimary?: boolean;
+}
+export interface Payment {
+    destinations: Destination[];
+    ttl?: number;
+    description?: string;
+    metadata?: Record<string, string>;
+    verifyUrl?: string;
+    platform?: string;
+    platformLogoUrl?: string;
+    platformLogoLightUrl?: string;
+    createdAt?: string;
+}
+export interface PaymentResult {
+    payment: Payment;
+    verifyLink: string;
+}
+export interface ZKPaymentResult extends PaymentResult {
+    secret: string;
+}
+export interface IBrantaClient {
+    getPayments(address: string, options?: BrantaClientOptions | null): Promise<Payment[]>;
+    postPayment(payment: Payment, options?: BrantaClientOptions | null): Promise<Payment>;
+    isApiKeyValid(options?: BrantaClientOptions | null): Promise<boolean>;
+}
+export interface IBrantaService {
+    getPayments(address: string, destinationEncryptionKey?: string | null, options?: BrantaClientOptions | null): Promise<Payment[]>;
+    addPayment(payment: Payment, options?: BrantaClientOptions | null): Promise<ZKPaymentResult>;
+    getPaymentsByQRCode(qrText: string, options?: BrantaClientOptions | null): Promise<Payment[]>;
+    isApiKeyValid(options?: BrantaClientOptions | null): Promise<boolean>;
+}

package/dist/v2/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@branta-ops/branta",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "description": "A JavaScript SDK for the Branta API",
   "homepage": "https://github.com/BrantaOps/branta-js#readme",
   "bugs": {
@@ -15,6 +15,16 @@
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./v2": {
+      "import": "./dist/v2/index.js",
+      "types": "./dist/v2/index.d.ts"
+    }
+  },
   "files": [
     "dist"
   ],