velirapay 0.1.0 → 0.2.0

package/dist/esm/services/account.js

@@ -1,5 +1,5 @@
 import { Account } from '../resources/account.js';
-import { data, meta, Service } from './service.js';
+import { data, meta, Service, withDecimalAmounts } from './service.js';
 /** The /v1/account and /v1/payment-settings endpoints. */
 export class AccountService extends Service {
     /** Retrieve the account the API key belongs to, with the coins it accepts in the key's mode. */
@@ -12,7 +12,7 @@ export class AccountService extends Service {
     }
     /** Change the default currency, the payment tolerances, the checkout language or invoice reminders. Needs payment_settings:write. */
     async updatePaymentSettings(params, options) {
-        return account(await this.respond('PATCH', '/v1/payment-settings', params, options));
+        return account(await this.respond('PATCH', '/v1/payment-settings', withDecimalAmounts(params, 'underpayment_tolerance', 'overpayment_threshold'), options));
     }
 }
 /** Read the account and its meta from an answer. */

package/dist/esm/services/api-keys.d.ts

@@ -8,7 +8,13 @@ export declare class ApiKeyService extends Service {
     list(params?: PageParams): Promise<Page<ApiKey>>;
     /** Iterate over every active key, newest first, fetching pages as they are reached. */
     iterator(params?: Omit<PageParams, 'page'>): AsyncGenerator<ApiKey, void, undefined>;
-    /** Create a key in the API key's mode. Its key property holds the key itself, shown this once; leaving permissions out gives full access. */
+    /**
+     * Create a key in the API key's mode. Its key property holds the key itself, shown this once; leaving permissions out gives full access.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the key was made, but cannot be shown again. Find it with list() by its name and createdAt, revoke() it,
+     * and create another with a fresh idempotency key.
+     */
     create(params: ApiKeyCreateParams, options?: RequestOptions): Promise<ApiKey>;
     /** Change a key's name, permissions or allowed_ips, only those given; null permissions gives full access and null allowed_ips anywhere. */
     update(id: string, params: ApiKeyUpdateParams, options?: RequestOptions): Promise<ApiKey>;

package/dist/esm/services/api-keys.js

@@ -10,7 +10,13 @@ export class ApiKeyService extends Service {
     async *iterator(params = {}) {
         yield* (await this.list(params)).autoPagingIterator();
     }
-    /** Create a key in the API key's mode. Its key property holds the key itself, shown this once; leaving permissions out gives full access. */
+    /**
+     * Create a key in the API key's mode. Its key property holds the key itself, shown this once; leaving permissions out gives full access.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the key was made, but cannot be shown again. Find it with list() by its name and createdAt, revoke() it,
+     * and create another with a fresh idempotency key.
+     */
     async create(params, options) {
         return new ApiKey(await this.request('POST', '/v1/api-keys', params, options));
     }

package/dist/esm/services/assets.d.ts

@@ -1,9 +1,8 @@
-import type { Page } from '../page.ts';
+import { AssetPage } from '../page.ts';
 import type { AssetListParams } from '../params.ts';
-import { SupportedAsset } from '../resources/supported-asset.ts';
 import { Service } from './service.ts';
 /** The /v1/assets endpoint. */
 export declare class AssetService extends Service {
-    /** List the coins that can be paid in the API key's mode, with the lowest price each can be charged at, in one page. */
-    list(params?: AssetListParams): Promise<Page<SupportedAsset>>;
+    /** List the coins that can be paid in the API key's mode, with the lowest price each can be charged at, in one page that also gives the currencies prices can be asked in. */
+    list(params?: AssetListParams): Promise<AssetPage>;
 }

package/dist/esm/services/assets.js

@@ -1,9 +1,10 @@
+import { AssetPage } from '../page.js';
 import { SupportedAsset } from '../resources/supported-asset.js';
 import { Service } from './service.js';
 /** The /v1/assets endpoint. */
 export class AssetService extends Service {
-    /** List the coins that can be paid in the API key's mode, with the lowest price each can be charged at, in one page. */
+    /** List the coins that can be paid in the API key's mode, with the lowest price each can be charged at, in one page that also gives the currencies prices can be asked in. */
     async list(params = {}) {
-        return this.page('/v1/assets', params, (asset) => new SupportedAsset(asset));
+        return this.page('/v1/assets', params, (asset) => new SupportedAsset(asset), AssetPage);
     }
 }

package/dist/esm/services/charges.d.ts

@@ -1,25 +1,25 @@
 import type { Page } from '../page.ts';
 import type { ChargeCreateParams, ChargeListParams, RefundParams, RequestOptions, SimulateParams } from '../params.ts';
-import { Charge } from '../resources/charge.ts';
+import { type ApiCharge } from '../resources/charge.ts';
 import { Service } from './service.ts';
 /** The /v1/charges endpoints. */
 export declare class ChargeService extends Service {
     /** Charge a customer: create a charge with what you already know about them, and send them to its checkoutUrl. */
-    create(params: ChargeCreateParams, options?: RequestOptions): Promise<Charge>;
+    create(params: ChargeCreateParams, options?: RequestOptions): Promise<ApiCharge>;
     /** Retrieve a charge by its id. */
-    retrieve(id: string): Promise<Charge>;
+    retrieve(id: string): Promise<ApiCharge>;
     /** List charges, newest first. */
-    list(params?: ChargeListParams): Promise<Page<Charge>>;
+    list(params?: ChargeListParams): Promise<Page<ApiCharge>>;
     /** Iterate over every charge, newest first, fetching pages as they are reached. */
-    iterator(params?: Omit<ChargeListParams, 'page'>): AsyncGenerator<Charge, void, undefined>;
+    iterator(params?: Omit<ChargeListParams, 'page'>): AsyncGenerator<ApiCharge, void, undefined>;
     /** Cancel a pending charge that no transfer has been seen for, so it can no longer be paid. */
-    cancel(id: string, options?: RequestOptions): Promise<Charge>;
+    cancel(id: string, options?: RequestOptions): Promise<ApiCharge>;
     /** Record a refund you sent the customer from your own wallet. An underpaid charge or a late payment is accepted first, and the network surcharge is never refundable. */
-    recordRefund(id: string, params: RefundParams, options?: RequestOptions): Promise<Charge>;
+    recordRefund(id: string, params: RefundParams, options?: RequestOptions): Promise<ApiCharge>;
     /** Email the customer the payment page of a pending charge. */
-    send(id: string, options?: RequestOptions): Promise<Charge>;
+    send(id: string, options?: RequestOptions): Promise<ApiCharge>;
     /** Accept an underpaid charge, or a late payment on an expired or canceled one, as paid for what arrived and confirmed. */
-    accept(id: string, options?: RequestOptions): Promise<Charge>;
+    accept(id: string, options?: RequestOptions): Promise<ApiCharge>;
     /** Pay a test-mode charge without coins, in full or by a chosen amount in the charge's coin. */
-    simulate(id: string, params?: SimulateParams, options?: RequestOptions): Promise<Charge>;
+    simulate(id: string, params?: SimulateParams, options?: RequestOptions): Promise<ApiCharge>;
 }

package/dist/esm/services/charges.js

@@ -1,18 +1,18 @@
 import { Charge } from '../resources/charge.js';
-import { path, Service } from './service.js';
+import { path, Service, withDecimalAmounts } from './service.js';
 /** The /v1/charges endpoints. */
 export class ChargeService extends Service {
     /** Charge a customer: create a charge with what you already know about them, and send them to its checkoutUrl. */
     async create(params, options) {
-        return new Charge(await this.request('POST', '/v1/charges', params, options));
+        return apiCharge(await this.request('POST', '/v1/charges', withDecimalAmounts(params, 'amount'), options));
     }
     /** Retrieve a charge by its id. */
     async retrieve(id) {
-        return new Charge(await this.request('GET', path('/v1/charges/%s', id)));
+        return apiCharge(await this.request('GET', path('/v1/charges/%s', id)));
     }
     /** List charges, newest first. */
     async list(params = {}) {
-        return this.page('/v1/charges', params, (charge) => new Charge(charge));
+        return this.page('/v1/charges', params, apiCharge);
     }
     /** Iterate over every charge, newest first, fetching pages as they are reached. */
     async *iterator(params = {}) {
@@ -20,22 +20,26 @@ export class ChargeService extends Service {
     }
     /** Cancel a pending charge that no transfer has been seen for, so it can no longer be paid. */
     async cancel(id, options) {
-        return new Charge(await this.request('POST', path('/v1/charges/%s/cancel', id), undefined, options));
+        return apiCharge(await this.request('POST', path('/v1/charges/%s/cancel', id), undefined, options));
     }
     /** Record a refund you sent the customer from your own wallet. An underpaid charge or a late payment is accepted first, and the network surcharge is never refundable. */
     async recordRefund(id, params, options) {
-        return new Charge(await this.request('POST', path('/v1/charges/%s/refunds', id), params, options));
+        return apiCharge(await this.request('POST', path('/v1/charges/%s/refunds', id), withDecimalAmounts(params, 'amount'), options));
     }
     /** Email the customer the payment page of a pending charge. */
     async send(id, options) {
-        return new Charge(await this.request('POST', path('/v1/charges/%s/send', id), undefined, options));
+        return apiCharge(await this.request('POST', path('/v1/charges/%s/send', id), undefined, options));
     }
     /** Accept an underpaid charge, or a late payment on an expired or canceled one, as paid for what arrived and confirmed. */
     async accept(id, options) {
-        return new Charge(await this.request('POST', path('/v1/charges/%s/accept', id), undefined, options));
+        return apiCharge(await this.request('POST', path('/v1/charges/%s/accept', id), undefined, options));
     }
     /** Pay a test-mode charge without coins, in full or by a chosen amount in the charge's coin. */
     async simulate(id, params = {}, options) {
-        return new Charge(await this.request('POST', path('/v1/charges/%s/simulate', id), Object.keys(params).length === 0 ? undefined : params, options));
+        return apiCharge(await this.request('POST', path('/v1/charges/%s/simulate', id), Object.keys(params).length === 0 ? undefined : withDecimalAmounts(params, 'amount'), options));
     }
 }
+/** Read a charge the API answered with, which always carries its checkout page. */
+function apiCharge(attributes) {
+    return new Charge(attributes);
+}

package/dist/esm/services/coupons.js

@@ -1,10 +1,10 @@
 import { Coupon } from '../resources/coupon.js';
-import { path, Service } from './service.js';
+import { path, Service, withDecimalAmounts } from './service.js';
 /** The /v1/coupons endpoints, where a coupon's id is its code. */
 export class CouponService extends Service {
     /** Create a coupon taking either percent_off or amount_off; currency is required with amount_off or min_amount. */
     async create(params, options) {
-        return new Coupon(await this.request('POST', '/v1/coupons', params, options));
+        return new Coupon(await this.request('POST', '/v1/coupons', withDecimalAmounts(params, 'percent_off', 'amount_off', 'min_amount'), options));
     }
     /** Retrieve a coupon by its code, in any case. */
     async retrieve(id) {

package/dist/esm/services/invoices.js

@@ -1,10 +1,14 @@
 import { Invoice } from '../resources/invoice.js';
-import { path, Service } from './service.js';
+import { path, Service, withDecimalAmounts } from './service.js';
 /** The /v1/invoices endpoints. */
 export class InvoiceService extends Service {
     /** Create an invoice, for a total or a list of items, and optionally email it to the customer. */
     async create(params, options) {
-        return new Invoice(await this.request('POST', '/v1/invoices', params, options));
+        const body = withDecimalAmounts(params, 'amount');
+        if (Array.isArray(params.items)) {
+            body.items = params.items.map((item) => withDecimalAmounts(item, 'quantity', 'unit_amount'));
+        }
+        return new Invoice(await this.request('POST', '/v1/invoices', body, options));
     }
     /** Retrieve an invoice by its id. */
     async retrieve(id) {

package/dist/esm/services/members.d.ts

@@ -8,7 +8,7 @@ export declare class MemberService extends Service {
     list(params?: PageParams): Promise<Page<Member>>;
     /** Iterate over every member, oldest first, fetching pages as they are reached. */
     iterator(params?: Omit<PageParams, 'page'>): AsyncGenerator<Member, void, undefined>;
-    /** Give a member another role: "admin", "finance", "support" or "viewer". An owner is never changed this way. */
+    /** Give a member another role: admin, finance, support or viewer, as the MemberRole values name them. An owner is never changed this way. */
     update(id: string, params: MemberUpdateParams, options?: RequestOptions): Promise<Member>;
     /** Remove a member, which also revokes the API keys they made. An owner is never removed this way. */
     remove(id: string, options?: RequestOptions): Promise<void>;
@@ -19,7 +19,7 @@ export declare class InvitationService extends Service {
     list(params?: PageParams): Promise<Page<Invitation>>;
     /** Iterate over every waiting invitation, newest first, fetching pages as they are reached. */
     iterator(params?: Omit<PageParams, 'page'>): AsyncGenerator<Invitation, void, undefined>;
-    /** Email someone an invitation to join as an "admin", "finance", "support" or "viewer", in the name of whoever made the API key. */
+    /** Email someone an invitation to join as an admin, finance, support or viewer, in the name of whoever made the API key. */
     create(params: InvitationCreateParams, options?: RequestOptions): Promise<Invitation>;
     /** Withdraw an invitation, so its link stops working. */
     cancel(id: string, options?: RequestOptions): Promise<void>;

package/dist/esm/services/members.js

@@ -10,7 +10,7 @@ export class MemberService extends Service {
     async *iterator(params = {}) {
         yield* (await this.list(params)).autoPagingIterator();
     }
-    /** Give a member another role: "admin", "finance", "support" or "viewer". An owner is never changed this way. */
+    /** Give a member another role: admin, finance, support or viewer, as the MemberRole values name them. An owner is never changed this way. */
     async update(id, params, options) {
         return new Member(await this.request('PATCH', path('/v1/members/%s', id), params, options));
     }
@@ -29,7 +29,7 @@ export class InvitationService extends Service {
     async *iterator(params = {}) {
         yield* (await this.list(params)).autoPagingIterator();
     }
-    /** Email someone an invitation to join as an "admin", "finance", "support" or "viewer", in the name of whoever made the API key. */
+    /** Email someone an invitation to join as an admin, finance, support or viewer, in the name of whoever made the API key. */
     async create(params, options) {
         return new Invitation(await this.request('POST', '/v1/invitations', params, options));
     }

package/dist/esm/services/overview.d.ts

@@ -2,6 +2,6 @@ import { Overview } from '../resources/overview.ts';
 import { Service } from './service.ts';
 /** The /v1/overview endpoint. Needs overview:read. */
 export declare class OverviewService extends Service {
-    /** Retrieve the dashboard's figures for the last 30 days, in the API key's mode. */
+    /** Retrieve the dashboard's figures for the last 30 days, in the API key's mode, and what needs attention now. */
     retrieve(): Promise<Overview>;
 }

package/dist/esm/services/overview.js

@@ -1,9 +1,10 @@
 import { Overview } from '../resources/overview.js';
-import { Service } from './service.js';
+import { data, meta, Service } from './service.js';
 /** The /v1/overview endpoint. Needs overview:read. */
 export class OverviewService extends Service {
-    /** Retrieve the dashboard's figures for the last 30 days, in the API key's mode. */
+    /** Retrieve the dashboard's figures for the last 30 days, in the API key's mode, and what needs attention now. */
     async retrieve() {
-        return new Overview(await this.request('GET', '/v1/overview'));
+        const response = await this.respond('GET', '/v1/overview');
+        return new Overview(data(response), meta(response));
     }
 }

package/dist/esm/services/payment-links.js

@@ -1,10 +1,12 @@
 import { PaymentLink } from '../resources/payment-link.js';
-import { path, Service } from './service.js';
+import { path, Service, withDecimalAmounts } from './service.js';
+/** The amounts a payment link takes, which go out as decimal strings. */
+const AMOUNTS = ['amount', 'suggested_amounts', 'min_amount', 'max_amount'];
 /** The /v1/payment-links endpoints. */
 export class PaymentLinkService extends Service {
     /** Create a payment link: one reusable public page, never one per customer. */
     async create(params, options) {
-        return new PaymentLink(await this.request('POST', '/v1/payment-links', params, options));
+        return new PaymentLink(await this.request('POST', '/v1/payment-links', withDecimalAmounts(params, ...AMOUNTS), options));
     }
     /** Retrieve a payment link by its id. */
     async retrieve(id) {
@@ -12,7 +14,7 @@ export class PaymentLinkService extends Service {
     }
     /** Change any of a payment link's fields. */
     async update(id, params, options) {
-        return new PaymentLink(await this.request('PATCH', path('/v1/payment-links/%s', id), params, options));
+        return new PaymentLink(await this.request('PATCH', path('/v1/payment-links/%s', id), withDecimalAmounts(params, ...AMOUNTS), options));
     }
     /** List payment links, newest first. */
     async list(params = {}) {

package/dist/esm/services/payout-addresses.d.ts

@@ -1,12 +1,17 @@
+import type { AddressNetwork, OrString } from '../enums.ts';
 import type { PayoutAddressUpdateParams, RequestOptions } from '../params.ts';
 import { PayoutAddress } from '../resources/payout.ts';
 import { Service } from './service.ts';
-/** The /v1/payout-addresses endpoints. Reading needs payout_addresses:read; changing needs payout_addresses:write and an owner's switch under Payment settings. */
+/**
+ * The /v1/payout-addresses endpoints, one address per network family: bitcoin, litecoin, dogecoin, bitcoincash, evm (Ethereum),
+ * bsc (BNB Chain), base, arbitrum, polygon, tron, monero, solana or lightning, as the AddressNetwork values name them.
+ * Reading needs payout_addresses:read; changing needs payout_addresses:write and an owner's switch under Payment settings.
+ */
 export declare class PayoutAddressService extends Service {
     /** List where payouts go in the API key's mode: one entry per network with coins on offer, its address null while there is none. */
     list(): Promise<PayoutAddress[]>;
-    /** Point the payouts of one network, such as "bitcoin" or "evm", at an address. */
-    update(network: string, params: PayoutAddressUpdateParams, options?: RequestOptions): Promise<PayoutAddress>;
+    /** Point the payouts of one network, such as AddressNetwork.Bitcoin or "evm", at an address. */
+    update(network: OrString<AddressNetwork>, params: PayoutAddressUpdateParams, options?: RequestOptions): Promise<PayoutAddress>;
     /** Remove the address of one network, so its payouts wait for a new one. */
-    delete(network: string, options?: RequestOptions): Promise<PayoutAddress>;
+    delete(network: OrString<AddressNetwork>, options?: RequestOptions): Promise<PayoutAddress>;
 }

package/dist/esm/services/payout-addresses.js

@@ -1,12 +1,16 @@
 import { PayoutAddress } from '../resources/payout.js';
 import { list, path, Service } from './service.js';
-/** The /v1/payout-addresses endpoints. Reading needs payout_addresses:read; changing needs payout_addresses:write and an owner's switch under Payment settings. */
+/**
+ * The /v1/payout-addresses endpoints, one address per network family: bitcoin, litecoin, dogecoin, bitcoincash, evm (Ethereum),
+ * bsc (BNB Chain), base, arbitrum, polygon, tron, monero, solana or lightning, as the AddressNetwork values name them.
+ * Reading needs payout_addresses:read; changing needs payout_addresses:write and an owner's switch under Payment settings.
+ */
 export class PayoutAddressService extends Service {
     /** List where payouts go in the API key's mode: one entry per network with coins on offer, its address null while there is none. */
     async list() {
         return list(await this.respond('GET', '/v1/payout-addresses')).map((address) => new PayoutAddress(address));
     }
-    /** Point the payouts of one network, such as "bitcoin" or "evm", at an address. */
+    /** Point the payouts of one network, such as AddressNetwork.Bitcoin or "evm", at an address. */
     async update(network, params, options) {
         return new PayoutAddress(await this.request('PUT', path('/v1/payout-addresses/%s', network), params, options));
     }

package/dist/esm/services/service.d.ts

@@ -1,8 +1,10 @@
 import type { ApiResponse } from '../http/api-response.ts';
 import type { HttpTransport } from '../http/transport.ts';
-import { Page } from '../page.ts';
+import { Page, type PagePosition } from '../page.ts';
 import type { RequestOptions } from '../params.ts';
 import { type ApiResource, type Attributes } from '../resources/api-resource.ts';
+/** A class of page, such as Page itself or one that reads more of the list's meta. */
+type PageKind<T extends ApiResource, P extends Page<T>> = new (data: T[], position: PagePosition, fetch: (page: number) => Promise<P>, meta: Attributes) => P;
 /** The requests shared by every group of endpoints. */
 export declare abstract class Service {
     protected readonly transport: HttpTransport;
@@ -11,8 +13,8 @@ export declare abstract class Service {
     protected request(method: string, path: string, body?: object, options?: RequestOptions): Promise<Attributes>;
     /** Send a request and return the whole response, for answers whose meta matters too. */
     protected respond(method: string, path: string, body?: object, options?: RequestOptions): Promise<ApiResponse>;
-    /** Fetch one page of a list. */
-    protected page<T extends ApiResource>(path: string, params: object, hydrate: (attributes: Attributes) => T): Promise<Page<T>>;
+    /** Fetch one page of a list, as a Page unless another kind is given. */
+    protected page<T extends ApiResource, P extends Page<T> = Page<T>>(path: string, params: object, hydrate: (attributes: Attributes) => T, kind?: PageKind<T, P>): Promise<P>;
 }
 /** Read the object under a response's "data" key. */
 export declare function data(response: ApiResponse): Attributes;
@@ -20,5 +22,8 @@ export declare function data(response: ApiResponse): Attributes;
 export declare function meta(response: ApiResponse): Attributes;
 /** Read the objects of the list under a response's "data" key. */
 export declare function list(response: ApiResponse): Attributes[];
+/** A copy of the params with the amounts under the given keys, alone or in a list, written as the API reads them. */
+export declare function withDecimalAmounts<T extends object>(params: T, ...keys: string[]): T;
 /** Build a path with the given ids escaped into its %s placeholders. */
 export declare function path(format: string, ...ids: string[]): string;
+export {};

package/dist/esm/services/service.js

@@ -15,19 +15,18 @@ export class Service {
     respond(method, path, body, options) {
         return this.transport.request(method, path, {}, body, options?.idempotencyKey);
     }
-    /** Fetch one page of a list. */
-    async page(path, params, hydrate) {
+    /** Fetch one page of a list, as a Page unless another kind is given. */
+    async page(path, params, hydrate, kind = Page) {
         const response = await this.transport.request('GET', path, params);
         const data = list(response).map(hydrate);
-        const json = response.json();
-        const meta = isRecord(json['meta']) ? json['meta'] : {};
-        const currentPage = integer(meta['current_page'], 1);
-        return new Page(data, {
+        const metadata = meta(response);
+        const currentPage = integer(metadata['current_page'], 1);
+        return new kind(data, {
             currentPage,
-            lastPage: integer(meta['last_page'], currentPage),
-            perPage: integer(meta['per_page'], data.length),
-            total: integer(meta['total'], data.length),
-        }, (page) => this.page(path, { ...params, page }, hydrate));
+            lastPage: integer(metadata['last_page'], currentPage),
+            perPage: integer(metadata['per_page'], data.length),
+            total: integer(metadata['total'], data.length),
+        }, (page) => this.page(path, { ...params, page }, hydrate, kind), metadata);
     }
 }
 /** Read the object under a response's "data" key. */
@@ -51,6 +50,41 @@ export function list(response) {
     }
     return value.filter(isRecord);
 }
+/** A copy of the params with the amounts under the given keys, alone or in a list, written as the API reads them. */
+export function withDecimalAmounts(params, ...keys) {
+    const copy = { ...params };
+    for (const key of keys) {
+        if (Object.hasOwn(copy, key)) {
+            const value = copy[key];
+            copy[key] = Array.isArray(value) ? value.map((item) => decimalAmount(item, key)) : decimalAmount(value, key);
+        }
+    }
+    return copy;
+}
+/** An amount as the API reads it: a string as it is, and a number rounded to 14 significant digits, as the API read JSON numbers, and written without an exponent, which the API refuses. */
+function decimalAmount(value, key) {
+    if (typeof value !== 'number') {
+        return value;
+    }
+    if (!Number.isFinite(value)) {
+        throw new InvalidArgumentError(`The ${key} must be a finite number, or a string such as "49.90", not ${value}.`);
+    }
+    if (!Number.isInteger(value) && Math.abs(value) >= 1e14) {
+        throw new InvalidArgumentError(`The ${key} ${value} has too many digits to be sent as a number: pass it as a string.`);
+    }
+    // Rounding drops the binary noise of a float, so 0.1 + 0.2 goes out as 0.3.
+    const rounded = Number.isInteger(value) ? value : Number(value.toPrecision(14));
+    const [, sign = '', whole = '', fraction = '', exponent] = /^(-?)(\d+)(?:\.(\d+))?e([+-]\d+)$/.exec(String(rounded)) ?? [];
+    if (exponent === undefined) {
+        return String(rounded);
+    }
+    const digits = whole + fraction;
+    const point = whole.length + Number(exponent);
+    if (point <= 0) {
+        return `${sign}0.${'0'.repeat(-point)}${digits}`;
+    }
+    return point >= digits.length ? `${sign}${digits}${'0'.repeat(point - digits.length)}` : `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
 /** Build a path with the given ids escaped into its %s placeholders. */
 export function path(format, ...ids) {
     let index = 0;

package/dist/esm/services/webhook-endpoints.d.ts

@@ -10,7 +10,13 @@ export declare class WebhookEndpointService extends Service {
     iterator(params?: Omit<PageParams, 'page'>): AsyncGenerator<WebhookEndpoint, void, undefined>;
     /** Retrieve one webhook endpoint. */
     retrieve(id: string): Promise<WebhookEndpoint>;
-    /** Add an endpoint and send it its verification challenge. The answer carries its signing secret, shown this once, and verificationError while it has not answered. */
+    /**
+     * Add an endpoint and send it its verification challenge. The answer carries its signing secret, shown this once, and verificationError while it has not answered.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the endpoint was added, but its secret cannot be shown again. Find it with list() and call rotateSecret(),
+     * since nothing relies on its first secret yet, or delete() it and add it again.
+     */
     create(params: WebhookEndpointCreateParams, options?: RequestOptions): Promise<WebhookEndpoint>;
     /** Change an endpoint's url, events, description or active, only those given. A new url is verified again. */
     update(id: string, params: WebhookEndpointUpdateParams, options?: RequestOptions): Promise<WebhookEndpoint>;
@@ -20,7 +26,14 @@ export declare class WebhookEndpointService extends Service {
     verify(id: string, options?: RequestOptions): Promise<WebhookEndpoint>;
     /** Queue a sample charge.paid event, marked as a test, to a verified endpoint. */
     test(id: string, options?: RequestOptions): Promise<WebhookDelivery>;
-    /** Replace the endpoint's signing secret. The answer carries the new one, shown this once; the old one keeps signing for a day, until previousSecretExpiresAt. */
+    /**
+     * Replace the endpoint's signing secret. The answer carries the new one, shown this once; the old one keeps signing for a day, until previousSecretExpiresAt.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the secret was rotated, but the new one cannot be shown again. The secret your receiver holds keeps
+     * verifying for a day as the previous one. Rotating again makes the lost secret the previous one and drops the one you hold at once,
+     * so only rotate again, with a fresh idempotency key, when you can deploy the new secret straight away; deliveries that fail meanwhile are retried.
+     */
     rotateSecret(id: string, options?: RequestOptions): Promise<WebhookEndpoint>;
     /** List what the endpoint was sent, newest first, kept for 30 days. */
     deliveries(id: string, params?: WebhookDeliveryListParams): Promise<Page<WebhookDelivery>>;

package/dist/esm/services/webhook-endpoints.js

@@ -14,7 +14,13 @@ export class WebhookEndpointService extends Service {
     async retrieve(id) {
         return new WebhookEndpoint(await this.request('GET', path('/v1/webhook-endpoints/%s', id)));
     }
-    /** Add an endpoint and send it its verification challenge. The answer carries its signing secret, shown this once, and verificationError while it has not answered. */
+    /**
+     * Add an endpoint and send it its verification challenge. The answer carries its signing secret, shown this once, and verificationError while it has not answered.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the endpoint was added, but its secret cannot be shown again. Find it with list() and call rotateSecret(),
+     * since nothing relies on its first secret yet, or delete() it and add it again.
+     */
     async create(params, options) {
         return endpoint(await this.respond('POST', '/v1/webhook-endpoints', params, options));
     }
@@ -34,7 +40,14 @@ export class WebhookEndpointService extends Service {
     async test(id, options) {
         return new WebhookDelivery(await this.request('POST', path('/v1/webhook-endpoints/%s/test', id), undefined, options));
     }
-    /** Replace the endpoint's signing secret. The answer carries the new one, shown this once; the old one keeps signing for a day, until previousSecretExpiresAt. */
+    /**
+     * Replace the endpoint's signing secret. The answer carries the new one, shown this once; the old one keeps signing for a day, until previousSecretExpiresAt.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the secret was rotated, but the new one cannot be shown again. The secret your receiver holds keeps
+     * verifying for a day as the previous one. Rotating again makes the lost secret the previous one and drops the one you hold at once,
+     * so only rotate again, with a fresh idempotency key, when you can deploy the new secret straight away; deliveries that fail meanwhile are retried.
+     */
     async rotateSecret(id, options) {
         return endpoint(await this.respond('POST', path('/v1/webhook-endpoints/%s/secret', id), undefined, options));
     }

package/dist/esm/version.d.ts

@@ -1,2 +1,2 @@
 /** The version of this library. */
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.2.0";

package/dist/esm/version.js

@@ -1,2 +1,2 @@
 /** The version of this library. */
-export const VERSION = '0.1.0';
+export const VERSION = '0.2.0';

package/package.json

@@ -1,19 +1,29 @@
 {
     "$schema": "https://www.schemastore.org/package.json",
     "name": "velirapay",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "The official Node.js library for VeliraPay crypto payments: charges, payment links, invoices, payouts, events and webhook verification.",
     "keywords": [
         "velirapay",
         "crypto",
+        "cryptocurrency",
+        "crypto-payments",
         "payments",
         "payment-gateway",
+        "payment-processing",
         "bitcoin",
         "ethereum",
+        "litecoin",
         "solana",
+        "usdt",
+        "usdc",
         "webhooks",
         "sdk",
-        "api"
+        "api",
+        "api-client",
+        "typescript",
+        "javascript",
+        "nodejs"
     ],
     "homepage": "https://velirapay.com",
     "bugs": {