xrpjson 0.1.0

package/dist/fp/factories/did-delete.js

@@ -0,0 +1,126 @@
+/**
+ * Functional DIDDelete factory — frozen-object style.
+ *
+ * Deletes the sender's Decentralized Identifier (DID) ledger entry.
+ * Per XLS-40 §5.3 the only required field is `Account`; the transaction
+ * otherwise uses only the common base transaction fields. The ledger
+ * rejects the deletion with `tecNO_ENTRY` if the account does not own a
+ * DID, but that is a runtime check (not locally checkable here).
+ * Validation happens at construction; there is no way to construct an
+ * invalid tx.
+ *
+ *   import { didDelete } from 'xrplt/fp';
+ *   const tx = didDelete({ Account });
+ *   const j = tx.toJSON();
+ *   const tx2 = tx.with({ Fee: '12' });
+ *
+ * Affected amendments:
+ *   - `DID` — base DIDDelete (XLS-40).
+ *
+ * @see https://xrpl.org/docs/references/protocol/transactions/types/diddelete
+ * @see XLS-0040 §5.3 (DIDDelete Transaction)
+ *      in `~/.mavis/docs.local/xrpl-standards/repo/XLS-0040-decentralized-identity/README.md`
+ *
+ * ## Divergences
+ *
+ * The class-based API at `src/transactions/did-delete.ts` and xrpl.js's
+ * `validateDIDDelete` both skip three rules that the canonical sources
+ * require. The factory fills them:
+ *
+ *   1. `Account` is validated as a classic/X-address via `isAccount`.
+ *      The class inherits its `validate()` from `Transaction.validate()`
+ *      and adds no check of its own — a malformed Account passes class
+ *      validation and only fails at the ledger with `temINVALID_ACCOUNT`.
+ *      The factory validates Account at construction time, consistent
+ *      with every other fp factory (`oracle-delete`, `loan-delete`,
+ *      `account-delete`).
+ *      Source: xrpl.js `validateBaseTransaction`
+ *              (`~/.mavis/docs.local/xrpl.js/repo/packages/xrpl/src/models/transactions/common.ts:987`)
+ *              — only checks `isString(Account)`, no format check.
+ *      Source: local `isAccount` at `src/validation/helpers.ts:55–60`.
+ *      Source: XLS-0040 §5.3.2 (`Account` Internal Type: `AccountID`).
+ *
+ *   2. `Flags` is exposed and validated.
+ *      The class has `ASSIGNABLE_FIELDS = []`, so callers using the
+ *      class API cannot set `Flags` at all. xrpl.js's
+ *      `validateDIDDelete` delegates to `validateBaseTransaction`,
+ *      which does NOT validate `Flags` at all — meaning any
+ *      non-negative integer, NaN, fractional value, or out-of-range
+ *      value passes xrpl.js's runtime check (see
+ *      `~/.mavis/docs.local/xrpl.js/repo/packages/xrpl/src/models/transactions/common.ts:964`
+ *      — Flags is absent from the optional-field list).
+ *      XLS-40 §5.3 defines no per-transaction flags for DIDDelete.
+ *      The only valid flag bits are the two global / "universal" flags
+ *      declared in ripple-binary-codec:
+ *        - `tfFullyCanonicalSig` = 0x80000000 (2147483648)
+ *        - `tfInnerBatchTxn`     = 0x40000000 (1073741824)
+ *      The factory accepts `Flags` as an optional `number`, requires
+ *      it to be a non-negative integer, and rejects any value with
+ *      bits set outside that valid mask.
+ *      Source: ripple-binary-codec `definitions.json`
+ *              (`~/.mavis/docs.local/xrpl.js/repo/packages/ripple-binary-codec/src/enums/definitions.json`)
+ *              lines 5318–5321 — universal flag namespace
+ *              (`tfFullyCanonicalSig`, `tfInnerBatchTxn`).
+ *      Source: xrpl.js `validateBaseTransaction`
+ *              (`~/.mavis/docs.local/xrpl.js/repo/packages/xrpl/src/models/transactions/common.ts:964–1037`)
+ *              — Flags is not validated.
+ *      Source: XLS-0040 §5.3.2 — DIDDelete defines no per-tx flags.
+ *
+ *   3. `Flags` integer-ness is enforced.
+ *      Even where xrpl.js or the class lets a numeric `Flags` through,
+ *      neither rejects NaN, ±Infinity, fractional values, or negatives.
+ *      `Object.isFrozen` of a frozen tx would still let a poisoned
+ *      numeric propagate to the ledger, where it would be serialized
+ *      as 0 (silent data loss). The factory rejects non-finite or
+ *      non-integer values up front.
+ *      Source: xrpl.js `isNumber` (`common.ts:209`) — `typeof === 'number'`
+ *              with no integer / finite check.
+ */
+import { isAccount, isNumber } from '../../validation/helpers.js';
+import { ValidationError } from '../../errors.js';
+import { buildFrozenTx, mergeForWith, require } from '../shape.js';
+// ─── Spec constants ──────────────────────────────────────────────────
+// Universal / global flag bits defined in ripple-binary-codec. DIDDelete
+// defines no per-tx flags (XLS-40 §5.3.2), so the only bits it may set
+// are these two.
+const TF_FULLY_CANONICAL_SIG = 0x80000000; // 2147483648
+const TF_INNER_BATCH_TXN = 0x40000000; // 1073741824
+const VALID_DID_DELETE_FLAGS = TF_FULLY_CANONICAL_SIG | TF_INNER_BATCH_TXN;
+// ─── Factory ─────────────────────────────────────────────────────────
+export function didDelete(props) {
+    // ── Account ── required, must be a valid XRPL classic or X-address.
+    require(props.Account, 'DIDDelete: Account is required', isAccount);
+    // ── Flags ── optional, but if present must be a non-negative integer
+    //   whose only set bits are in the universal flag mask.
+    if (props.Flags !== undefined) {
+        if (!isNumber(props.Flags) ||
+            !Number.isFinite(props.Flags) ||
+            !Number.isInteger(props.Flags) ||
+            props.Flags < 0) {
+            throw new ValidationError('DIDDelete: Flags must be a non-negative integer (tfFullyCanonicalSig | tfInnerBatchTxn)');
+        }
+        if ((props.Flags & ~VALID_DID_DELETE_FLAGS) !== 0) {
+            throw new ValidationError(`DIDDelete: Flags contains invalid bits (only tfFullyCanonicalSig=0x${TF_FULLY_CANONICAL_SIG.toString(16)} and tfInnerBatchTxn=0x${TF_INNER_BATCH_TXN.toString(16)} are allowed)`);
+        }
+    }
+    return buildFrozenTx('DIDDelete', 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 didDelete(mergeForWith(this, overrides));
+        },
+    });
+}
+//# sourceMappingURL=did-delete.js.map

package/dist/fp/factories/did-delete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"did-delete.js","sourceRoot":"","sources":["../../../src/fp/factories/did-delete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEnE,wEAAwE;AAExE,yEAAyE;AACzE,uEAAuE;AACvE,iBAAiB;AACjB,MAAM,sBAAsB,GAAG,UAAU,CAAC,CAAC,aAAa;AACxD,MAAM,kBAAkB,GAAG,UAAU,CAAC,CAAC,aAAa;AACpD,MAAM,sBAAsB,GAAG,sBAAsB,GAAG,kBAAkB,CAAC;AA0B3E,wEAAwE;AAExE,MAAM,UAAU,SAAS,CAAC,KAAqB;IAC7C,qEAAqE;IACrE,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,gCAAgC,EAAE,SAAS,CAAC,CAAC;IAEpE,sEAAsE;IACtE,wDAAwD;IACxD,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAC9B,IACE,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;YACtB,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;YAC7B,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC;YAC9B,KAAK,CAAC,KAAK,GAAG,CAAC,EACf,CAAC;YACD,MAAM,IAAI,eAAe,CACvB,yFAAyF,CAC1F,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,sBAAsB,CAAC,KAAK,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,eAAe,CACvB,sEAAsE,sBAAsB,CAAC,QAAQ,CAAC,EAAE,CAAC,0BAA0B,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC,eAAe,CAClL,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,aAAa,CAClB,WAAW,EACX,KAAK,EACL;QACE,QAAQ;YACN,6BAA6B;QAC/B,CAAC;QACD,MAAM;YACJ,MAAM,IAAI,GAA4B,EAAE,CAAC;YACzC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAClC,IAAI,CAAC,KAAK,UAAU,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,MAAM;oBAAE,SAAS;gBACjE,MAAM,CAAC,GAAI,IAA2C,CAAC,CAAC,CAAC,CAAC;gBAC1D,IAAI,CAAC,KAAK,SAAS;oBAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACnC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAkB,SAAkC;YACtD,OAAO,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;QAClD,CAAC;KACF,CACF,CAAC;AACJ,CAAC"}

package/dist/fp/factories/did-set.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Props for the `DIDSet` factory.
+ *
+ * Field naming follows xrpl.js / XLS-40 exactly — no rename relative
+ * to the class API. The class's `URI` field, the xrpl.js `URI` field,
+ * and the XLS-40 `URI` field all refer to the same hex-encoded
+ * Universal Resource Identifier slot on the DID ledger entry.
+ */
+export interface DIDSetProps {
+    /**
+     * The unique address of the transaction sender. The DID ledger entry
+     * is owned by this account. Required, must be a valid XRPL classic
+     * or X-address.
+     */
+    Account: string;
+    /**
+     * The DID document associated with the DID, hex-encoded. Optional,
+     * but at least one of `Data`, `DIDDocument`, or `URI` must be
+     * present (not `undefined`) for the tx to be well-formed.
+     *
+     * Pass `""` to clear an existing `DIDDocument` from the ledger
+     * entry. Source: xrpl.org `didset.md:41`.
+     */
+    DIDDocument?: string | undefined;
+    /**
+     * The public attestations of identity credentials associated with
+     * the DID, hex-encoded. Optional, but at least one of `Data`,
+     * `DIDDocument`, or `URI` must be present.
+     *
+     * Pass `""` to clear.
+     */
+    Data?: string | undefined;
+    /**
+     * The Universal Resource Identifier associated with the DID,
+     * hex-encoded. Optional, but at least one of `Data`, `DIDDocument`,
+     * or `URI` must be present.
+     *
+     * Pass `""` to clear.
+     */
+    URI?: string | undefined;
+    /**
+     * Bit-flags for this transaction. DIDSet defines no
+     * transaction-specific flags; only the universal
+     * `tfFullyCanonicalSig` (0x80000000) is meaningful. Optional.
+     */
+    Flags?: number | undefined;
+    /** Fee in XRP (drops), base-10 integer string. */
+    Fee?: string | undefined;
+    /** Account sequence number. */
+    Sequence?: number | undefined;
+}
+export interface DIDSet extends Readonly<DIDSetProps> {
+    readonly TransactionType: 'DIDSet';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<DIDSetProps>): DIDSet;
+}
+/**
+ * Build a frozen DIDSet. Throws `ValidationError` on construction if
+ * any required field is missing or malformed.
+ *
+ * The class-based equivalent validates lazily (caller must invoke
+ * `.validate()`); this functional version validates at construction.
+ * There is no way to build an invalid tx — `with()` re-runs the
+ * factory, so overrides are re-validated too.
+ */
+export declare function didSet(props: DIDSetProps): DIDSet;
+//# sourceMappingURL=did-set.d.ts.map

package/dist/fp/factories/did-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"did-set.d.ts","sourceRoot":"","sources":["../../../src/fp/factories/did-set.ts"],"names":[],"mappings":"AAoGA;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEjC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1B;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEzB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE3B,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,MACf,SAAQ,QAAQ,CAAC,WAAW,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC;IACnC,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC;CAC/C;AAsCD;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAwDjD"}

package/dist/fp/factories/did-set.js

@@ -0,0 +1,178 @@
+/**
+ * Functional DIDSet factory — frozen-object style.
+ *
+ * Creates or updates a [W3C DID][xls-40] (Decentralized Identifier) ledger
+ * entry associated with the sending `Account`. Validation happens at
+ * construction; there is no way to construct an invalid tx.
+ *
+ *   import { didSet } from 'xrplt/fp';
+ *   const tx = didSet({
+ *     Account,
+ *     URI: '697066733A2F2F62616679626569676479727A7435...', // ipfs://...
+ *   });
+ *   tx.validate();   // no-op — already validated at construction
+ *   const j = tx.toJSON();
+ *   const tx2 = tx.with({ Fee: '12', Sequence: 42 });
+ *
+ * At least one of `Data`, `DIDDocument`, or `URI` must be provided — per
+ * XLS-40 the tx must carry "modification" payload or rippled rejects it
+ * with `temEMPTY_DID`. An empty string (`""`) is the canonical way to
+ * clear an existing field, per the xrpl.org DIDSet reference.
+ *
+ * @see https://xrpl.org/docs/references/protocol/transactions/types/didset
+ * @see XLS-40 §5.2 (DIDSet transaction)
+ *      https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0040-decentralized-identity
+ * @see xrpl.js `packages/xrpl/src/models/transactions/DIDSet.ts`
+ *      (validateDIDSet — source of every guard below except the
+ *      hex-format and Account-format checks, which are stricter.)
+ *
+ * ## Divergences
+ *
+ * The factory implements the canonical XRPL DIDSet shape from
+ * xrpl.js / XLS-40 / xrpl.org, which is a strict superset of the
+ * validation the class API performs. The class at
+ * `src/transactions/did-set.ts` is a minimal placeholder — it only
+ * enforces the "at least one of Data/DIDDocument/URI" rule at
+ * `validate()`-call time. Concretely:
+ *
+ *   1. **Validation is eager, not lazy.** The class lets callers
+ *      construct a tx without immediately validating it; the factory
+ *      runs every guard at construction so an invalid `DIDSet` is a
+ *      type error (the call throws). There is no way to construct an
+ *      invalid frozen tx. Sources: class `validate()` runs only when
+ *      explicitly called (`src/transactions/did-set.ts:37-42`); the
+ *      factory mirrors the xrpl.js guard sequence
+ *      (`DIDSet.ts:31-48`) at construction time.
+ *
+ *   2. **`Account` is validated as a classic/X-address via `isAccount`,
+ *      not just as a non-empty string.** The class defers `Account`
+ *      validation to the base class's `validateBaseTransaction`, which
+ *      only requires `typeof Account === 'string'`. The factory
+ *      enforces the format regex at construction, matching the rest
+ *      of the M4 fp family (delegateSet, setRegularKey, payment, etc.).
+ *
+ *   3. **`Data`, `DIDDocument`, and `URI` are validated as
+ *      well-formed uppercase/lowercase hex (or `""` to clear) when
+ *      present.** xrpl.js `validateDIDSet` only checks `isString`
+ *      (`DIDSet.ts:34,36,38`) and lets the binary codec reject
+ *      non-hex at signing time. XRPL.org's DIDSet reference documents
+ *      all three fields as JSON Type `String` / Internal Type `Blob`
+ *      (see the Field tables at `xrpl-dev-portal/repo/docs/
+ *      references/protocol/transactions/types/didset.md:33-38`). The
+ *      factory enforces the hex format pre-signing so the failure
+ *      surfaces at construction, not at submit time. Empty string is
+ *      accepted (and validated as a no-op hex) because the xrpl.org
+ *      note "To delete the Data, DIDDocument, or URI field from an
+ *      existing DID ledger entry, add the field as an empty string."
+ *      (`didset.md:41`) makes `""` the canonical clear payload.
+ *      Source: xrpl.org `didset.md:33-41`; XLS-40 §5.2 (DIDSet
+ *      fields are `Blob` internal type).
+ *
+ *   4. **`Data`, `DIDDocument`, and `URI` lengths must be even
+ *      (whole-byte blobs).** Each field is an XLS-40 "Blob", which
+ *      rippled serialises as an even number of nibbles. xrpl.js does
+ *      not enforce this at the validator layer (it relies on the
+ *      binary codec), but odd-length hex would be rejected at sign
+ *      time with a codec error rather than a clear `ValidationError`.
+ *      The factory surfaces this at construction so callers don't
+ *      have to wait until `encode()` to discover the typo.
+ *      Source: ripple-binary-codec `definitions.json`
+ *      `DIDSet.Data/DIDDocument/URI: Blob`; XLS-40 §5.2.
+ *
+ *   5. **`Flags` is validated as a finite number if present.** The
+ *      spec defines no DIDSet-specific flags; the only meaningful
+ *      value is the universal `tfFullyCanonicalSig` (0x80000000) that
+ *      every signed transaction should set. The class accepts any
+ *      `Flags` value without type-checking; the factory rejects
+ *      non-numeric, `NaN`, or non-finite values. The bit itself is
+ *      NOT validated against a whitelist because some legacy tooling
+ *      passes through whatever the signer provides. Source: XRPL.org
+ *      DIDSet reference (no transaction-specific flags table; the
+ *      global flag list at
+ *      `xrpl-dev-portal/repo/docs/references/protocol/transactions/
+ *      common-fields.md` is authoritative).
+ */
+import { isAccount, isHex, isNumber, isString } from '../../validation/helpers.js';
+import { ValidationError } from '../../errors.js';
+import { buildFrozenTx, mergeForWith, require } from '../shape.js';
+// ─── Helpers ─────────────────────────────────────────────────────────
+/**
+ * Validate a Blob field per XLS-40: it must be a string, must be valid
+ * hex (or empty to clear), and must have even length (whole-byte
+ * encoding).
+ *
+ * The empty string is intentionally accepted because xrpl.org
+ * documents `""` as the canonical payload for clearing an existing
+ * field. Source: xrpl.org `didset.md:41`.
+ */
+function validateBlobField(field, value) {
+    if (!isString(value)) {
+        throw new ValidationError(`DIDSet: ${field} must be a string (hex-encoded, or "" to clear)`);
+    }
+    // Empty string is the canonical "clear" payload and is NOT hex.
+    if (value === '')
+        return;
+    if (!isHex(value)) {
+        throw new ValidationError(`DIDSet: ${field} must be valid hex (got: ${JSON.stringify(value)})`);
+    }
+    if (value.length % 2 !== 0) {
+        throw new ValidationError(`DIDSet: ${field} hex must have even length (whole bytes); got ${value.length} chars`);
+    }
+}
+// ─── Factory ─────────────────────────────────────────────────────────
+/**
+ * Build a frozen DIDSet. Throws `ValidationError` on construction if
+ * any required field is missing or malformed.
+ *
+ * The class-based equivalent validates lazily (caller must invoke
+ * `.validate()`); this functional version validates at construction.
+ * There is no way to build an invalid tx — `with()` re-runs the
+ * factory, so overrides are re-validated too.
+ */
+export function didSet(props) {
+    // ── Account ── required, must be a valid XRPL classic/X-address.
+    require(props.Account, 'DIDSet: missing or invalid Account', isAccount);
+    // ── At least one of Data / DIDDocument / URI must be present. ──
+    // xrpl.js `validateDIDSet` lines 40-48; XRPL.org DIDSet "must include
+    // either Data, DIDDocument, or URI"; class `src/transactions/did-set
+    // .ts:39-41` enforces the same rule at `.validate()` time.
+    const hasData = props.Data !== undefined;
+    const hasDIDDocument = props.DIDDocument !== undefined;
+    const hasURI = props.URI !== undefined;
+    if (!hasData && !hasDIDDocument && !hasURI) {
+        throw new ValidationError('DIDSet: must specify at least one of Data, DIDDocument, or URI');
+    }
+    // ── Data / DIDDocument / URI ── if present, must be hex Blob.
+    if (hasData)
+        validateBlobField('Data', props.Data);
+    if (hasDIDDocument)
+        validateBlobField('DIDDocument', props.DIDDocument);
+    if (hasURI)
+        validateBlobField('URI', props.URI);
+    // ── Flags ── if present, must be a finite number.
+    if (props.Flags !== undefined) {
+        if (!isNumber(props.Flags) || !Number.isFinite(props.Flags)) {
+            throw new ValidationError('DIDSet: Flags must be a finite number');
+        }
+    }
+    return buildFrozenTx('DIDSet', 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 didSet(mergeForWith(this, overrides));
+        },
+    });
+}
+//# sourceMappingURL=did-set.js.map

package/dist/fp/factories/did-set.js.map

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

package/dist/fp/factories/escrow-cancel.d.ts

@@ -0,0 +1,28 @@
+export interface EscrowCancelProps {
+    /** The unique address of the transaction sender. Any account may cancel. */
+    Account: string;
+    /**
+     * Address of the source account that funded the escrow payment.
+     * The sender of the original `EscrowCreate` transaction.
+     */
+    Owner: string;
+    /**
+     * Transaction sequence (or Ticket number) of the `EscrowCreate`
+     * transaction that created the escrow to cancel. `UInt32`.
+     */
+    OfferSequence: number;
+    /** Bit-flags for this transaction. The spec defines none — must be 0. */
+    Flags?: number | undefined;
+    /** Fee in XRP (drops), base-10 integer string. */
+    Fee?: string | undefined;
+    /** Account sequence number. */
+    Sequence?: number | undefined;
+}
+export interface EscrowCancel extends Readonly<EscrowCancelProps> {
+    readonly TransactionType: 'EscrowCancel';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<EscrowCancelProps>): EscrowCancel;
+}
+export declare function escrowCancel(props: EscrowCancelProps): EscrowCancel;
+//# sourceMappingURL=escrow-cancel.d.ts.map

package/dist/fp/factories/escrow-cancel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escrow-cancel.d.ts","sourceRoot":"","sources":["../../../src/fp/factories/escrow-cancel.ts"],"names":[],"mappings":"AA6EA,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,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,YAAa,SAAQ,QAAQ,CAAC,iBAAiB,CAAC;IAC/D,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC;IACzC,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,YAAY,CAAC;CAC3D;AAID,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAsEnE"}

package/dist/fp/factories/escrow-cancel.js

@@ -0,0 +1,127 @@
+/**
+ * Functional EscrowCancel factory — frozen-object style.
+ *
+ * Return escrowed funds from an expired escrow back to the original
+ * sender. The escrow must have a `CancelAfter` time that has already
+ * passed; that runtime check is enforced by rippled, not the factory.
+ * Validation here happens at construction; there is no way to construct
+ * an invalid tx.
+ *
+ *   import { escrowCancel } from 'xrplt/fp';
+ *   const tx = escrowCancel({ Account, Owner, OfferSequence: 7 });
+ *   const j = tx.toJSON();
+ *   const tx2 = tx.with({ Fee: '12' });
+ *
+ * Affected amendments:
+ *   - `Escrow` (base EscrowCancel)
+ *   - `TokenEscrow` (XLS-85: IOU/MPT tokens in addition to XRP)
+ *
+ * @see https://xrpl.org/docs/references/protocol/transactions/types/escrowcancel
+ * @see https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0085-token-escrow
+ *
+ * ## Divergences
+ *
+ * The class-based API at `src/transactions/escrow-cancel.ts` and xrpl.js's
+ * `validateEscrowCancel` both skip three preclaim guards that the
+ * canonical sources require. The factory fills them:
+ *
+ *   1. **`OfferSequence` must be a UInt32 (non-negative integer in
+ *      `[0, 0xffffffff]`).**
+ *      The class only checks `isNumber(this.OfferSequence)`, which accepts
+ *      any JS number — including `NaN`, `Infinity`, negatives, non-integers,
+ *      and values larger than `2^32 - 1`. xrpl.js is nearly identical:
+ *      `validateEscrowCancel` (`escrowCancel.ts:42–48`) only rejects
+ *      `NaN` / non-numeric strings.
+ *      Source: xrpl-dev-portal `escrowcancel.md` Fields table —
+ *        "`OfferSequence` | Number | UInt32".
+ *      Source: xrpl.js `escrowCancel.ts` — only checks
+ *        `typeof OfferSequence === 'number' || 'string'` and `!Number.isNaN(Number(...))`.
+ *
+ *   2. **`Account` must be a valid XRPL classic or X-address.**
+ *      The class does not validate `Account` at all (it inherits only
+ *      `Transaction.validate()` and never checks the address format).
+ *      The factory uses `isAccount` so a typo in the sender address is
+ *      caught at construction.
+ *      Source: xrpl-dev-portal basic-data-types.md — `AccountID` is a
+ *        classic address or X-address.
+ *
+ *   3. **Cross-field invariant — `OfferSequence` may not equal the
+ *      transaction's own `Sequence` (temBAD_SEQUENCE).**
+ *      A cancel that targets its own slot is meaningless and is
+ *      rejected by rippled with `temBAD_SEQUENCE`. The class does not
+ *      check this; the factory does so the same way it does for
+ *      `OfferCancel` (see `src/fp/factories/offer-cancel.ts`).
+ *      Source: xrpl-dev-portal `tem-codes.md` row `temBAD_SEQUENCE`
+ *        ("trying to cancel an offer that would have to be placed after
+ *        the transaction that cancels it") — applied symmetrically to
+ *        any previous-tx reference.
+ *
+ * Note: the factory does NOT enforce the ledger-time rules "the
+ * original EscrowCreate must have specified a CancelAfter time" or
+ * "the CancelAfter time must be in the past" — those are runtime
+ * `tec`-class results, not preclaim malformations. Per xrpl-dev-portal
+ * `escrowcancel.md` (Description section) they belong to rippled's
+ * apply-time checks.
+ */
+import { isAccount, isNumber } from '../../validation/helpers.js';
+import { ValidationError } from '../../errors.js';
+import { buildFrozenTx, mergeForWith, require } from '../shape.js';
+// ─── Spec constants ──────────────────────────────────────────────────
+// UInt32 bounds (per xrpl-dev-portal escrowcancel.md Fields table).
+const UINT32_MIN = 0;
+const UINT32_MAX = 0xffffffff;
+// ─── Factory ─────────────────────────────────────────────────────────
+export function escrowCancel(props) {
+    // ── Account ── required, must be a valid XRPL classic / X-address.
+    //    The class API does not check Account format at all.
+    require(props.Account, 'EscrowCancel: Account is required', isAccount);
+    // ── Owner ── required, must be a valid XRPL classic / X-address.
+    //    `Owner` is the original `EscrowCreate` sender; need not equal
+    //    `Account` (any account may submit an EscrowCancel per
+    //    xrpl-dev-portal escrowcancel.md).
+    if (!isAccount(props.Owner)) {
+        throw new ValidationError('EscrowCancel: Owner must be a valid XRPL account address');
+    }
+    // ── OfferSequence ── required, must be an integer in [0, 0xffffffff].
+    //    The class uses `isNumber`, which accepts any JS number (negatives,
+    //    floats, NaN, Infinity, > UInt32). The factory tightens to UInt32.
+    if (!isNumber(props.OfferSequence)) {
+        throw new ValidationError('EscrowCancel: missing or invalid OfferSequence');
+    }
+    if (!Number.isInteger(props.OfferSequence) ||
+        props.OfferSequence < UINT32_MIN ||
+        props.OfferSequence > UINT32_MAX) {
+        throw new ValidationError(`EscrowCancel: OfferSequence must be a UInt32 in [${UINT32_MIN}, ${UINT32_MAX}]`);
+    }
+    // ── Cross-field: OfferSequence may not equal the tx's own Sequence.
+    //    xrpl-dev-portal tem-codes.md: "temBAD_SEQUENCE — trying to
+    //    cancel an offer that would have to be placed after the
+    //    transaction that cancels it." Applied symmetrically to any
+    //    previous-tx reference (EscrowCancel's OfferSequence is one).
+    if (props.Sequence !== undefined &&
+        isNumber(props.Sequence) &&
+        Number.isInteger(props.Sequence) &&
+        props.OfferSequence === props.Sequence) {
+        throw new ValidationError('EscrowCancel: OfferSequence must not equal the transaction Sequence (temBAD_SEQUENCE)');
+    }
+    return buildFrozenTx('EscrowCancel', 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 escrowCancel(mergeForWith(this, overrides));
+        },
+    });
+}
+//# sourceMappingURL=escrow-cancel.js.map

package/dist/fp/factories/escrow-cancel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escrow-cancel.js","sourceRoot":"","sources":["../../../src/fp/factories/escrow-cancel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEnE,wEAAwE;AAExE,oEAAoE;AACpE,MAAM,UAAU,GAAG,CAAC,CAAC;AACrB,MAAM,UAAU,GAAG,UAAU,CAAC;AAgC9B,wEAAwE;AAExE,MAAM,UAAU,YAAY,CAAC,KAAwB;IACnD,oEAAoE;IACpE,yDAAyD;IACzD,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,mCAAmC,EAAE,SAAS,CAAC,CAAC;IAEvE,kEAAkE;IAClE,mEAAmE;IACnE,2DAA2D;IAC3D,uCAAuC;IACvC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,eAAe,CACvB,0DAA0D,CAC3D,CAAC;IACJ,CAAC;IAED,uEAAuE;IACvE,wEAAwE;IACxE,uEAAuE;IACvE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,eAAe,CACvB,gDAAgD,CACjD,CAAC;IACJ,CAAC;IACD,IACE,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC;QACtC,KAAK,CAAC,aAAa,GAAG,UAAU;QAChC,KAAK,CAAC,aAAa,GAAG,UAAU,EAChC,CAAC;QACD,MAAM,IAAI,eAAe,CACvB,oDAAoD,UAAU,KAAK,UAAU,GAAG,CACjF,CAAC;IACJ,CAAC;IAED,qEAAqE;IACrE,gEAAgE;IAChE,4DAA4D;IAC5D,gEAAgE;IAChE,kEAAkE;IAClE,IACE,KAAK,CAAC,QAAQ,KAAK,SAAS;QAC5B,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC;QACxB,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC;QAChC,KAAK,CAAC,aAAa,KAAK,KAAK,CAAC,QAAQ,EACtC,CAAC;QACD,MAAM,IAAI,eAAe,CACvB,uFAAuF,CACxF,CAAC;IACJ,CAAC;IAED,OAAO,aAAa,CAClB,cAAc,EACd,KAAK,EACL;QACE,QAAQ;YACN,6BAA6B;QAC/B,CAAC;QACD,MAAM;YACJ,MAAM,IAAI,GAA4B,EAAE,CAAC;YACzC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAClC,IAAI,CAAC,KAAK,UAAU,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,MAAM;oBAAE,SAAS;gBACjE,MAAM,CAAC,GAAI,IAA2C,CAAC,CAAC,CAAC,CAAC;gBAC1D,IAAI,CAAC,KAAK,SAAS;oBAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACnC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAqB,SAAqC;YAC5D,OAAO,YAAY,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;QACrD,CAAC;KACF,CACF,CAAC;AACJ,CAAC"}

package/dist/fp/factories/escrow-create.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Functional EscrowCreate factory — frozen-object style.
+ *
+ * Set aside XRP (or, under the TokenEscrow amendment, IOU/MPT tokens) in
+ * an escrow that delivers them to a predetermined recipient when
+ * certain conditions are met. Validation happens at construction;
+ * there is no way to construct an invalid tx.
+ *
+ *   import { escrowCreate } from 'xrplt/fp';
+ *   const tx = escrowCreate({ Account, Amount, Destination, FinishAfter: 533171558 });
+ *   const j = tx.toJSON();
+ *   const tx2 = tx.with({ CancelAfter: 533257958 });
+ *
+ * Affected amendments:
+ *   - `Escrow` (base XRP escrow)
+ *   - `TokenEscrow` (XLS-85: IOU/MPT tokens in addition to XRP)
+ *
+ * @see https://xrpl.org/docs/references/protocol/transactions/types/escrowcreate
+ * @see https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0085-token-escrow
+ *
+ * ## Divergences
+ *
+ * Compared with `src/transactions/escrow-create.ts`, this factory adds
+ * preclaim guards the class API skips:
+ *
+ * 1. **`Amount` must be strictly positive (non-zero, non-negative).**
+ *    Source: xrpl.js
+ *    (`repo/packages/xrpl/src/models/transactions/escrowCreate.ts:25–28`) —
+ *    "Must always be a positive value." The local `isAmount` helper (and the
+ *    class) accept any numeric string, including `"0"` and `"-1"`, which the
+ *    ledger rejects with `temBAD_AMOUNT`.
+ *
+ * 2. **`FinishAfter` must be strictly less than `CancelAfter` when both
+ *    are present.**
+ *    Source: xrpl.org `escrowcreate.md` fields table — "`FinishAfter` …
+ *    the escrowed funds can be released to the recipient. This value is
+ *    immutable" — combined with the `CancelAfter` description "the funds
+ *    can only be returned to the sender after this time" — implying
+ *    `FinishAfter < CancelAfter` for any meaningful escrow. The class
+ *    does not enforce the ordering.
+ *
+ * 3. **`Condition` must be a hex string.**
+ *    Source: xrpl.org `escrowcreate.md` — "`Condition` — Hex value
+ *    representing a PREIMAGE-SHA-256 crypto-condition." The class only
+ *    checks `isString(Condition)` and accepts arbitrary text.
+ *
+ * 4. **Either `FinishAfter` or `Condition` must be specified.**
+ *    Source: xrpl.js
+ *    (`repo/packages/xrpl/src/models/transactions/escrowCreate.ts:74–78`) —
+ *    "Either Condition or FinishAfter must be specified." A conditional
+ *    escrow with no `FinishAfter` and no `CancelAfter` would be
+ *    unspendable forever; the class does not enforce this.
+ *
+ * 5. **`Destination` must not equal `Account`.**
+ *    Source: XRPL `rippled` preclaim `temMALFORMED` for self-escrow
+ *    (`EscrowCreate.cpp` — `if (ctx.tx[sfDestination] == ctx.tx[sfAccount])
+ *    return temMALFORMED;`). The class only checks the address format.
+ *
+ * 6. **`DestinationTag`, `CancelAfter`, `FinishAfter` must be
+ *    non-negative integers when provided.**
+ *    Source: xrpl.org `escrowcreate.md` — fields are typed `UInt32`.
+ *    The class accepts negative numbers as JavaScript `number`s.
+ */
+import type { Amount } from '../../types/amounts.js';
+export interface EscrowCreateProps {
+    /** The unique address of the transaction sender. */
+    Account: string;
+    /** Amount of XRP (drops) or fungible token to set aside. */
+    Amount: Amount;
+    /** Address to receive escrowed funds. Must differ from `Account`. */
+    Destination: string;
+    /**
+     * Time (seconds since Ripple Epoch) after which the escrow can be
+     * cancelled and funds returned to the sender. `UInt32`.
+     */
+    CancelAfter?: number | undefined;
+    /**
+     * Time (seconds since Ripple Epoch) after which the escrow can be
+     * finished and funds released to the destination. `UInt32`.
+     */
+    FinishAfter?: number | undefined;
+    /**
+     * Hex PREIMAGE-SHA-256 crypto-condition. 80 hex chars.
+     */
+    Condition?: string | undefined;
+    /**
+     * Optional destination tag (`UInt32`) — e.g. a hosted recipient
+     * identifier at the destination address.
+     */
+    DestinationTag?: number | undefined;
+    /** Bit-flags for this transaction. EscrowCreate has no defined flags. */
+    Flags?: number | undefined;
+    Fee?: string | undefined;
+    Sequence?: number | undefined;
+}
+export interface EscrowCreate extends Readonly<EscrowCreateProps> {
+    readonly TransactionType: 'EscrowCreate';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<EscrowCreateProps>): EscrowCreate;
+}
+export declare function escrowCreate(props: EscrowCreateProps): EscrowCreate;
+//# sourceMappingURL=escrow-create.d.ts.map