dnsofmoney 0.4.0

package/README.md

@@ -0,0 +1,110 @@
+# dnsofmoney — TypeScript SDK
+
+Resolve, register, send to, and check availability of `pay:` aliases using the DNS of Money API.
+
+**No external dependencies** — uses only the built-in `fetch()` API.
+
+## Install
+
+```bash
+npm install dnsofmoney
+```
+
+> Not yet on npm — coming soon. For now, clone the repo and build from source:
+> ```bash
+> cd sdk/typescript && npm install && npm run build
+> ```
+
+## Quick Start
+
+### Resolve a pay: alias
+
+```typescript
+import { resolve } from "dnsofmoney";
+
+const result = await resolve("pay:vendor.alpha");
+console.log(result.entity?.display_name);
+console.log(result.endpoints[0].rail);
+console.log(result.resolution_status);
+```
+
+### Register a pay: alias
+
+```typescript
+import { register } from "dnsofmoney";
+
+const result = await register(
+  "pay:your.name",
+  "Your Name",
+  "fednow",
+  "fas_live_...",
+);
+console.log(result.alias_name);
+console.log(result.registration_number);
+```
+
+### Check availability
+
+```typescript
+import { checkAvailability } from "dnsofmoney";
+
+const available = await checkAvailability("pay:desired.name");
+console.log(available ? "Available!" : "Taken.");
+```
+
+### Preview a payment (dry-run, no API key)
+
+```typescript
+import { sendPreview } from "dnsofmoney";
+
+const preview = await sendPreview("pay:vendor.alpha");
+console.log(preview.resolved, preview.rail, preview.destination_address);
+```
+
+### Send money to a pay: alias
+
+```typescript
+import { send } from "dnsofmoney";
+
+const receipt = await send("pay:vendor.alpha", 5.0, "fas_live_...", {
+  currency: "XRP",
+  memo: "invoice 1234",
+  // idempotencyKey auto-generated if omitted — safe to retry
+});
+console.log(receipt.status, receipt.rail, receipt.tx_hash);
+```
+
+### Client instance (reuse connections)
+
+```typescript
+import { DNSOfMoneyClient } from "dnsofmoney";
+
+const client = new DNSOfMoneyClient({ apiKey: "fas_live_..." });
+const result = await client.resolve("pay:vendor.alpha");
+const available = await client.checkAvailability("pay:new.name");
+const preview = await client.sendPreview("pay:vendor.alpha");
+const receipt = await client.send("pay:vendor.alpha", 5.0, { currency: "XRP" });
+```
+
+## Error Handling
+
+```typescript
+import { resolve, AliasNotFoundError, AuthenticationError } from "dnsofmoney";
+
+try {
+  const result = await resolve("pay:nonexistent.alias");
+} catch (err) {
+  if (err instanceof AliasNotFoundError) {
+    console.log("Alias does not exist");
+  } else if (err instanceof AuthenticationError) {
+    console.log("Invalid API key");
+  }
+}
+```
+
+## Links
+
+- [Full documentation](https://docs.dnsofmoney.com)
+- [FAS-1 specification](https://github.com/dnsofmoney/dns-of-money/blob/main/docs/FAS-1-spec.md)
+- [Examples](https://github.com/dnsofmoney/dns-of-money/tree/main/examples)
+- [JSON schemas](https://github.com/dnsofmoney/dns-of-money/tree/main/schemas)

package/dist/client.d.ts

@@ -0,0 +1,100 @@
+/**
+ * DNS of Money SDK — TypeScript client.
+ *
+ * Resolve, register, and check availability of pay: aliases.
+ * Uses only the built-in fetch() API — no external dependencies.
+ *
+ * Usage:
+ *   import { DNSOfMoneyClient } from "dnsofmoney";
+ *
+ *   const client = new DNSOfMoneyClient({ apiKey: "fas_live_..." });
+ *   const result = await client.resolve("pay:vendor.alpha");
+ */
+import type { RegistrationResponse, ResolutionResponse, SendOptions, SendPreview, SendResult } from "./models";
+export interface ClientOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+export declare class DNSOfMoneyClient {
+    private readonly apiKey?;
+    private readonly baseUrl;
+    private readonly timeout;
+    constructor(options?: ClientOptions);
+    /**
+     * Resolve a pay: alias to payment credentials.
+     *
+     * No API key required for public aliases. Authenticated callers
+     * receive higher-tier responses with additional fields.
+     *
+     * @param aliasUri - A FAS-1 pay: URI (e.g., "pay:vendor.alpha").
+     * @throws {AliasNotFoundError} If the alias does not exist.
+     */
+    resolve(aliasUri: string): Promise<ResolutionResponse>;
+    /**
+     * Register a new pay: alias.
+     *
+     * Requires API key. The alias must not already be taken or reserved.
+     *
+     * @throws {AliasTakenError} If the alias is already registered.
+     * @throws {CapReachedError} If the founding tier cap has been reached.
+     * @throws {AuthenticationError} If the API key is missing or invalid.
+     */
+    register(aliasName: string, displayName: string, preferredRail: string, extra?: Record<string, unknown>): Promise<RegistrationResponse>;
+    /**
+     * Check if a pay: alias is available to register.
+     *
+     * No API key required.
+     *
+     * @returns true if available, false if taken or reserved.
+     */
+    checkAvailability(aliasName: string): Promise<boolean>;
+    /**
+     * Preview where a payment would go without executing.
+     *
+     * No API key required. Returns the destination address (masked),
+     * rail, fee estimate, and identity info.
+     *
+     * @param alias - A pay: alias (e.g., "pay:vendor.alpha") or bare name ("vendor.alpha").
+     * @throws {AliasNotFoundError} If the alias does not exist.
+     */
+    sendPreview(alias: string): Promise<SendPreview>;
+    /**
+     * Send money to a pay: alias.
+     *
+     * Requires API key. Resolves the alias globally, routes to the best
+     * payment rail, generates an ISO 20022 message, and executes settlement.
+     *
+     * @param alias - Target pay: alias (e.g., "pay:vendor.alpha").
+     * @param amount - Amount in currency units.
+     * @param options - Optional currency, memo, and idempotencyKey. An
+     *   idempotency key is auto-generated if not provided.
+     * @throws {AliasNotFoundError} If the alias does not exist.
+     * @throws {AuthenticationError} If the API key is missing or invalid.
+     */
+    send(alias: string, amount: number, options?: SendOptions): Promise<SendResult>;
+    private headers;
+    private get;
+    private post;
+    private handleResponse;
+}
+/**
+ * Resolve a pay: alias. See DNSOfMoneyClient.resolve for full docs.
+ */
+export declare function resolve(aliasUri: string, apiKey?: string, baseUrl?: string): Promise<ResolutionResponse>;
+/**
+ * Register a pay: alias. See DNSOfMoneyClient.register for full docs.
+ */
+export declare function register(aliasName: string, displayName: string, preferredRail: string, apiKey: string, baseUrl?: string, extra?: Record<string, unknown>): Promise<RegistrationResponse>;
+/**
+ * Check alias availability. See DNSOfMoneyClient.checkAvailability for full docs.
+ */
+export declare function checkAvailability(aliasName: string, baseUrl?: string): Promise<boolean>;
+/**
+ * Preview a send-to-alias payment. See DNSOfMoneyClient.sendPreview for full docs.
+ */
+export declare function sendPreview(alias: string, baseUrl?: string): Promise<SendPreview>;
+/**
+ * Send money to a pay: alias. See DNSOfMoneyClient.send for full docs.
+ */
+export declare function send(alias: string, amount: number, apiKey: string, options?: SendOptions, baseUrl?: string): Promise<SendResult>;

package/dist/client.js

@@ -0,0 +1,357 @@
+"use strict";
+/**
+ * DNS of Money SDK — TypeScript client.
+ *
+ * Resolve, register, and check availability of pay: aliases.
+ * Uses only the built-in fetch() API — no external dependencies.
+ *
+ * Usage:
+ *   import { DNSOfMoneyClient } from "dnsofmoney";
+ *
+ *   const client = new DNSOfMoneyClient({ apiKey: "fas_live_..." });
+ *   const result = await client.resolve("pay:vendor.alpha");
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DNSOfMoneyClient = void 0;
+exports.resolve = resolve;
+exports.register = register;
+exports.checkAvailability = checkAvailability;
+exports.sendPreview = sendPreview;
+exports.send = send;
+const exceptions_1 = require("./exceptions");
+const DEFAULT_BASE_URL = "https://api.dnsofmoney.com";
+class DNSOfMoneyClient {
+    constructor(options = {}) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.timeout = options.timeout ?? 10000;
+    }
+    /**
+     * Resolve a pay: alias to payment credentials.
+     *
+     * No API key required for public aliases. Authenticated callers
+     * receive higher-tier responses with additional fields.
+     *
+     * @param aliasUri - A FAS-1 pay: URI (e.g., "pay:vendor.alpha").
+     * @throws {AliasNotFoundError} If the alias does not exist.
+     */
+    async resolve(aliasUri) {
+        const raw = await this.get(`/resolve/${aliasUri}`);
+        const data = raw.success !== undefined ? (raw.data ?? raw) : raw;
+        return parseResolution(data);
+    }
+    /**
+     * Register a new pay: alias.
+     *
+     * Requires API key. The alias must not already be taken or reserved.
+     *
+     * @throws {AliasTakenError} If the alias is already registered.
+     * @throws {CapReachedError} If the founding tier cap has been reached.
+     * @throws {AuthenticationError} If the API key is missing or invalid.
+     */
+    async register(aliasName, displayName, preferredRail, extra = {}) {
+        const body = {
+            alias_name: aliasName,
+            display_name: displayName,
+            preferred_rail: preferredRail,
+            ...extra,
+        };
+        const data = await this.post("/v1/aliases", body);
+        return {
+            alias_name: data.alias_name ?? aliasName,
+            registration_number: data.registration_number,
+            anchor_status: data.anchor_status,
+            proof: data.proof,
+            created_at: data.created_at,
+        };
+    }
+    /**
+     * Check if a pay: alias is available to register.
+     *
+     * No API key required.
+     *
+     * @returns true if available, false if taken or reserved.
+     */
+    async checkAvailability(aliasName) {
+        const data = await this.get(`/v1/aliases/check/${aliasName}`);
+        return data.status === "available";
+    }
+    /**
+     * Preview where a payment would go without executing.
+     *
+     * No API key required. Returns the destination address (masked),
+     * rail, fee estimate, and identity info.
+     *
+     * @param alias - A pay: alias (e.g., "pay:vendor.alpha") or bare name ("vendor.alpha").
+     * @throws {AliasNotFoundError} If the alias does not exist.
+     */
+    async sendPreview(alias) {
+        const data = await this.get(`/api/v1/send/preview/${alias}`);
+        return {
+            alias: data.alias ?? alias,
+            resolved: data.resolved ?? false,
+            destination_address: data.destination_address,
+            display_name: data.display_name,
+            rail: data.rail,
+            currency: data.currency ?? "USD",
+            fee_estimate: data.fee_estimate,
+            identity: data.identity,
+        };
+    }
+    /**
+     * Send money to a pay: alias.
+     *
+     * Requires API key. Resolves the alias globally, routes to the best
+     * payment rail, generates an ISO 20022 message, and executes settlement.
+     *
+     * @param alias - Target pay: alias (e.g., "pay:vendor.alpha").
+     * @param amount - Amount in currency units.
+     * @param options - Optional currency, memo, and idempotencyKey. An
+     *   idempotency key is auto-generated if not provided.
+     * @throws {AliasNotFoundError} If the alias does not exist.
+     * @throws {AuthenticationError} If the API key is missing or invalid.
+     */
+    async send(alias, amount, options = {}) {
+        const currency = options.currency ?? "USD";
+        const body = {
+            alias,
+            amount,
+            currency,
+            idempotency_key: options.idempotencyKey ?? generateIdempotencyKey(),
+        };
+        if (options.memo !== undefined) {
+            body.memo = options.memo;
+        }
+        const data = await this.post("/api/v1/send", body);
+        return {
+            transaction_id: data.transaction_id ?? "",
+            status: data.status ?? "",
+            alias: data.alias ?? alias,
+            amount: data.amount ?? amount,
+            currency: data.currency ?? currency,
+            rail: data.rail ?? "",
+            tx_hash: data.tx_hash,
+            settle_time_seconds: data.settle_time_seconds,
+            memo: data.memo,
+            created_at: data.created_at,
+        };
+    }
+    // ── Internal HTTP helpers ─────────────────────────────────────────────
+    headers() {
+        const h = { Accept: "application/json" };
+        if (this.apiKey) {
+            h["X-API-Key"] = this.apiKey;
+        }
+        return h;
+    }
+    async get(path) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const resp = await fetch(`${this.baseUrl}${path}`, {
+                method: "GET",
+                headers: this.headers(),
+                signal: controller.signal,
+            });
+            return this.handleResponse(resp);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async post(path, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const resp = await fetch(`${this.baseUrl}${path}`, {
+                method: "POST",
+                headers: { ...this.headers(), "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            return this.handleResponse(resp);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async handleResponse(resp) {
+        if (resp.ok) {
+            return resp.json();
+        }
+        let body = {};
+        try {
+            body = await resp.json();
+        }
+        catch {
+            // non-JSON error body — ignore
+        }
+        const errorCode = body.error_code ?? "";
+        const detail = body.detail ?? "";
+        if (resp.status === 401)
+            throw new exceptions_1.AuthenticationError();
+        if (resp.status === 404)
+            throw new exceptions_1.AliasNotFoundError(detail || "unknown alias");
+        if (resp.status === 409) {
+            if (errorCode === "CAP_EXCEEDED")
+                throw new exceptions_1.CapReachedError();
+            throw new exceptions_1.AliasTakenError(detail || "alias taken");
+        }
+        if (resp.status === 429) {
+            throw new exceptions_1.RateLimitError(body.retry_after);
+        }
+        throw new exceptions_1.DNSOfMoneyError(`HTTP ${resp.status}: ${resp.statusText}`, resp.status);
+    }
+}
+exports.DNSOfMoneyClient = DNSOfMoneyClient;
+// ── Helpers ────────────────────────────────────────────────────────────────
+/**
+ * Generate a unique idempotency key for a send. Prefers crypto.randomUUID
+ * (Node 19+, all modern browsers); falls back to a timestamp+random hex token.
+ */
+function generateIdempotencyKey() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID) {
+        return `sdk-${c.randomUUID()}`;
+    }
+    const rand = Math.random().toString(16).slice(2);
+    return `sdk-${Date.now().toString(16)}${rand}`;
+}
+// ── Module-level convenience functions ────────────────────────────────────
+/**
+ * Resolve a pay: alias. See DNSOfMoneyClient.resolve for full docs.
+ */
+async function resolve(aliasUri, apiKey, baseUrl = DEFAULT_BASE_URL) {
+    return new DNSOfMoneyClient({ apiKey, baseUrl }).resolve(aliasUri);
+}
+/**
+ * Register a pay: alias. See DNSOfMoneyClient.register for full docs.
+ */
+async function register(aliasName, displayName, preferredRail, apiKey, baseUrl = DEFAULT_BASE_URL, extra = {}) {
+    return new DNSOfMoneyClient({ apiKey, baseUrl }).register(aliasName, displayName, preferredRail, extra);
+}
+/**
+ * Check alias availability. See DNSOfMoneyClient.checkAvailability for full docs.
+ */
+async function checkAvailability(aliasName, baseUrl = DEFAULT_BASE_URL) {
+    return new DNSOfMoneyClient({ baseUrl }).checkAvailability(aliasName);
+}
+/**
+ * Preview a send-to-alias payment. See DNSOfMoneyClient.sendPreview for full docs.
+ */
+async function sendPreview(alias, baseUrl = DEFAULT_BASE_URL) {
+    return new DNSOfMoneyClient({ baseUrl }).sendPreview(alias);
+}
+/**
+ * Send money to a pay: alias. See DNSOfMoneyClient.send for full docs.
+ */
+async function send(alias, amount, apiKey, options = {}, baseUrl = DEFAULT_BASE_URL) {
+    return new DNSOfMoneyClient({ apiKey, baseUrl }).send(alias, amount, options);
+}
+// ── Response parsing ──────────────────────────────────────────────────────
+function parseResolution(data) {
+    // Entity — may be nested object or top-level fields
+    let entity;
+    if (data.entity) {
+        entity = {
+            display_name: data.entity.display_name ?? "",
+            entity_type: data.entity.entity_type,
+            jurisdiction: data.entity.jurisdiction,
+            kyc_status: data.entity.kyc_status,
+        };
+    }
+    else if (data.display_name) {
+        entity = {
+            display_name: data.display_name ?? "",
+            entity_type: data.entity_type,
+        };
+    }
+    // Endpoints — handle both flat array and preferred_endpoint + fallback
+    const endpoints = [];
+    if (data.preferred_endpoint) {
+        const ep = data.preferred_endpoint;
+        endpoints.push({
+            rail: ep.rail_type ?? ep.rail ?? "",
+            currency: ep.currency ?? "USD",
+            address: ep.address,
+            priority: ep.priority ?? 1,
+            fee_estimate: ep.fee_estimate,
+            settlement_latency: ep.settlement_latency,
+            routing_metadata: ep.routing_metadata,
+        });
+        for (const fb of data.fallback_endpoints ?? []) {
+            endpoints.push({
+                rail: fb.rail_type ?? fb.rail ?? "",
+                currency: fb.currency ?? "USD",
+                address: fb.address,
+                priority: fb.priority ?? 2,
+                fee_estimate: fb.fee_estimate,
+                settlement_latency: fb.settlement_latency,
+                routing_metadata: fb.routing_metadata,
+            });
+        }
+    }
+    else {
+        for (const ep of data.endpoints ?? []) {
+            endpoints.push({
+                rail: ep.rail ?? "",
+                currency: ep.currency ?? "USD",
+                address: ep.address,
+                priority: ep.priority ?? 1,
+                fee_estimate: ep.fee_estimate,
+                settlement_latency: ep.settlement_latency,
+                routing_metadata: ep.routing_metadata,
+            });
+        }
+    }
+    // Compliance
+    let compliance;
+    if (data.compliance) {
+        const c = data.compliance;
+        compliance = {
+            sanctions_checked: c.sanctions_checked ?? c.screened ?? false,
+            fatf_risk_rating: c.fatf_risk_rating,
+            requires_purpose_code: c.requires_purpose_code ?? false,
+            screened: c.screened,
+            result: c.result,
+            provider: c.provider,
+            screened_at: c.screened_at,
+            cached: c.cached,
+        };
+    }
+    // Identity (NFT + generative art)
+    let identity;
+    if (data.identity) {
+        const i = data.identity;
+        identity = {
+            nft_token_id: i.nft_token_id,
+            image_uri: i.image_uri,
+            metadata_uri: i.metadata_uri,
+            image_url: i.image_url,
+            nft_explorer_url: i.nft_explorer_url,
+            generation: i.generation,
+            identity_status: i.identity_status,
+            tier: i.tier,
+        };
+    }
+    return {
+        resolution_id: data.resolution_id ?? "",
+        alias_uri: data.alias ?? "",
+        resolved_at: data.resolved_at ?? "",
+        ttl_seconds: data.ttl_seconds ?? 300,
+        message_id: data.message_id,
+        entity_id: data.entity_id,
+        entity,
+        endpoints,
+        compliance,
+        iso20022_hint: data.iso20022_hint,
+        identity,
+        rail_score: data.rail_score,
+        resolution_status: data.status ?? data.resolution_status ?? "resolved",
+        caller_tier: data.caller_tier,
+        resolved_from: data.resolved_from ?? "origin",
+        cache_hit: data.cache_hit ?? false,
+        agent_commerce: data.agent_commerce,
+        warnings: data.warnings ?? [],
+    };
+}

package/dist/exceptions.d.ts

@@ -0,0 +1,26 @@
+/** Base error for all DNS of Money SDK errors. */
+export declare class DNSOfMoneyError extends Error {
+    readonly statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}
+/** Raised when a pay: alias does not exist (HTTP 404). */
+export declare class AliasNotFoundError extends DNSOfMoneyError {
+    constructor(alias: string);
+}
+/** Raised when a pay: alias is already registered (HTTP 409). */
+export declare class AliasTakenError extends DNSOfMoneyError {
+    constructor(alias: string);
+}
+/** Raised when the API key is missing or invalid (HTTP 401). */
+export declare class AuthenticationError extends DNSOfMoneyError {
+    constructor();
+}
+/** Raised when the API rate limit is exceeded (HTTP 429). */
+export declare class RateLimitError extends DNSOfMoneyError {
+    readonly retryAfter?: number;
+    constructor(retryAfter?: number);
+}
+/** Raised when the founding tier cap (500) has been reached. */
+export declare class CapReachedError extends DNSOfMoneyError {
+    constructor();
+}

package/dist/exceptions.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapReachedError = exports.RateLimitError = exports.AuthenticationError = exports.AliasTakenError = exports.AliasNotFoundError = exports.DNSOfMoneyError = void 0;
+/** Base error for all DNS of Money SDK errors. */
+class DNSOfMoneyError extends Error {
+    constructor(message, statusCode) {
+        super(message);
+        this.name = "DNSOfMoneyError";
+        this.statusCode = statusCode;
+    }
+}
+exports.DNSOfMoneyError = DNSOfMoneyError;
+/** Raised when a pay: alias does not exist (HTTP 404). */
+class AliasNotFoundError extends DNSOfMoneyError {
+    constructor(alias) {
+        super(`Alias not found: ${alias}`, 404);
+        this.name = "AliasNotFoundError";
+    }
+}
+exports.AliasNotFoundError = AliasNotFoundError;
+/** Raised when a pay: alias is already registered (HTTP 409). */
+class AliasTakenError extends DNSOfMoneyError {
+    constructor(alias) {
+        super(`Alias already taken: ${alias}`, 409);
+        this.name = "AliasTakenError";
+    }
+}
+exports.AliasTakenError = AliasTakenError;
+/** Raised when the API key is missing or invalid (HTTP 401). */
+class AuthenticationError extends DNSOfMoneyError {
+    constructor() {
+        super("Invalid or missing API key", 401);
+        this.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/** Raised when the API rate limit is exceeded (HTTP 429). */
+class RateLimitError extends DNSOfMoneyError {
+    constructor(retryAfter) {
+        const msg = retryAfter
+            ? `Rate limit exceeded — retry after ${retryAfter}s`
+            : "Rate limit exceeded";
+        super(msg, 429);
+        this.name = "RateLimitError";
+        this.retryAfter = retryAfter;
+    }
+}
+exports.RateLimitError = RateLimitError;
+/** Raised when the founding tier cap (500) has been reached. */
+class CapReachedError extends DNSOfMoneyError {
+    constructor() {
+        super("Founding tier cap reached (500/500)", 409);
+        this.name = "CapReachedError";
+    }
+}
+exports.CapReachedError = CapReachedError;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { DNSOfMoneyClient, resolve, register, checkAvailability, sendPreview, send, } from "./client";
+export type { ClientOptions } from "./client";
+export { DNSOfMoneyError, AliasNotFoundError, AliasTakenError, AuthenticationError, RateLimitError, CapReachedError, } from "./exceptions";
+export type { Entity, Endpoint, Compliance, Identity, AgentCard, ResolutionResponse, RegistrationResponse, SendPreview, SendResult, SendOptions, } from "./models";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapReachedError = exports.RateLimitError = exports.AuthenticationError = exports.AliasTakenError = exports.AliasNotFoundError = exports.DNSOfMoneyError = exports.send = exports.sendPreview = exports.checkAvailability = exports.register = exports.resolve = exports.DNSOfMoneyClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "DNSOfMoneyClient", { enumerable: true, get: function () { return client_1.DNSOfMoneyClient; } });
+Object.defineProperty(exports, "resolve", { enumerable: true, get: function () { return client_1.resolve; } });
+Object.defineProperty(exports, "register", { enumerable: true, get: function () { return client_1.register; } });
+Object.defineProperty(exports, "checkAvailability", { enumerable: true, get: function () { return client_1.checkAvailability; } });
+Object.defineProperty(exports, "sendPreview", { enumerable: true, get: function () { return client_1.sendPreview; } });
+Object.defineProperty(exports, "send", { enumerable: true, get: function () { return client_1.send; } });
+var exceptions_1 = require("./exceptions");
+Object.defineProperty(exports, "DNSOfMoneyError", { enumerable: true, get: function () { return exceptions_1.DNSOfMoneyError; } });
+Object.defineProperty(exports, "AliasNotFoundError", { enumerable: true, get: function () { return exceptions_1.AliasNotFoundError; } });
+Object.defineProperty(exports, "AliasTakenError", { enumerable: true, get: function () { return exceptions_1.AliasTakenError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return exceptions_1.AuthenticationError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return exceptions_1.RateLimitError; } });
+Object.defineProperty(exports, "CapReachedError", { enumerable: true, get: function () { return exceptions_1.CapReachedError; } });

package/dist/models.d.ts

@@ -0,0 +1,108 @@
+/** The entity (person, business, agent) that owns a pay: alias. */
+export interface Entity {
+    display_name: string;
+    entity_type?: string;
+    jurisdiction?: string;
+    kyc_status?: string;
+}
+/** A single payment endpoint returned by resolution. */
+export interface Endpoint {
+    rail: string;
+    currency: string;
+    address?: string;
+    priority: number;
+    fee_estimate?: string;
+    settlement_latency?: string;
+    routing_metadata?: Record<string, unknown>;
+}
+/** Compliance screening result attached to a resolution. */
+export interface Compliance {
+    sanctions_checked: boolean;
+    fatf_risk_rating?: string;
+    requires_purpose_code: boolean;
+    screened?: boolean;
+    result?: string;
+    provider?: string;
+    screened_at?: string;
+    cached?: boolean;
+}
+/** On-chain identity linked to a pay: alias (NFT + generative art). */
+export interface Identity {
+    nft_token_id?: string;
+    image_uri?: string;
+    metadata_uri?: string;
+    image_url?: string;
+    nft_explorer_url?: string;
+    generation?: number;
+    identity_status?: string;
+    tier?: string;
+}
+/** AP2/A2A-003 agent capability manifest. */
+export interface AgentCard {
+    name: string;
+    endpoint: string;
+    capabilities: string[];
+    authentication?: string;
+    domains: string[];
+    protocol_versions: string[];
+}
+/** Full resolution response from the DNS of Money API. */
+export interface ResolutionResponse {
+    resolution_id: string;
+    alias_uri: string;
+    resolved_at: string;
+    ttl_seconds: number;
+    message_id?: string;
+    entity_id?: string;
+    entity?: Entity;
+    endpoints: Endpoint[];
+    compliance?: Compliance;
+    iso20022_hint?: Record<string, unknown>;
+    identity?: Identity;
+    rail_score?: Record<string, unknown>;
+    resolution_status: string;
+    caller_tier?: number;
+    resolved_from: string;
+    cache_hit: boolean;
+    agent_commerce?: Record<string, unknown>;
+    warnings: string[];
+}
+/** Response from a successful alias registration. */
+export interface RegistrationResponse {
+    alias_name: string;
+    registration_number?: number;
+    anchor_status?: string;
+    proof?: Record<string, unknown>;
+    created_at?: string;
+}
+/** Preview of where a payment would go (dry-run, no execution). */
+export interface SendPreview {
+    alias: string;
+    resolved: boolean;
+    destination_address?: string;
+    display_name?: string;
+    rail?: string;
+    currency: string;
+    fee_estimate?: string;
+    identity?: Record<string, unknown>;
+}
+/** Result of a send-to-alias payment execution. */
+export interface SendResult {
+    transaction_id: string;
+    status: string;
+    alias: string;
+    amount: number;
+    currency: string;
+    rail: string;
+    tx_hash?: string;
+    settle_time_seconds?: number;
+    memo?: string;
+    created_at?: string;
+}
+/** Optional parameters for a send-to-alias payment. */
+export interface SendOptions {
+    currency?: string;
+    memo?: string;
+    /** Unique key to prevent double-send. Auto-generated if not provided. */
+    idempotencyKey?: string;
+}

package/dist/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "dnsofmoney",
+  "version": "0.4.0",
+  "description": "DNS of Money — pay: alias resolution + send SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "test": "echo 'Tests coming soon'"
+  },
+  "keywords": ["payments", "dns", "fintech", "xrpl", "iso20022", "fas-1"],
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dnsofmoney/dns-of-money"
+  },
+  "homepage": "https://dnsofmoney.com"
+}