@defuse-protocol/nearintents-mpp-sdk 0.0.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Iker Alustiza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,235 @@
+# nearintents-mpp-sdk
+
+Reference implementation of the **`nearintents` payment method** for
+[MPP (Machine Payments Protocol)](https://mpp.dev) enabling cross-chain HTTP 402
+payments settled by [NEAR Intents](https://near-intents.org): clients pay on
+any supported chain, merchants receive an exact amount on theirs. Extends
+[`mppx`](https://github.com/wevm/mppx). The original spec this implementation is based on is found at [Tempo's MPP specs repository](https://github.com/tempoxyz/mpp-specs/blob/main/specs/methods/nearintents/draft-nearintents-charge-00.md).
+
+## Usage
+
+Server (see [`src/server/Charge.ts`](src/server/Charge.ts) for all options):
+
+```ts
+import { Mppx } from 'mppx/server'
+import { nearintents } from '@defuse-protocol/nearintents-mpp-sdk/server'
+
+const mppx = Mppx.create({
+  secretKey: process.env.MPP_SECRET_KEY!,
+  methods: [
+    nearintents.charge({
+      originAsset: 'eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+      destinationAsset: 'near:mainnet/nep141:1720…33a1',
+      destinationRecipient: 'merchant.near',
+      refundTo: '0x2527…C317', // merchant origin-chain refund address
+      amountOut: '1000000', // exact amount the merchant receives (EXACT_OUTPUT)
+      oneClick: { jwt: process.env.ONE_CLICK_JWT },
+      // production: store: Store.redis(client) — replay protection needs an atomic store
+    }),
+  ],
+})
+```
+
+Client (`policy` as safety surface, the client pays before delivery):
+
+```ts
+import { Mppx } from 'mppx/client'
+import { nearintents } from '@defuse-protocol/nearintents-mpp-sdk/client'
+
+const mppx = Mppx.create({
+  methods: [
+    nearintents.charge({
+      walletClient, // viem WalletClient (+ public actions) for eip155 origins
+      policy: {
+        allowedOriginNetworks: ['eip155:42161'],
+        maxAmountIn: { 'eip155:42161/erc20:0xaf88…5831': '5000000' },
+      },
+    }),
+  ],
+})
+const response = await mppx.fetch('https://api.example.com/paid-resource')
+```
+
+Non-EVM origins (BTC, Solana, …) pay via the `sendDeposit` callback or present
+an already-broadcast tx hash as `context.hash`.
+
+A `policy` is **strongly recommended for any autonomous payer.** The client
+always schema-validates the challenge and refuses to pay past `expires`, but
+the *value* checks — allowed origin networks/assets, per-asset `maxAmountIn`
+caps, and the expected destination leg — only run when a `policy` is
+configured. Without one, the client will pay any authentic challenge the
+server presents; the policy is the client's safety surface since it pays
+before delivery.
+
+## How it works
+
+1. The server answers an unpaid request with `402` + `WWW-Authenticate:
+   Payment` whose `request` carries a unique, single-use **1Click deposit
+   address** as `recipient`, the origin-chain leg the client pays (`amount`,
+   `currency`), and the merchant's destination leg in `methodDetails`.
+2. The client pays the source asset on its origin chain and retries with the
+   confirmed transaction hash as a `{type: "hash"}` credential.
+3. The server verifies the deposit via the 1Click status endpoint, drives the
+   cross-chain swap to `SUCCESS`, and returns the resource with a
+   `Payment-Receipt` carrying `challengeId`, `originTxHash`, and the
+   destination-chain delivery hash.
+
+Quotes use `EXACT_OUTPUT`, so the merchant receives a deterministic amount of
+its chosen asset on its chosen chain. 
+
+Note that settlement is not trustless: deposits are custodied by the NEAR Intents 
+settlement system for the duration of the swap, with automatic refunds 
+to `methodDetails.refundTo` on every non-success outcome. 
+See the spec's Trust Model section.
+
+## Demo
+
+[`demo/`](demo/README.md) is a browser storefront that runs the real client in
+the page: unlock a paid endpoint with an injected EVM wallet on Arbitrum, or
+from any Bitcoin wallet by pasting the deposit txid. `pnpm demo:server` +
+`pnpm demo:app` (dev), or `pnpm demo:build && pnpm demo:server` (same-origin
+production shape; the root [`Dockerfile`](Dockerfile) packages it).
+
+## Examples
+
+[`examples/server.ts`](examples/server.ts) is a two-route merchant (Arbitrum
+USDC origin with a 5-minute window, native BTC origin with a 45-minute
+window); [`examples/client.ts`](examples/client.ts) pays it — or dry-runs,
+printing the decoded challenge, when no key/hash is provided.
+
+```sh
+cp .env.example .env            # add ONE_CLICK_JWT (and merchant addresses)
+pnpm example:server             # http://localhost:8402
+pnpm example:client             # dry run: shows what /premium asks for
+pnpm example:client http://localhost:8402/premium-btc
+```
+
+To execute a real payment (real funds!): set `PRIVATE_KEY` to a funded
+Arbitrum account and run `pnpm example:client`, or send the deposit yourself
+and re-run with `DEPOSIT_TX_HASH=0x…`. The client refuses anything beyond its
+configured `policy.maxAmountIn` caps.
+
+## Operational notes
+
+- **Refunds.** `methodDetails.refundTo` is a **merchant-configured** address
+  on the origin chain (the server cannot know the payer before payment).
+  Every non-success terminal refunds the deposit there; payers recover
+  off-band per the merchant's terms. Disclose this in your terms of service.
+- **Per-origin expiry.** Size `expiresWindow` (and the mppx route `expires`)
+  to the origin chain: minutes for fast chains, 45–60 minutes for Bitcoin.
+  The example server creates the route handler per request so the absolute
+  mppx `expires` becomes a rolling window. **`charge({ expiresWindow })` MUST
+  equal the `expires` you pass to `mppx.charge({ expires })`** — mppx computes
+  the challenge `expires` before this method can read it, so the coupling is
+  manual. Setting the route `expires` *larger* than `expiresWindow` can make a
+  challenge advertise an `expires` past the quote deadline; a client depositing
+  just before it is refunded instead of swapped (recoverable, but wasteful).
+  The example/demo servers keep the two in lock-step.
+- **Under-deposits are terminal.** If a deposit lands below
+  `methodDetails.minAmountIn`, 1Click reports `INCOMPLETE_DEPOSIT`, which this
+  method treats as a terminal outcome (per spec §Settlement): the deposit is
+  refunded to `refundTo`, the credential is consumed, and the client recovers
+  with a fresh challenge — it does **not** hold the quote open waiting for a
+  top-up (that is async-delivery territory, out of scope here). Backend
+  aggregation of multiple deposits that reach `SUCCESS` *is* honored: any one
+  of the observed origin-chain tx hashes is accepted as the credential.
+- **Slow settlements.** `verify` holds the connection at most
+  `settlementTimeout` seconds, then returns **504** with a problem body —
+  the credential is *not* consumed and the client re-presents the same
+  credential later (the deposit keeps settling in the background). Backend
+  unavailability returns **503**, never `verification-failed`. Long-running
+  origins can layer a `202 Accepted`/webhook pattern on top; that is out of
+  scope for this package.
+- **After a failed settlement** the immediate 402 echoes the spent challenge
+  (mppx computes the retry challenge before `verify` runs); the client's next
+  request receives a fresh quote. Conformant clients re-request on 402.
+- **Trust model.** Settlement is not trustless: for the duration of the swap
+  the deposit is custodied by the NEAR Intents settlement system
+  (`methodDetails.settlementBackend: "near-intents"`), which either delivers
+  the destination asset to the merchant or refunds the deposit. Comparable to
+  entrusting a payment processor with a transfer; agents applying per-method
+  risk policies can key off the `method` and `settlementBackend` fields.  
+
+## Observability
+
+The library never logs on its own. Merchant-side visibility comes from two
+layers:
+
+```ts
+const method = nearintents.charge({
+  // in-flight settlement progress (structured events → your logger):
+  // quote.minted / quote.reused / deposit.submitted / settlement.status /
+  // settlement.terminal / settlement.suspended / receipt.issued
+  onEvent: (event) => logger.info(event),
+  /* … */
+})
+
+const mppx = Mppx.create({ secretKey, methods: [method] })
+// outcome-level events, from mppx itself:
+mppx.on('payment.success', ({ receipt }) => logger.info(receipt))
+mppx.on('payment.failed', ({ error }) => logger.warn(error.type, error.message))
+```
+
+`settlement.suspended` (backend unavailable / settlement timeout) means the
+credential was **not** consumed and the client will re-present it. The
+example and demo servers wire `onEvent` to the console, so `pnpm
+example:server` shows each payment progressing live. Everything the events
+carry (deposit addresses, tx hashes) is public on-chain data.
+
+## Advanced: the settlement core
+
+The spec's server steps 7 ("verify deposit") and 8 ("submit + await swap
+finality") are implemented *inside* the method's `verify()`. Merchants never
+call them directly, and the safety rails (atomic in-flight hash claim,
+consume-on-terminal, release-on-5xx) live in that sequence. This package uses
+**status observation** (spec §Verification step 3, second mode): 1Click
+detecting a qualifying deposit *is* the origin-chain verification, and on
+`SUCCESS` the presented `payload.hash` must appear among the backend's
+observed `originChainTxHashes`. Direct per-chain RPC verification is a
+possible future hardening hook, deliberately not part of v1.
+
+For advanced integrations (custom settlement flows, background workers, ops
+tooling), the underlying 1Click client is exported as the `OneClick`
+namespace: `quote`, `submitDeposit`, `getStatus`, `pollToTerminal`,
+`matchesOriginTx`, `destinationTxHash`, `terminalError`, plus the CAIP-19 ↔
+1Click asset mapping (`createAssetMap`). If you drive settlement yourself you
+also own replay protection.
+
+## Spec
+
+The normative wire contract is
+[`docs/spec/draft-nearintents-charge-00.md`](docs/spec/draft-nearintents-charge-00.md)
+(registered in
+[`tempoxyz/mpp-specs`](https://github.com/tempoxyz/mpp-specs) under
+`specs/methods/nearintents/`). Conformance vectors in
+[`test/vectors.test.ts`](test/vectors.test.ts) are generated through mppx
+primitives from the spec's examples.
+
+## Development
+
+```sh
+npx pnpm@11 install   # pnpm pinned via packageManager
+pnpm check            # typecheck + lint + tests
+```
+
+Tests are **mock-only** (in-process mock 1Click server in
+[`test/OneClickMock.ts`](test/OneClickMock.ts)); the suite never calls live
+1Click.
+
+Note: `mppx` **0.8.6 or later** is required — it ships the upstream
+receipt-extensibility fix ([wevm/mppx#612](https://github.com/wevm/mppx/pull/612))
+that lets the method-specific receipt fields (`challengeId`, `originTxHash`,
+`destinationNetwork`) survive the `Payment-Receipt` codec; earlier releases
+strip them. mppx is an exact-pinned peer dependency while it is pre-1.0.
+
+### Releasing
+
+Releases are automated with [changesets](https://github.com/changesets/changesets):
+PRs that change published behavior include one (`pnpm changeset`). On merge to
+`main`, the release workflow maintains a "Version Packages" PR; merging *that*
+builds and publishes to npm with
+[provenance](https://docs.npmjs.com/generating-provenance-statements).
+
+## License
+
+[MIT](LICENSE)

package/dist/Errors.d.ts

@@ -0,0 +1,57 @@
+import { Errors } from 'mppx';
+/**
+ * The deposit was verified but the cross-chain swap did not complete
+ * (1Click terminal status `FAILED` or `REFUNDED`). The deposit is refunded to
+ * `methodDetails.refundTo`; the client recovers with a fresh challenge.
+ *
+ * Additional error code registered by the `nearintents` spec (§Error Codes).
+ */
+export declare class SettlementFailedError extends Errors.PaymentError {
+    readonly name = "SettlementFailedError";
+    readonly title = "Settlement Failed";
+    readonly status: number;
+    readonly type = "https://paymentauth.org/problems/settlement-failed";
+    constructor(options?: SettlementFailedError.Options);
+}
+export declare namespace SettlementFailedError {
+    type Options = {
+        /** Reason settlement failed (e.g. the 1Click refund reason). */
+        reason?: string | undefined;
+    };
+}
+/**
+ * The 1Click backend was unreachable during a required check. Per the spec
+ * (§Verification), this MUST surface as an HTTP 5xx — never as
+ * `verification-failed` — and the credential MUST NOT be settled or consumed.
+ * The client retries the same credential once the backend recovers.
+ */
+export declare class SettlementUnavailableError extends Errors.PaymentError {
+    readonly name = "SettlementUnavailableError";
+    readonly title = "Settlement Backend Unavailable";
+    readonly status: number;
+    readonly type = "https://paymentauth.org/problems/server-error";
+    constructor(options?: SettlementUnavailableError.Options);
+}
+export declare namespace SettlementUnavailableError {
+    type Options = {
+        reason?: string | undefined;
+    };
+}
+/**
+ * Settlement did not reach a terminal state within the server's time budget.
+ * The swap may still complete; the credential is NOT consumed, so the client
+ * can re-present the same credential later (or wait for the refund path).
+ */
+export declare class SettlementTimeoutError extends Errors.PaymentError {
+    readonly name = "SettlementTimeoutError";
+    readonly title = "Settlement Timeout";
+    readonly status: number;
+    readonly type = "https://paymentauth.org/problems/server-error";
+    constructor(options?: SettlementTimeoutError.Options);
+}
+export declare namespace SettlementTimeoutError {
+    type Options = {
+        timeoutMs?: number | undefined;
+    };
+}
+//# sourceMappingURL=Errors.d.ts.map

package/dist/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../src/Errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,MAAM,CAAC,YAAY;IAC5D,SAAkB,IAAI,2BAA0B;IAChD,QAAQ,CAAC,KAAK,uBAAsB;IACpC,SAAkB,MAAM,EAAE,MAAM,CAAM;IACtC,QAAQ,CAAC,IAAI,wDAAuD;gBAExD,OAAO,GAAE,qBAAqB,CAAC,OAAY;CAQxD;AAED,MAAM,CAAC,OAAO,WAAW,qBAAqB,CAAC;IAC7C,KAAK,OAAO,GAAG;QACb,gEAAgE;QAChE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAC5B,CAAA;CACF;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,SAAQ,MAAM,CAAC,YAAY;IACjE,SAAkB,IAAI,gCAA+B;IACrD,QAAQ,CAAC,KAAK,oCAAmC;IACjD,SAAkB,MAAM,EAAE,MAAM,CAAM;IACtC,QAAQ,CAAC,IAAI,mDAAkD;gBAEnD,OAAO,GAAE,0BAA0B,CAAC,OAAY;CAQ7D;AAED,MAAM,CAAC,OAAO,WAAW,0BAA0B,CAAC;IAClD,KAAK,OAAO,GAAG;QACb,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAC5B,CAAA;CACF;AAED;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,MAAM,CAAC,YAAY;IAC7D,SAAkB,IAAI,4BAA2B;IACjD,QAAQ,CAAC,KAAK,wBAAuB;IACrC,SAAkB,MAAM,EAAE,MAAM,CAAM;IACtC,QAAQ,CAAC,IAAI,mDAAkD;gBAEnD,OAAO,GAAE,sBAAsB,CAAC,OAAY;CAQzD;AAED,MAAM,CAAC,OAAO,WAAW,sBAAsB,CAAC;IAC9C,KAAK,OAAO,GAAG;QACb,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAC/B,CAAA;CACF"}

package/dist/Errors.js

@@ -0,0 +1,54 @@
+import { Errors } from 'mppx';
+/**
+ * The deposit was verified but the cross-chain swap did not complete
+ * (1Click terminal status `FAILED` or `REFUNDED`). The deposit is refunded to
+ * `methodDetails.refundTo`; the client recovers with a fresh challenge.
+ *
+ * Additional error code registered by the `nearintents` spec (§Error Codes).
+ */
+export class SettlementFailedError extends Errors.PaymentError {
+    name = 'SettlementFailedError';
+    title = 'Settlement Failed';
+    status = 402;
+    type = 'https://paymentauth.org/problems/settlement-failed';
+    constructor(options = {}) {
+        const { reason } = options;
+        super(reason
+            ? `Settlement failed: ${reason}.`
+            : 'Settlement failed: the cross-chain swap did not complete; the deposit is refunded to the refund address.');
+    }
+}
+/**
+ * The 1Click backend was unreachable during a required check. Per the spec
+ * (§Verification), this MUST surface as an HTTP 5xx — never as
+ * `verification-failed` — and the credential MUST NOT be settled or consumed.
+ * The client retries the same credential once the backend recovers.
+ */
+export class SettlementUnavailableError extends Errors.PaymentError {
+    name = 'SettlementUnavailableError';
+    title = 'Settlement Backend Unavailable';
+    status = 503;
+    type = 'https://paymentauth.org/problems/server-error';
+    constructor(options = {}) {
+        const { reason } = options;
+        super(reason
+            ? `Settlement backend unavailable: ${reason}.`
+            : 'Settlement backend unavailable; retry the same credential later.');
+    }
+}
+/**
+ * Settlement did not reach a terminal state within the server's time budget.
+ * The swap may still complete; the credential is NOT consumed, so the client
+ * can re-present the same credential later (or wait for the refund path).
+ */
+export class SettlementTimeoutError extends Errors.PaymentError {
+    name = 'SettlementTimeoutError';
+    title = 'Settlement Timeout';
+    status = 504;
+    type = 'https://paymentauth.org/problems/server-error';
+    constructor(options = {}) {
+        const { timeoutMs } = options;
+        super(`Settlement did not reach a terminal state${timeoutMs !== undefined ? ` within ${timeoutMs}ms` : ''}; re-present the same credential later.`);
+    }
+}
+//# sourceMappingURL=Errors.js.map

package/dist/Errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.js","sourceRoot":"","sources":["../src/Errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B;;;;;;GAMG;AACH,MAAM,OAAO,qBAAsB,SAAQ,MAAM,CAAC,YAAY;IAC1C,IAAI,GAAG,uBAAuB,CAAA;IACvC,KAAK,GAAG,mBAAmB,CAAA;IAClB,MAAM,GAAW,GAAG,CAAA;IAC7B,IAAI,GAAG,oDAAoD,CAAA;IAEpE,YAAY,UAAyC,EAAE;QACrD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAA;QAC1B,KAAK,CACH,MAAM;YACJ,CAAC,CAAC,sBAAsB,MAAM,GAAG;YACjC,CAAC,CAAC,0GAA0G,CAC/G,CAAA;IACH,CAAC;CACF;AASD;;;;;GAKG;AACH,MAAM,OAAO,0BAA2B,SAAQ,MAAM,CAAC,YAAY;IAC/C,IAAI,GAAG,4BAA4B,CAAA;IAC5C,KAAK,GAAG,gCAAgC,CAAA;IAC/B,MAAM,GAAW,GAAG,CAAA;IAC7B,IAAI,GAAG,+CAA+C,CAAA;IAE/D,YAAY,UAA8C,EAAE;QAC1D,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAA;QAC1B,KAAK,CACH,MAAM;YACJ,CAAC,CAAC,mCAAmC,MAAM,GAAG;YAC9C,CAAC,CAAC,kEAAkE,CACvE,CAAA;IACH,CAAC;CACF;AAQD;;;;GAIG;AACH,MAAM,OAAO,sBAAuB,SAAQ,MAAM,CAAC,YAAY;IAC3C,IAAI,GAAG,wBAAwB,CAAA;IACxC,KAAK,GAAG,oBAAoB,CAAA;IACnB,MAAM,GAAW,GAAG,CAAA;IAC7B,IAAI,GAAG,+CAA+C,CAAA;IAE/D,YAAY,UAA0C,EAAE;QACtD,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;QAC7B,KAAK,CACH,4CACE,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,SAAS,IAAI,CAAC,CAAC,CAAC,EACvD,yCAAyC,CAC1C,CAAA;IACH,CAAC;CACF"}

package/dist/Methods.d.ts

@@ -0,0 +1,44 @@
+/**
+ * NEAR Intents charge method — shared schema used by both server and client.
+ *
+ * The challenge `request` carries the origin-chain leg the client must pay
+ * (`recipient` is a unique single-use 1Click deposit address) plus the
+ * merchant's destination leg in `methodDetails`. The credential payload is
+ * the client's confirmed origin-chain deposit transaction hash (push mode).
+ *
+ * Spec: docs/spec/draft-nearintents-charge-00.md
+ */
+export declare const charge: {
+    readonly name: "nearintents";
+    readonly intent: "charge";
+    readonly schema: {
+        readonly credential: {
+            readonly payload: import("zod/mini").ZodMiniObject<{
+                type: import("zod/mini").ZodMiniLiteral<"hash">;
+                hash: import("zod/mini").ZodMiniString<string>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly request: import("zod/mini").ZodMiniObject<{
+            amount: import("zod/mini").ZodMiniString<string>;
+            currency: import("zod/mini").ZodMiniString<string>;
+            recipient: import("zod/mini").ZodMiniString<string>;
+            description: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            externalId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            methodDetails: import("zod/mini").ZodMiniObject<{
+                originNetwork: import("zod/mini").ZodMiniString<string>;
+                destinationNetwork: import("zod/mini").ZodMiniString<string>;
+                destinationAsset: import("zod/mini").ZodMiniString<string>;
+                destinationRecipient: import("zod/mini").ZodMiniString<string>;
+                amountOut: import("zod/mini").ZodMiniString<string>;
+                minAmountIn: import("zod/mini").ZodMiniString<string>;
+                depositMemo: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniString<string>>>;
+                slippageTolerance: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+                timeEstimate: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+                refundTo: import("zod/mini").ZodMiniString<string>;
+                settlementBackend: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniLiteral<"near-intents">>;
+                credentialTypes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniLiteral<"hash">>>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+//# sourceMappingURL=Methods.d.ts.map

package/dist/Methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Methods.d.ts","sourceRoot":"","sources":["../src/Methods.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASjB,CAAA"}

package/dist/Methods.js

@@ -0,0 +1,23 @@
+import { Method } from 'mppx';
+import * as Types from './Types.js';
+/**
+ * NEAR Intents charge method — shared schema used by both server and client.
+ *
+ * The challenge `request` carries the origin-chain leg the client must pay
+ * (`recipient` is a unique single-use 1Click deposit address) plus the
+ * merchant's destination leg in `methodDetails`. The credential payload is
+ * the client's confirmed origin-chain deposit transaction hash (push mode).
+ *
+ * Spec: docs/spec/draft-nearintents-charge-00.md
+ */
+export const charge = Method.from({
+    name: Types.paymentMethod,
+    intent: Types.chargeIntent,
+    schema: {
+        credential: {
+            payload: Types.HashPayloadSchema,
+        },
+        request: Types.ChargeRequestSchema,
+    },
+});
+//# sourceMappingURL=Methods.js.map

package/dist/Methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Methods.js","sourceRoot":"","sources":["../src/Methods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC;IAChC,IAAI,EAAE,KAAK,CAAC,aAAa;IACzB,MAAM,EAAE,KAAK,CAAC,YAAY;IAC1B,MAAM,EAAE;QACN,UAAU,EAAE;YACV,OAAO,EAAE,KAAK,CAAC,iBAAiB;SACjC;QACD,OAAO,EAAE,KAAK,CAAC,mBAAmB;KACnC;CACF,CAAC,CAAA"}

package/dist/Types.d.ts

@@ -0,0 +1,125 @@
+import { Receipt, z } from 'mppx';
+/** Payment method name for `nearintents` challenges. */
+export declare const paymentMethod: "nearintents";
+/** Payment intent name for one-time cross-chain charges. */
+export declare const chargeIntent: "charge";
+/** `methodDetails.settlementBackend` disclosure value for this method. */
+export declare const settlementBackend: "near-intents";
+/** Credential types supported by this method (spec: the only valid value is "hash"). */
+export declare const credentialTypes: readonly ["hash"];
+/** Parsed CAIP-2 chain identifier. */
+export type Caip2 = {
+    namespace: string;
+    reference: string;
+};
+/** Parsed CAIP-19 asset identifier. */
+export type Caip19 = {
+    chain: Caip2;
+    assetNamespace: string;
+    assetReference: string;
+};
+/** Parses a CAIP-2 chain identifier (e.g. `eip155:42161`). Throws on invalid input. */
+export declare function parseCaip2(id: string): Caip2;
+/** Parses a CAIP-19 asset identifier (e.g. `eip155:42161/erc20:0xaf88…`). Throws on invalid input. */
+export declare function parseCaip19(id: string): Caip19;
+/** Returns the CAIP-2 chain component of a CAIP-19 asset identifier. */
+export declare function chainOf(assetId: string): string;
+/** Compares two CAIP-2 identifiers by parsed components. */
+export declare function networkEqual(a: string, b: string): boolean;
+/**
+ * Compares two CAIP-19 identifiers by parsed components.
+ *
+ * The asset reference is compared in the chain's canonical form: for `eip155`
+ * chains (hex addresses) the comparison is case-insensitive; for all other
+ * chains it is exact (e.g. base58 references are case-sensitive).
+ */
+export declare function assetEqual(a: string, b: string): boolean;
+/** Formats a payer identity as a `did:pkh` source (CAIP-2 network + payer address). */
+export declare function toSource(parameters: {
+    network: string;
+    address: string;
+}): string;
+/** Base-unit integer amount (e.g. "1000000" for 1 USDC at 6 decimals). */
+export declare function atomicAmount(): z.ZodMiniString<string>;
+/** CAIP-2 chain identifier string. */
+export declare function caip2(): z.ZodMiniString<string>;
+/** CAIP-19 asset identifier string. */
+export declare function caip19(): z.ZodMiniString<string>;
+/** NEAR Intents-specific `methodDetails` for the charge request (spec §Method Details). */
+export declare const MethodDetailsSchema: z.ZodMiniObject<{
+    originNetwork: z.ZodMiniString<string>;
+    destinationNetwork: z.ZodMiniString<string>;
+    destinationAsset: z.ZodMiniString<string>;
+    destinationRecipient: z.ZodMiniString<string>;
+    amountOut: z.ZodMiniString<string>;
+    minAmountIn: z.ZodMiniString<string>;
+    depositMemo: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    slippageTolerance: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    timeEstimate: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    refundTo: z.ZodMiniString<string>;
+    settlementBackend: z.ZodMiniOptional<z.ZodMiniLiteral<"near-intents">>;
+    credentialTypes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniLiteral<"hash">>>;
+}, z.core.$strip>;
+export type MethodDetails = z.infer<typeof MethodDetailsSchema>;
+/**
+ * Canonical `nearintents` charge request (the decoded challenge `request` parameter).
+ *
+ * The standard fields describe the payment the client makes on the origin
+ * chain (`recipient` is the single-use 1Click deposit address); the merchant's
+ * destination leg is carried in `methodDetails`.
+ */
+export declare const ChargeRequestSchema: z.ZodMiniObject<{
+    amount: z.ZodMiniString<string>;
+    currency: z.ZodMiniString<string>;
+    recipient: z.ZodMiniString<string>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    methodDetails: z.ZodMiniObject<{
+        originNetwork: z.ZodMiniString<string>;
+        destinationNetwork: z.ZodMiniString<string>;
+        destinationAsset: z.ZodMiniString<string>;
+        destinationRecipient: z.ZodMiniString<string>;
+        amountOut: z.ZodMiniString<string>;
+        minAmountIn: z.ZodMiniString<string>;
+        depositMemo: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+        slippageTolerance: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        timeEstimate: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        refundTo: z.ZodMiniString<string>;
+        settlementBackend: z.ZodMiniOptional<z.ZodMiniLiteral<"near-intents">>;
+        credentialTypes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniLiteral<"hash">>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ChargeRequest = z.infer<typeof ChargeRequestSchema>;
+/** Push-mode credential payload: the confirmed origin-chain deposit transaction hash. */
+export declare const HashPayloadSchema: z.ZodMiniObject<{
+    type: z.ZodMiniLiteral<"hash">;
+    hash: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type HashPayload = z.infer<typeof HashPayloadSchema>;
+/**
+ * `nearintents` Payment-Receipt payload (spec §Receipt).
+ *
+ * Extends the mppx base receipt with the method's REQUIRED `challengeId` and
+ * `originTxHash` fields (and optional `destinationNetwork`). `reference` is
+ * the destination-chain transaction hash of the merchant delivery.
+ */
+export type NearIntentsReceipt = Receipt.Receipt & {
+    method: typeof paymentMethod;
+    /** The `id` from the original challenge. */
+    challengeId: string;
+    /** The client's origin-chain deposit transaction hash (`payload.hash`). */
+    originTxHash: string;
+    /** CAIP-2 identifier of the chain where the merchant was paid. */
+    destinationNetwork?: string | undefined;
+};
+/** Builds a spec-conformant `nearintents` receipt through `Receipt.from`. */
+export declare function toReceipt(parameters: {
+    challengeId: string;
+    /** Destination-chain transaction hash of the merchant delivery. */
+    reference: string;
+    originTxHash: string;
+    destinationNetwork?: string | undefined;
+    externalId?: string | undefined;
+    timestamp?: string | undefined;
+}): NearIntentsReceipt;
+//# sourceMappingURL=Types.d.ts.map

package/dist/Types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.d.ts","sourceRoot":"","sources":["../src/Types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,MAAM,CAAA;AAEjC,wDAAwD;AACxD,eAAO,MAAM,aAAa,EAAG,aAAsB,CAAA;AAEnD,4DAA4D;AAC5D,eAAO,MAAM,YAAY,EAAG,QAAiB,CAAA;AAE7C,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,EAAG,cAAuB,CAAA;AAExD,wFAAwF;AACxF,eAAO,MAAM,eAAe,mBAAoB,CAAA;AAehD,sCAAsC;AACtC,MAAM,MAAM,KAAK,GAAG;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,uCAAuC;AACvC,MAAM,MAAM,MAAM,GAAG;IACnB,KAAK,EAAE,KAAK,CAAA;IACZ,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAI5C;AAED,sGAAsG;AACtG,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAG/C;AAeD,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAU1D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAexD;AAED,uFAAuF;AACvF,wBAAgB,QAAQ,CAAC,UAAU,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEjF;AAMD,0EAA0E;AAC1E,wBAAgB,YAAY,4BAE3B;AAED,sCAAsC;AACtC,wBAAgB,KAAK,4BAEpB;AAED,uCAAuC;AACvC,wBAAgB,MAAM,4BAErB;AAED,2FAA2F;AAC3F,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;iBAyB9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;iBA4B7B,CAAA;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,yFAAyF;AACzF,eAAO,MAAM,iBAAiB;;;iBAI5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAM3D;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,OAAO,GAAG;IACjD,MAAM,EAAE,OAAO,aAAa,CAAA;IAC5B,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAA;IACpB,kEAAkE;IAClE,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACxC,CAAA;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,UAAU,EAAE;IACpC,WAAW,EAAE,MAAM,CAAA;IACnB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACvC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,GAAG,kBAAkB,CAYrB"}