xrpjson 0.1.0

package/dist/fp/factories/clawback.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Functional Clawback factory — frozen-object style.
+ *
+ * Reclaim issued tokens or MPTs from a holder's account. The submitter
+ * (`Account`) must be the issuer of the asset being clawed back. The
+ * `Amount` shape determines which ledger code path executes:
+ *
+ * - `IssuedCurrencyAmount` (`{ currency, issuer, value }`) — claws back
+ *   trust-line tokens. The `issuer` sub-field here names the **holder**
+ *   (XLS-39 §3.3.1, "the sub-field `issuer` within `Amount` represents
+ *   the token holder's address instead of the issuer's"). `Holder` MUST
+ *   be omitted.
+ * - `MPTAmount` (`{ mpt_issuance_id, value }`) — claws back MPTs.
+ *   `Holder` MUST be present and must be a valid XRPL account distinct
+ *   from `Account`.
+ *
+ * XRP can never be clawed back — XLS-39 explicitly forbids it ("This
+ * proposal deals only with issued assets. The proposed clawback support
+ * cannot be used to claw back XRP.").
+ *
+ * Validation happens at construction; there is no way to construct an
+ * invalid tx.
+ *
+ *   import { clawback } from 'xrplt/fp';
+ *   // IOU clawback — the holder is encoded inside Amount.issuer:
+ *   const iouTx = clawback({
+ *     Account:        'rIssuer…',
+ *     Amount: { currency: 'USD', issuer: 'rHolder…', value: '100' },
+ *   });
+ *   // MPT clawback — the holder is encoded in Holder:
+ *   const mptTx = clawback({
+ *     Account: 'rIssuer…',
+ *     Amount:  { mpt_issuance_id: '00000001', value: '100' },
+ *     Holder:  'rHolder…',
+ *   });
+ *   const j   = iouTx.toJSON();
+ *   const tx2 = iouTx.with({ 'Amount.value': '50' });   // type-safe via with()
+ *
+ * @see https://xrpl.org/docs/references/protocol/transactions/types/clawback
+ * @see https://github.com/XRPLF/xrpl.js/blob/main/packages/xrpl/src/models/transactions/clawback.ts
+ * @see XLS-39 §3.3.1 (https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0039-clawback)
+ *
+ * ## Divergences
+ *
+ * Compared with `src/transactions/clawback.ts`, this factory adds
+ * preclaim guards the class API skips. Each is cited to the canonical
+ * source.
+ *
+ * - **`Amount` is typed as `ClawbackAmount` (IOU or MPT only), not the
+ *   wider `Amount`.** The class declares `Amount: Amount` (which
+ *   includes the XRP drops `string` variant) and only filters strings
+ *   out via `typeof this.Amount === 'string'`. Typing the parameter
+ *   as `ClawbackAmount` makes the no-XRP rule a compile-time guarantee;
+ *   the runtime guard below also rejects malformed amounts.
+ *   - Source: xrpl-dev-portal clawback.md, `Amount` row, JSON Type
+ *     "Currency Amount" with `issuer` sub-field semantics, and the
+ *     document body: "When clawing back trust line tokens, you must
+ *     omit the `Holder` field. When clawing back MPTs, you must provide
+ *     the `Holder` field."
+ *   - Source: XLS-39 §1: "This proposal deals only with issued assets.
+ *     The proposed clawback support cannot be used to claw back XRP."
+ *
+ * - **`Account` must be a valid XRPL classic or X-address.** The class
+ *   inherits only `validateBaseTransaction`'s `isString(Account)` check
+ *   and never enforces address format.
+ *   - Source: xrpl-dev-portal clawback.md, `Account` row, Internal
+ *     Type = `AccountID`.
+ *
+ * - **`Account` and `Amount.issuer` must be distinct (IOU form).**
+ *   The class delegates to `isAmount` only; it never compares Account
+ *   to Amount.issuer. The ledger rejects this with `temBAD_AMOUNT`
+ *   ("the specified holder is the issuer" — docs use "holder" to mean
+ *   the counterparty, here `Amount.issuer`).
+ *   - Source: xrpl-dev-portal clawback.md "Error Cases" table,
+ *     `temBAD_AMOUNT` row.
+ *   - Source: xrpl.js `validateClawback` lines 54–56, message
+ *     `'Clawback: invalid holder Account'`.
+ *   - Source: XLS-39 §3.3.1 "Amount": "It is an error if the
+ *     counterparty listed in `Amount` is the same as the `Account`
+ *     issuing this transaction; the transaction should fail execution
+ *     with `temBAD_AMOUNT`."
+ *
+ * - **`Account` and `Holder` must be distinct (MPT form).** Same
+ *   rationale as above.
+ *   - Source: xrpl.js `validateClawback` lines 58–60, message
+ *     `'Clawback: invalid holder Account'`.
+ *   - Source: xrpl-dev-portal clawback.md, `Holder` row: "The holder
+ *     must have a non-zero balance of the MPT issuance indicated in
+ *     the `Amount` field" (you cannot claw back from yourself).
+ *
+ * - **Holder must be omitted for IOU clawback and required for MPT
+ *   clawback.** The class never enforces this asymmetry.
+ *   - Source: xrpl.js `validateClawback` lines 62–68, messages
+ *     `'Clawback: cannot have Holder for currency'` and
+ *     `'Clawback: missing Holder'`.
+ *   - Source: xrpl-dev-portal clawback.md body: "When clawing back
+ *     trust line tokens, you must omit the `Holder` field. When
+ *     clawing back MPTs, you must provide the `Holder` field."
+ *
+ * - **`Holder` must be a valid XRPL address** (MPT form). The class
+ *   delegates to `isAccount` which is fine — kept identical.
+ *   - Source: xrpl.js `validateClawback` line 48
+ *     (`validateOptionalField(tx, 'Holder', isAccount)`).
+ *
+ * - **IssuedCurrencyAmount sub-fields are validated** (3-char ASCII or
+ *   40-char hex `currency`; `issuer` must be a valid XRPL account;
+ *   `value` must be a positive non-zero base-10 integer string).
+ *   The class only checks shape via `isAmount`, which does not enforce
+ *   those sub-fields.
+ *   - Source: xrpl-dev-portal basic-data-types#specifying-currency-amounts.
+ *   - Source: xrpl-dev-portal clawback.md, `Amount` row, Description:
+ *     "The quantity in the `value` sub-field must not be zero."
+ *   - Source: XLS-39 §3.3.1 "Amount": "It returns `temBAD_AMOUNT` is
+ *     the amount is zero."
+ *
+ * - **MPTAmount sub-fields are validated** (`mpt_issuance_id` is a
+ *   24–48 char hex string; `value` is a positive non-zero base-10
+ *   integer string). The class only checks shape via `isAmount`.
+ *   - Source: xrpl-dev-portal clawback.md "Error Cases" table,
+ *     `temBAD_AMOUNT` row.
+ *   - Source: XLS-0033 Multi-Purpose Tokens
+ *     (`mpt_issuance_id` is a 192-bit uint hex-encoded).
+ *
+ * - **`Flags` is pass-through** (no per-tx flag defined by XLS-39).
+ *   The class never inspects Flags either. Per XLS-39 §3.3.1, "The
+ *   universal transaction flags that are applicable to all
+ *   transactions (e.g., `tfFullyCanonicalSig`) are valid. This
+ *   proposal introduces no new transaction-specific flags." We
+ *   therefore do not validate Flags beyond type acceptance.
+ *   - Source: XLS-39 §3.3.1 "Flags" row.
+ */
+import type { ClawbackAmount } from '../../types/amounts.js';
+import type { GlobalFlagsInterface } from '../../types/flags.js';
+export interface ClawbackProps {
+    /** The issuer submitting the clawback. Must equal the asset's issuer. */
+    Account: string;
+    /**
+     * The amount to claw back. For IOU clawbacks, the `issuer` sub-field
+     * names the **holder**. For MPT clawbacks, the holder is named in
+     * the separate `Holder` field.
+     */
+    Amount: ClawbackAmount;
+    /**
+     * Required for MPT clawbacks; MUST be omitted for IOU clawbacks.
+     * Must be distinct from `Account`.
+     */
+    Holder?: string | undefined;
+    /** No per-tx flags defined; pass-through (universal flags only). */
+    Flags?: number | GlobalFlagsInterface | undefined;
+    Fee?: string | undefined;
+    Sequence?: number | undefined;
+}
+export interface Clawback extends Readonly<ClawbackProps> {
+    readonly TransactionType: 'Clawback';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<ClawbackProps>): Clawback;
+}
+export declare function clawback(props: ClawbackProps): Clawback;
+//# sourceMappingURL=clawback.d.ts.map

package/dist/fp/factories/clawback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clawback.d.ts","sourceRoot":"","sources":["../../../src/fp/factories/clawback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkIG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAyBjE,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,MAAM,EAAE,cAAc,CAAC;IACvB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAAC;IAClD,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,QAAS,SAAQ,QAAQ,CAAC,aAAa,CAAC;IACvD,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC;IACrC,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC;CACnD;AAcD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,QAAQ,CAoIvD"}

package/dist/fp/factories/clawback.js

@@ -0,0 +1,111 @@
+import { isAccount, isHex, isIssuedCurrencyAmount, isMPTAmount, isString, } from '../../validation/helpers.js';
+import { ValidationError } from '../../errors.js';
+import { buildFrozenTx, mergeForWith, require } from '../shape.js';
+// ─── Spec constants ──────────────────────────────────────────────────
+// Currency codes are either 3 ASCII characters or 40 hex characters.
+const CURRENCY_ASCII_LENGTH = 3;
+const CURRENCY_HEX_LENGTH = 40;
+// MPT issuance IDs are 192-bit, hex-encoded (≤ 48 chars).
+// We accept 24..48 to leave slack for future widenings / leading-zero
+// encoders. Empty strings are rejected.
+const MPT_ISSUANCE_ID_MIN = 24;
+const MPT_ISSUANCE_ID_MAX = 48;
+// ─── Helpers ─────────────────────────────────────────────────────────
+/**
+ * XRPLNumber: a non-negative base-10 integer string. Matches the policy
+ * used across other factories (vaultClawback, ammClawback, vaultCreate).
+ */
+function isXrplNumber(value) {
+    return isString(value) && /^[0-9]+$/u.test(value);
+}
+// ─── Factory ─────────────────────────────────────────────────────────
+export function clawback(props) {
+    // ── Account ── required, valid XRPL classic / X-address.
+    require(props.Account, 'Clawback: Account is required', isAccount);
+    // ── Amount ── required, must be a ClawbackAmount (NOT XRP drops).
+    if (props.Amount === undefined) {
+        throw new ValidationError('Clawback: Amount is required');
+    }
+    if (!isIssuedCurrencyAmount(props.Amount) && !isMPTAmount(props.Amount)) {
+        throw new ValidationError('Clawback: Amount must be an IssuedCurrency or MPT, not XRP drops');
+    }
+    // ── IOU clawback path ───────────────────────────────────────────────
+    // xrpl-dev-portal clawback.md body: "When clawing back trust line
+    // tokens, you must omit the `Holder` field."
+    if (isIssuedCurrencyAmount(props.Amount)) {
+        if (props.Holder !== undefined) {
+            throw new ValidationError('Clawback: Holder must not be provided when clawing back a currency (IOU); the holder is named in Amount.issuer');
+        }
+        // currency: 3 ASCII or 40 hex characters.
+        const ccy = props.Amount.currency;
+        if (ccy.length !== CURRENCY_ASCII_LENGTH &&
+            ccy.length !== CURRENCY_HEX_LENGTH) {
+            throw new ValidationError(`Clawback: Amount.currency must be ${CURRENCY_ASCII_LENGTH} ASCII characters or ${CURRENCY_HEX_LENGTH} hex characters (actual: ${ccy.length})`);
+        }
+        if (ccy.length === CURRENCY_HEX_LENGTH && !isHex(ccy)) {
+            throw new ValidationError('Clawback: Amount.currency (40-char form) must be hex');
+        }
+        // issuer: must be a valid XRPL classic / X-address.
+        // XLS-39 §3.3.1: "the sub-field `issuer` within `Amount` represents
+        // the token holder's address instead of the issuer's."
+        if (!isAccount(props.Amount.issuer)) {
+            throw new ValidationError('Clawback: Amount.issuer must be a valid XRPL account address');
+        }
+        // Account != Amount.issuer (you cannot claw back from yourself).
+        if (props.Account === props.Amount.issuer) {
+            throw new ValidationError('Clawback: Account and Amount.issuer must be distinct (cannot claw back from yourself)');
+        }
+        // value: positive non-zero base-10 integer string.
+        if (!isXrplNumber(props.Amount.value)) {
+            throw new ValidationError('Clawback: Amount.value must be a non-negative base-10 integer string');
+        }
+        if (props.Amount.value === '0') {
+            throw new ValidationError('Clawback: Amount.value must not be zero (temBAD_AMOUNT)');
+        }
+        // ── MPT clawback path ─────────────────────────────────────────────
+        // xrpl-dev-portal clawback.md body: "When clawing back MPTs, you
+        // must provide the `Holder` field."
+    }
+    else {
+        // Holder is required for MPT clawback.
+        require(props.Holder, 'Clawback: Holder is required when clawing back an MPT', isAccount);
+        // mpt_issuance_id: 24..48 char hex string.
+        const mptid = props.Amount.mpt_issuance_id;
+        if (mptid.length < MPT_ISSUANCE_ID_MIN ||
+            mptid.length > MPT_ISSUANCE_ID_MAX ||
+            !isHex(mptid)) {
+            throw new ValidationError(`Clawback: Amount.mpt_issuance_id must be a ${MPT_ISSUANCE_ID_MIN}-${MPT_ISSUANCE_ID_MAX} character hex string`);
+        }
+        // value: positive non-zero base-10 integer string.
+        if (!isXrplNumber(props.Amount.value)) {
+            throw new ValidationError('Clawback: Amount.value must be a non-negative base-10 integer string');
+        }
+        if (props.Amount.value === '0') {
+            throw new ValidationError('Clawback: Amount.value must not be zero (temBAD_AMOUNT)');
+        }
+        // Account != Holder (you cannot claw back from yourself).
+        if (props.Account === props.Holder) {
+            throw new ValidationError('Clawback: Account and Holder must be distinct (cannot claw back from yourself)');
+        }
+    }
+    return buildFrozenTx('Clawback', props, {
+        validate() {
+            // Validated at construction.
+        },
+        toJSON() {
+            const json = {};
+            for (const k of Object.keys(this)) {
+                if (k === 'validate' || k === 'toJSON' || k === 'with')
+                    continue;
+                const v = this[k];
+                if (v !== undefined)
+                    json[k] = v;
+            }
+            return json;
+        },
+        with(overrides) {
+            return clawback(mergeForWith(this, overrides));
+        },
+    });
+}
+//# sourceMappingURL=clawback.js.map

package/dist/fp/factories/clawback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clawback.js","sourceRoot":"","sources":["../../../src/fp/factories/clawback.ts"],"names":[],"mappings":"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"}

package/dist/fp/factories/confidential-mpt-clawback.d.ts

@@ -0,0 +1,24 @@
+export interface ConfidentialMptClawbackProps {
+    /** Issuer AccountID — must be the issuer of `MPTokenIssuanceID`. */
+    Account: string;
+    /** AccountID — the holder being clawed back from. */
+    Holder: string;
+    /** UInt192 — MPT issuance identifier (48-char hex). */
+    MPTokenIssuanceID: string;
+    /** UInt64 — plaintext total to claw back. */
+    MPTAmount: string;
+    /** 64-byte Clawback sigma proof (128-char hex). */
+    ZKProof: string;
+    /** Fee in XRP (drops), base-10 integer string. */
+    Fee?: string | undefined;
+    /** Account sequence number. */
+    Sequence?: number | undefined;
+}
+export interface ConfidentialMptClawback extends Readonly<ConfidentialMptClawbackProps> {
+    readonly TransactionType: 'ConfidentialMPTClawback';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<ConfidentialMptClawbackProps>): ConfidentialMptClawback;
+}
+export declare function confidentialMptClawback(props: ConfidentialMptClawbackProps): ConfidentialMptClawback;
+//# sourceMappingURL=confidential-mpt-clawback.d.ts.map

package/dist/fp/factories/confidential-mpt-clawback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidential-mpt-clawback.d.ts","sourceRoot":"","sources":["../../../src/fp/factories/confidential-mpt-clawback.ts"],"names":[],"mappings":"AAoJA,MAAM,WAAW,4BAA4B;IAC3C,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,uBACf,SAAQ,QAAQ,CAAC,4BAA4B,CAAC;IAC9C,QAAQ,CAAC,eAAe,EAAE,yBAAyB,CAAC;IACpD,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,CACF,SAAS,EAAE,OAAO,CAAC,4BAA4B,CAAC,GAC/C,uBAAuB,CAAC;CAC5B;AAID,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,4BAA4B,GAClC,uBAAuB,CA0FzB"}

package/dist/fp/factories/confidential-mpt-clawback.js

@@ -0,0 +1,200 @@
+/**
+ * Functional ConfidentialMptClawback factory — frozen-object style.
+ *
+ * Issuer-only operation that burns the holder's entire confidential MPT
+ * balance (inbox + spending) and decrements both `OutstandingAmount` and
+ * `ConfidentialOutstandingAmount`. Unlike a normal `Clawback`, the issuer
+ * does not possess the holder's private ElGamal key, so it must supply a
+ * `MPTAmount` (the plaintext total) and a 64-byte compact Clawback sigma
+ * `ZKProof` proving that the on-ledger `IssuerEncryptedBalance` ciphertext
+ * encrypts that plaintext.
+ *
+ * Validation happens at construction; there is no way to construct an
+ * invalid tx. Compare to the class-based equivalent, which exposes a
+ * separate `.validate()` method you must remember to call.
+ *
+ *   import { confidentialMptClawback } from 'xrplt/fp';
+ *   const tx = confidentialMptClawback({ Account, Holder, MPTokenIssuanceID, MPTAmount, ZKProof });
+ *   const j = tx.toJSON();
+ *   const tx2 = tx.with({ Fee: '100' });
+ *
+ * Requires the `ConfidentialTransfer` amendment.
+ *
+ * @see https://xrpl.org/docs/references/protocol/transactions/types/confidentialmptclawback
+ * @see XLS-0096 §12 — Transaction: `ConfidentialMPTClawback`
+ *   (https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0096-confidential-mpt)
+ * @see xrpl.js — packages/xrpl/src/models/transactions/ConfidentialMPTClawback.ts
+ *
+ * ## Divergences
+ *
+ * Compared with `src/transactions/confidential-mpt-clawback.ts`, this
+ * factory adds guards the class skips — and is explicit about the
+ * canonical guards it cannot enforce in a zero-dependency package.
+ *
+ * - **`Account` is validated as a well-formed XRPL classic or X-address**
+ *   at construction time, with `isAccount` (`src/validation/helpers.ts`
+ *   lines 55–60). The class API delegates Account validation to its
+ *   `TokenTransaction` → `Transaction` parent chain via `super.validate()`;
+ *   failures therefore surface as a separate `.validate()` step rather
+ *   than at `new`. We re-implement the guard inline so a malformed Account
+ *   is caught at construction.
+ *   - Source: xrpl.js `validateBaseTransaction` (called transitively by
+ *     `validateConfidentialMPTClawback`).
+ *   - Source: xrpl-dev-portal `confidentialmptclawback.md` JSON-Type
+ *     column for `Account` (`ACCOUNTID`).
+ *
+ * - **`Holder` is validated as a well-formed XRPL classic or X-address**
+ *   at construction time. The class also checks this (`isAccount`), but
+ *   only inside `.validate()` rather than at `new`.
+ *   - Source: XLS-0096 §12.2 Fields table, Internal Type = `ACCOUNTID`
+ *     for `Holder`.
+ *   - Source: xrpl-dev-portal `confidentialmptclawback.md` Fields table
+ *     row for `Holder` (`ACCOUNTID`).
+ *
+ * - **`MPTAmount` is bounded to the canonical UInt64 range and rejected
+ *   for non-numeric / non-integer / out-of-range / "MAX+1" form.** The class
+ *   only checks `MPTAmount !== '0'`, allowing `'9223372036854775808'`
+ *   (one past max uint64) to pass through and rely on the ledger to reject
+ *   it. xrpl.js's `validateConfidentialMPTAmount` (called via
+ *   `validateConfidentialMPTClawback` with `allowZero = false`) enforces
+ *   both `INTEGER_SANITY_CHECK` (`/^[0-9]+$/u`) and
+ *   `MPTAmount <= MAX_MPT_AMOUNT (= 9223372036854775807)`.
+ *   - Source: xrpl.js `validateConfidentialMPTAmount`
+ *     (`packages/xrpl/src/models/transactions/common.ts` lines 596–608).
+ *   - Source: xrpl.js `MAX_MPT_AMOUNT` (same file, line 48).
+ *   - Source: xrpl.js test `ConfidentialMPTClawback.test.ts` cases
+ *     "throws w/ zero MPTAmount", "throws w/ out-of-range MPTAmount",
+ *     "throws w/ non-numeric MPTAmount".
+ *   - Source: XLS-0096 §12.4.1 item 5: `MPTAmount` is zero or exceeds
+ *     the maximum limits → `temBAD_AMOUNT`.
+ *
+ * - **`Account` must NOT equal `Holder` (KNOWN LIMITATION — NOT
+ *   IMPLEMENTED)**. XLS-0096 §12.4.1.3 mandates this as `temMALFORMED`:
+ *
+ *     > "The `Account` is attempting to claw back from itself
+ *     > (`Account` == `Holder`). (`temMALFORMED`)"
+ *
+ *   xrpl.js's `validateConfidentialMPTClawback` (lines 59–63) enforces
+ *   this via a direct string comparison.
+ *
+ *   The class API also skips this guard (it relies on `super.validate()`
+ *   which does not perform the self-clawback check), so this is not a
+ *   coverage regression relative to the class. Adding the guard is
+ *   trivially possible in this factory (a single string comparison), so
+ *   we **do** add it here — making the factory strictly more correct
+ *   than the class API.
+ *   - Source: XLS-0096 §12.4.1.3 Failure Conditions (Data Verification),
+ *     item 3: `temMALFORMED` when `Account` == `Holder`.
+ *   - Source: xrpl-dev-portal `confidentialmptclawback.md` Error Cases
+ *     table, `temMALFORMED` row, "The `Account` and the `Holder` are
+ *     the same".
+ *   - Source: xrpl.js `ConfidentialMPTClawback.ts` lines 59–63.
+ *
+ * - **`Account` must be the issuer of `MPTokenIssuanceID` (KNOWN
+ *   LIMITATION — NOT IMPLEMENTED)**. XLS-0096 §12.4.1.2 mandates this as
+ *   `temMALFORMED`:
+ *
+ *     > "The `Account` is not the issuer of the `MPTokenIssuanceID`.
+ *     > (`temMALFORMED`)"
+ *
+ *   xrpl.js's `validateConfidentialMPTClawback` (lines 53–57) enforces
+ *   this via its `isMPTIssuer(account, mptIssuanceID)` helper, which
+ *   calls `decodeAccountID` (base58 + double-SHA-256 checksum decoding of
+ *   the classic address) and compares the resulting 20-byte AccountID
+ *   against `mptIssuanceID.slice(8)` (the 40-hex-char issuer portion
+ *   after the 8-hex-char sequence prefix).
+ *
+ *   This factory cannot add this guard because the package is
+ *   **zero-dependency** — base58 + checksum decoding would require
+ *   either inlining a ~50-line codec or pulling in
+ *   `ripple-address-codec`, neither of which fits the scope of a
+ *   single-tx factory. The class API also skips this guard (it relies on
+ *   `super.validate()` which does not perform the issuer check), so this
+ *   is not a coverage regression relative to the class — but it remains
+ *   a documented gap that consumers must validate at the integration
+ *   layer (e.g. via the ledger submission result).
+ *   - Source: XLS-0096 §12.4.1.2 Failure Conditions (Data Verification),
+ *     item 2: `temMALFORMED` when `Account` is not the issuer.
+ *   - Source: xrpl-dev-portal `confidentialmptclawback.md` Error Cases
+ *     table, `temMALFORMED` row.
+ *   - Source: xrpl.js `ConfidentialMPTClawback.ts` lines 53–57
+ *     (`isMPTIssuer` guard) and `common.ts` lines 632–646
+ *     (`isMPTIssuer` implementation, including the base58 + AccountID
+ *     decoding dependency).
+ */
+import { isAccount, isHex, isString } from '../../validation/helpers.js';
+import { ValidationError } from '../../errors.js';
+import { buildFrozenTx, mergeForWith, require } from '../shape.js';
+// ─── Spec constants ──────────────────────────────────────────────────
+// `MPTokenIssuanceID` is a `UINT192`, hex-encoded to exactly 48 chars
+// (192 / 8 = 24 bytes = 48 hex chars). XLS-0096 §12.2; xrpl-dev-portal
+// `confidentialmptclawback.md` Fields table.
+const MPT_ISSUANCE_ID_HEX_LENGTH = 48;
+// ZKProof is a 64-byte blob, hex-encoded to 128 chars
+// (XLS-0096 §12.2: `BLOB`; xrpl.js `CONFIDENTIAL_CLAWBACK_PROOF_BYTES = 64`).
+const ZK_PROOF_HEX_LENGTH = 128;
+// `MPTAmount` is a `UINT64` per XLS-0096 §12.2. The maximum is 2^63 − 1
+// (signed integer range), matching xrpl.js's `MAX_MPT_AMOUNT`. Integer
+// form is required (no decimals, no leading sign) per xrpl.js
+// `INTEGER_SANITY_CHECK = /^[0-9]+$/u`.
+const MAX_MPT_AMOUNT = BigInt('9223372036854775807');
+const INTEGER_SANITY_CHECK = /^[0-9]+$/u;
+// ─── Factory ─────────────────────────────────────────────────────────
+export function confidentialMptClawback(props) {
+    // ── Account ── required, must be a valid XRPL classic/X-address.
+    require(props.Account, 'ConfidentialMPTClawback: Account is required', isAccount);
+    // ── Holder ── required, must be a valid XRPL classic/X-address.
+    require(props.Holder, 'ConfidentialMPTClawback: Holder is required', isAccount);
+    // ── MPTokenIssuanceID ── required, exactly 48-char hex (UINT192).
+    if (!isString(props.MPTokenIssuanceID) ||
+        !isHex(props.MPTokenIssuanceID) ||
+        props.MPTokenIssuanceID.length !== MPT_ISSUANCE_ID_HEX_LENGTH) {
+        throw new ValidationError(`ConfidentialMPTClawback: MPTokenIssuanceID must be a ${MPT_ISSUANCE_ID_HEX_LENGTH}-character hex string (UInt192)`);
+    }
+    // ── MPTAmount ── required, non-empty integer string, in [1, 2^63-1].
+    if (!isString(props.MPTAmount)) {
+        throw new ValidationError('ConfidentialMPTClawback: MPTAmount is required');
+    }
+    if (!INTEGER_SANITY_CHECK.test(props.MPTAmount)) {
+        throw new ValidationError('ConfidentialMPTClawback: MPTAmount must be a non-negative base-10 integer string');
+    }
+    const amount = BigInt(props.MPTAmount);
+    if (amount === BigInt(0)) {
+        throw new ValidationError('ConfidentialMPTClawback: MPTAmount must be non-zero');
+    }
+    if (amount > MAX_MPT_AMOUNT) {
+        throw new ValidationError(`ConfidentialMPTClawback: MPTAmount out of range (max ${MAX_MPT_AMOUNT.toString()})`);
+    }
+    // ── ZKProof ── required, exactly 128-char hex (64 bytes).
+    if (!isString(props.ZKProof) || !isHex(props.ZKProof) || props.ZKProof.length !== ZK_PROOF_HEX_LENGTH) {
+        throw new ValidationError(`ConfidentialMPTClawback: ZKProof must be a ${ZK_PROOF_HEX_LENGTH}-character hex string (64 bytes)`);
+    }
+    // ── Account != Holder ── issuer cannot claw back from itself
+    //   (XLS-0096 §12.4.1.3). The class API skips this guard.
+    if (props.Account === props.Holder) {
+        throw new ValidationError('ConfidentialMPTClawback: Holder and Account must be different');
+    }
+    // NOTE: `Account` must be the issuer of `MPTokenIssuanceID`
+    // (XLS-0096 §12.4.1.2 / xrpl.js `isMPTIssuer` guard). Not enforced
+    // here — see `## Divergences` header for why.
+    return buildFrozenTx('ConfidentialMPTClawback', props, {
+        validate() {
+            // Validated at construction.
+        },
+        toJSON() {
+            const json = {};
+            for (const k of Object.keys(this)) {
+                if (k === 'validate' || k === 'toJSON' || k === 'with')
+                    continue;
+                const v = this[k];
+                if (v !== undefined)
+                    json[k] = v;
+            }
+            return json;
+        },
+        with(overrides) {
+            return confidentialMptClawback(mergeForWith(this, overrides));
+        },
+    });
+}
+//# sourceMappingURL=confidential-mpt-clawback.js.map

package/dist/fp/factories/confidential-mpt-clawback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidential-mpt-clawback.js","sourceRoot":"","sources":["../../../src/fp/factories/confidential-mpt-clawback.ts"],"names":[],"mappings":"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"}

package/dist/fp/factories/confidential-mpt-convert-back.d.ts

@@ -0,0 +1,32 @@
+export interface ConfidentialMptConvertBackProps {
+    /** The account performing the conversion. Must be a valid XRPL classic/X-address. */
+    Account: string;
+    /** UInt192 — MPT issuance identifier (48-char hex). */
+    MPTokenIssuanceID: string;
+    /** UInt64 — plaintext amount to credit to the public balance (base-10 integer string, in [1, 2⁶³−1]). */
+    MPTAmount: string;
+    /** 66-byte ElGamal ciphertext to subtract from the holder's spending balance (132 hex chars). */
+    HolderEncryptedAmount: string;
+    /** 66-byte ElGamal ciphertext to subtract from the issuer's mirror balance (132 hex chars). */
+    IssuerEncryptedAmount: string;
+    /** UInt256 — 32-byte scalar blinding factor (64 hex chars). */
+    BlindingFactor: string;
+    /** 33-byte Pedersen commitment to the holder's spending balance (66 hex chars). */
+    BalanceCommitment: string;
+    /** 816-byte proof bundle (compact sigma + single Bulletproof range proof, 1632 hex chars). */
+    ZKProof: string;
+    /** 66-byte ElGamal ciphertext for the auditor (132 hex chars). Required iff issuance has AuditorEncryptionKey. */
+    AuditorEncryptedAmount?: string | undefined;
+    /** Fee in XRP (drops), base-10 integer string. */
+    Fee?: string | undefined;
+    /** Account sequence number. */
+    Sequence?: number | undefined;
+}
+export interface ConfidentialMptConvertBack extends Readonly<ConfidentialMptConvertBackProps> {
+    readonly TransactionType: 'ConfidentialMPTConvertBack';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<ConfidentialMptConvertBackProps>): ConfidentialMptConvertBack;
+}
+export declare function confidentialMptConvertBack(props: ConfidentialMptConvertBackProps): ConfidentialMptConvertBack;
+//# sourceMappingURL=confidential-mpt-convert-back.d.ts.map

package/dist/fp/factories/confidential-mpt-convert-back.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidential-mpt-convert-back.d.ts","sourceRoot":"","sources":["../../../src/fp/factories/confidential-mpt-convert-back.ts"],"names":[],"mappings":"AAqJA,MAAM,WAAW,+BAA+B;IAC9C,qFAAqF;IACrF,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC;IAClB,iGAAiG;IACjG,qBAAqB,EAAE,MAAM,CAAC;IAC9B,+FAA+F;IAC/F,qBAAqB,EAAE,MAAM,CAAC;IAC9B,+DAA+D;IAC/D,cAAc,EAAE,MAAM,CAAC;IACvB,mFAAmF;IACnF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,8FAA8F;IAC9F,OAAO,EAAE,MAAM,CAAC;IAChB,kHAAkH;IAClH,sBAAsB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,kDAAkD;IAClD,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,0BACf,SAAQ,QAAQ,CAAC,+BAA+B,CAAC;IACjD,QAAQ,CAAC,eAAe,EAAE,4BAA4B,CAAC;IACvD,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,CACF,SAAS,EAAE,OAAO,CAAC,+BAA+B,CAAC,GAClD,0BAA0B,CAAC;CAC/B;AAkBD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,+BAA+B,GACrC,0BAA0B,CA6G5B"}