xrpjson 0.1.0

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

@@ -0,0 +1,38 @@
+export interface ConfidentialMptSendProps {
+    /** The account performing the send. Must be a valid XRPL classic/X-address. */
+    Account: string;
+    /** UInt192 — MPT issuance identifier (48-char hex). */
+    MPTokenIssuanceID: string;
+    /** AccountID — receiver of the confidential transfer. Must differ from Account. */
+    Destination: string;
+    /** UINT32 — destination tag (optional, used for hosted recipients). */
+    DestinationTag?: number | undefined;
+    /** Blob — 66-byte ElGamal ciphertext used to debit sender's spending balance. */
+    SenderEncryptedAmount: string;
+    /** Blob — 66-byte ciphertext credited to the receiver's inbox balance. */
+    DestinationEncryptedAmount: string;
+    /** Blob — 66-byte ciphertext used to update the issuer mirror balance. */
+    IssuerEncryptedAmount: string;
+    /** Blob — optional 66-byte ciphertext for the auditor. */
+    AuditorEncryptedAmount?: string | undefined;
+    /** Blob — 946-byte proof bundle (compact sigma + aggregated Bulletproof). */
+    ZKProof: string;
+    /** Blob — 33-byte Pedersen commitment to the transfer amount. */
+    AmountCommitment: string;
+    /** Blob — 33-byte Pedersen commitment to sender's spending balance. */
+    BalanceCommitment: string;
+    /** Vector256 — 1..8 credential IDs (conditional, non-empty when supplied). */
+    CredentialIDs?: string[] | undefined;
+    /** Fee in XRP (drops), base-10 integer string. */
+    Fee?: string | undefined;
+    /** Account sequence number. */
+    Sequence?: number | undefined;
+}
+export interface ConfidentialMptSend extends Readonly<ConfidentialMptSendProps> {
+    readonly TransactionType: 'ConfidentialMPTSend';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<ConfidentialMptSendProps>): ConfidentialMptSend;
+}
+export declare function confidentialMptSend(props: ConfidentialMptSendProps): ConfidentialMptSend;
+//# sourceMappingURL=confidential-mpt-send.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"confidential-mpt-send.d.ts","sourceRoot":"","sources":["../../../src/fp/factories/confidential-mpt-send.ts"],"names":[],"mappings":"AA0KA,MAAM,WAAW,wBAAwB;IACvC,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mFAAmF;IACnF,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,iFAAiF;IACjF,qBAAqB,EAAE,MAAM,CAAC;IAC9B,0EAA0E;IAC1E,0BAA0B,EAAE,MAAM,CAAC;IACnC,0EAA0E;IAC1E,qBAAqB,EAAE,MAAM,CAAC;IAC9B,0DAA0D;IAC1D,sBAAsB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,aAAa,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACrC,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,mBACf,SAAQ,QAAQ,CAAC,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,eAAe,EAAE,qBAAqB,CAAC;IAChD,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,wBAAwB,CAAC,GAAG,mBAAmB,CAAC;CACzE;AA2BD,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,wBAAwB,GAC9B,mBAAmB,CA4KrB"}

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

@@ -0,0 +1,254 @@
+/**
+ * Functional ConfidentialMptSend factory — frozen-object style.
+ *
+ * Sends MPT tokens to another account while keeping the transfer amount
+ * hidden on-ledger. The transferred amount is credited to the receiver's
+ * confidential inbox balance (`CB_IN`) — the receiver may later merge
+ * these funds into their spending balance via `ConfidentialMPTMergeInbox`.
+ *
+ * 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 { confidentialMptSend } from 'xrplt/fp';
+ *   const tx = confidentialMptSend({
+ *     Account,
+ *     MPTokenIssuanceID,
+ *     Destination,
+ *     SenderEncryptedAmount,
+ *     DestinationEncryptedAmount,
+ *     IssuerEncryptedAmount,
+ *     ZKProof,
+ *     AmountCommitment,
+ *     BalanceCommitment,
+ *   });
+ *   const j = tx.toJSON();
+ *   const tx2 = tx.with({ Fee: '100' });
+ *
+ * Requires the `ConfidentialTransfer` amendment.
+ *
+ * @see https://xrpl.org/docs/references/protocol/transactions/types/confidentialmptsend
+ * @see XLS-0096 §9 — Transaction: `ConfidentialMPTSend`
+ *   (https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0096-confidential-mpt)
+ * @see xrpl.js — packages/xrpl/src/models/transactions/ConfidentialMPTSend.ts
+ *
+ * ## Divergences
+ *
+ * Compared with `src/transactions/confidential-mpt-send.ts`, this factory
+ * adds guards the class skips — and explicitly documents the two
+ * canonical guards that cannot be added in a zero-dependency package.
+ *
+ * - **`Account` is validated as a well-formed XRPL classic or X-address
+ *   at construction time** (`src/validation/helpers.ts` `isAccount`,
+ *   lines 55–60). The class delegates `Account` validation to its
+ *   `TokenTransaction` → `Transaction` parent chain via `super.validate()`
+ *   and never inspects `Account` directly. We re-implement the guard
+ *   inline so a malformed Account is caught at construction.
+ *   - Source: xrpl.js `validateBaseTransaction`
+ *     (packages/xrpl/src/models/transactions/common.ts line 964).
+ *   - Source: xrpl-dev-portal `confidentialmptsend.md` Fields table
+ *     row for `Account`, JSON Type = `AccountID`.
+ *
+ * - **`Account` must NOT equal `Destination`** (XLS-0096 §9.4.1.4 mandates
+ *   this as `temMALFORMED`; xrpl.js `validateConfidentialMPTSend` lines
+ *   97–101 checks it explicitly). The class API does NOT check this —
+ *   it relies on `super.validate()` which never compares the two fields.
+ *   - Source: XLS-0096 §9.4.1.4 Failure Conditions, item 4: the sender
+ *     and destination accounts are the same (`temMALFORMED`).
+ *   - Source: xrpl.js `ConfidentialMPTSend.ts` lines 97–101.
+ *
+ * - **`DestinationTag` is accepted and validated as a `UINT32`** when
+ *   supplied. The class omits this field entirely
+ *   (`ConfidentialMPTSendTxFields` declares no `DestinationTag`).
+ *   - Source: XLS-0096 §9.2 Fields table, Internal Type = `UINT32`.
+ *   - Source: xrpl.js `ConfidentialMPTSend.ts` lines 40, 114
+ *     (`DestinationTag?: number`, `validateOptionalField(tx,
+ *     'DestinationTag', isNumber)`).
+ *
+ * - **`CredentialIDs` is structurally validated when supplied**: must be
+ *   an array (not a single string), length must be in `[1, 8]`, each
+ *   element must be a 64-character hex string (HASH256 / Vector256),
+ *   and the array must contain no duplicates. The class declares the
+ *   field but never inspects it. Per XLS-0096 §9.4.1 the empty-array
+ *   case is `temMALFORMED`; per XLS-0096 §9.4.2.1 authorization checks
+ *   on the credentials are runtime checks and not enforced here.
+ *   - Source: XLS-0096 §9.4.1 Failure Conditions (temMALFORMED when
+ *     CredentialIDs is empty, exceeds the maximum size, or contains
+ *     duplicates).
+ *   - Source: xrpl.js `validateCredentialsList` (common.ts line 1106)
+ *     and `MAX_AUTHORIZED_CREDENTIALS = 8` (common.ts line 28).
+ *   - Source: xrpl-dev-portal `confidentialmptsend.md` Fields table
+ *     row for `CredentialIDs`, Internal Type = `Vector256`.
+ *
+ * - **`AuditorEncryptedAmount` is validated as exactly 132 hex chars**
+ *   when supplied. The class already performs this check; we mirror it
+ *   here for consistency with the other ciphertext fields.
+ *
+ * - **`Account` must NOT be the issuer of `MPTokenIssuanceID`
+ *   (KNOWN LIMITATION — NOT IMPLEMENTED)**. XLS-0096 §9.4.1.2 mandates
+ *   this as `temMALFORMED`:
+ *
+ *     > "The sender is the issuer of the MPT. (`temMALFORMED`)"
+ *
+ *   xrpl.js's `validateConfidentialMPTSend` (lines 104–108) enforces
+ *   this via its `isMPTIssuer(account, mptIssuanceID)` helper (common.ts
+ *   line 632), 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 §9.4.1.2 Failure Conditions (Data Verification),
+ *     item 2: `temMALFORMED` when the sender is the issuer.
+ *   - Source: xrpl-dev-portal `confidentialmptsend.md` Error Cases
+ *     table, `temMALFORMED` row.
+ *   - Source: xrpl.js `ConfidentialMPTSend.ts` lines 104–108
+ *     (`isMPTIssuer` guard) and `common.ts` lines 632–646
+ *     (`isMPTIssuer` implementation, including the base58 + AccountID
+ *     decoding dependency).
+ *
+ * - **`Destination` must NOT be the issuer of `MPTokenIssuanceID`
+ *   (KNOWN LIMITATION — NOT IMPLEMENTED)**. Same root cause and
+ *   mitigation as the sender-issuer guard above.
+ *   - Source: XLS-0096 §9.4.1.3 Failure Conditions (Data Verification),
+ *     item 3: `temMALFORMED` when the destination is the issuer.
+ *   - Source: xrpl.js `ConfidentialMPTSend.ts` lines 109–113
+ *     (`isMPTIssuer` guard).
+ */
+import { isAccount, isArray, isHex, isNumber, 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 §9.2; xrpl-dev-portal
+// `confidentialmptsend.md` Fields table.
+const MPT_ISSUANCE_ID_HEX_LENGTH = 48;
+// Pedersen commitments are 33-byte compressed EC points (BLOB).
+// XLS-0096 §9.2 (AmountCommitment / BalanceCommitment), Internal Type = BLOB;
+// xrpl.js `CONFIDENTIAL_EC_POINT_BYTES = 33`.
+const CONFIDENTIAL_EC_POINT_HEX_LENGTH = 66;
+// ElGamal ciphertexts are 66 bytes (two compressed EC points).
+// XLS-0096 §9.2; xrpl.js `CONFIDENTIAL_ELGAMAL_CIPHERTEXT_BYTES = 66`.
+const CONFIDENTIAL_CIPHERTEXT_HEX_LENGTH = 132;
+// ConfidentialMPTSend ZKProof is a 946-byte bundle (192-byte compact
+// sigma + 754-byte aggregated Bulletproof). XLS-0096 §9.2 / §9.4.1.5
+// mandates the length exactly; xrpl.js `CONFIDENTIAL_SEND_PROOF_BYTES = 946`.
+const CONFIDENTIAL_SEND_PROOF_HEX_LENGTH = 2 * 946;
+// Vector256 = 64 hex chars per credential ID. XLS-70 / XLS-0096 §9.2.
+const CREDENTIAL_ID_HEX_LENGTH = 64;
+// Maximum number of credential IDs per transaction (XLS-70). XLS-0096
+// §9.4.1 requires CredentialIDs not to exceed the maximum size;
+// xrpl.js `MAX_AUTHORIZED_CREDENTIALS = 8`.
+const MAX_AUTHORIZED_CREDENTIALS = 8;
+// DestinationTag is a UINT32 (0 .. 2^32 − 1).
+const MAX_UINT32 = 0xffffffff;
+// ─── Helpers ─────────────────────────────────────────────────────────
+/**
+ * Validate a hex blob of a specific byte length (length = 2 × bytes).
+ */
+function requireHexOfByteLength(field, value, bytes, errorPrefix) {
+    const hexLen = bytes * 2;
+    if (!isString(value) ||
+        !isHex(value) ||
+        value.length !== hexLen) {
+        throw new ValidationError(`${errorPrefix}: ${field} must be a ${hexLen}-character hex string (${bytes} bytes)`);
+    }
+}
+// ─── Factory ─────────────────────────────────────────────────────────
+export function confidentialMptSend(props) {
+    // ── Account ── required, must be a valid XRPL classic/X-address.
+    require(props.Account, 'ConfidentialMPTSend: Account is required', isAccount);
+    // ── MPTokenIssuanceID ── required, exactly 48-char hex (UINT192).
+    requireHexOfByteLength('MPTokenIssuanceID', props.MPTokenIssuanceID, MPT_ISSUANCE_ID_HEX_LENGTH / 2, 'ConfidentialMPTSend');
+    // ── Destination ── required, must be a valid XRPL classic/X-address.
+    require(props.Destination, 'ConfidentialMPTSend: Destination is required', isAccount);
+    // ── Account != Destination ── (XLS-0096 §9.4.1.4 / xrpl.js).
+    if (props.Account === props.Destination) {
+        throw new ValidationError('ConfidentialMPTSend: Destination and Account must be different');
+    }
+    // ── DestinationTag ── optional, UINT32.
+    if (props.DestinationTag !== undefined) {
+        if (!isNumber(props.DestinationTag) ||
+            !Number.isInteger(props.DestinationTag) ||
+            props.DestinationTag < 0 ||
+            props.DestinationTag > MAX_UINT32) {
+            throw new ValidationError(`ConfidentialMPTSend: DestinationTag must be an integer in [0, ${MAX_UINT32}]`);
+        }
+    }
+    // ── SenderEncryptedAmount ── required, 66-byte ciphertext.
+    requireHexOfByteLength('SenderEncryptedAmount', props.SenderEncryptedAmount, CONFIDENTIAL_CIPHERTEXT_HEX_LENGTH / 2, 'ConfidentialMPTSend');
+    // ── DestinationEncryptedAmount ── required, 66-byte ciphertext.
+    requireHexOfByteLength('DestinationEncryptedAmount', props.DestinationEncryptedAmount, CONFIDENTIAL_CIPHERTEXT_HEX_LENGTH / 2, 'ConfidentialMPTSend');
+    // ── IssuerEncryptedAmount ── required, 66-byte ciphertext.
+    requireHexOfByteLength('IssuerEncryptedAmount', props.IssuerEncryptedAmount, CONFIDENTIAL_CIPHERTEXT_HEX_LENGTH / 2, 'ConfidentialMPTSend');
+    // ── AuditorEncryptedAmount ── optional, 66-byte ciphertext.
+    if (props.AuditorEncryptedAmount !== undefined) {
+        requireHexOfByteLength('AuditorEncryptedAmount', props.AuditorEncryptedAmount, CONFIDENTIAL_CIPHERTEXT_HEX_LENGTH / 2, 'ConfidentialMPTSend');
+    }
+    // ── ZKProof ── required, 946-byte proof bundle.
+    requireHexOfByteLength('ZKProof', props.ZKProof, CONFIDENTIAL_SEND_PROOF_HEX_LENGTH / 2, 'ConfidentialMPTSend');
+    // ── AmountCommitment ── required, 33-byte compressed EC point.
+    requireHexOfByteLength('AmountCommitment', props.AmountCommitment, CONFIDENTIAL_EC_POINT_HEX_LENGTH / 2, 'ConfidentialMPTSend');
+    // ── BalanceCommitment ── required, 33-byte compressed EC point.
+    requireHexOfByteLength('BalanceCommitment', props.BalanceCommitment, CONFIDENTIAL_EC_POINT_HEX_LENGTH / 2, 'ConfidentialMPTSend');
+    // ── CredentialIDs ── optional, but when present must be a non-empty
+    //    array of unique 64-char hex strings of length 1..8.
+    if (props.CredentialIDs !== undefined) {
+        if (!isArray(props.CredentialIDs)) {
+            throw new ValidationError('ConfidentialMPTSend: CredentialIDs must be an array');
+        }
+        if (props.CredentialIDs.length === 0) {
+            throw new ValidationError('ConfidentialMPTSend: CredentialIDs cannot be an empty array');
+        }
+        if (props.CredentialIDs.length > MAX_AUTHORIZED_CREDENTIALS) {
+            throw new ValidationError(`ConfidentialMPTSend: CredentialIDs cannot exceed ${MAX_AUTHORIZED_CREDENTIALS} elements`);
+        }
+        const seen = new Set();
+        for (const cid of props.CredentialIDs) {
+            if (!isString(cid) ||
+                !isHex(cid) ||
+                cid.length !== CREDENTIAL_ID_HEX_LENGTH) {
+                throw new ValidationError(`ConfidentialMPTSend: each CredentialID must be a ${CREDENTIAL_ID_HEX_LENGTH}-character hex string (Vector256)`);
+            }
+            if (seen.has(cid)) {
+                throw new ValidationError('ConfidentialMPTSend: CredentialIDs cannot contain duplicates');
+            }
+            seen.add(cid);
+        }
+    }
+    // NOTE: Account must NOT be the issuer of MPTokenIssuanceID
+    // (XLS-0096 §9.4.1.2 / xrpl.js `isMPTIssuer` guard). Not enforced
+    // here — see `## Divergences` header for why.
+    // NOTE: Destination must NOT be the issuer of MPTokenIssuanceID
+    // (XLS-0096 §9.4.1.3 / xrpl.js `isMPTIssuer` guard). Not enforced
+    // here — see `## Divergences` header for why.
+    return buildFrozenTx('ConfidentialMPTSend', 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 confidentialMptSend(mergeForWith(this, overrides));
+        },
+    });
+}
+//# sourceMappingURL=confidential-mpt-send.js.map

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

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

package/dist/fp/factories/credential-accept.d.ts

@@ -0,0 +1,23 @@
+export interface CredentialAcceptProps {
+    /** The subject of the credential (the Account submitting the tx). */
+    Account: string;
+    /** The issuer of the credential. XRPL classic or X-address. */
+    Issuer: string;
+    /**
+     * Hex-encoded identifier of the credential type. 1–64 bytes
+     * (2–128 hex chars), non-empty.
+     */
+    CredentialType: string;
+    /** Bit-flags for this transaction. */
+    Flags?: number | undefined;
+    Fee?: string | undefined;
+    Sequence?: number | undefined;
+}
+export interface CredentialAccept extends Readonly<CredentialAcceptProps> {
+    readonly TransactionType: 'CredentialAccept';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<CredentialAcceptProps>): CredentialAccept;
+}
+export declare function credentialAccept(props: CredentialAcceptProps): CredentialAccept;
+//# sourceMappingURL=credential-accept.d.ts.map

package/dist/fp/factories/credential-accept.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-accept.d.ts","sourceRoot":"","sources":["../../../src/fp/factories/credential-accept.ts"],"names":[],"mappings":"AAqFA,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,gBACf,SAAQ,QAAQ,CAAC,qBAAqB,CAAC;IACvC,QAAQ,CAAC,eAAe,EAAE,kBAAkB,CAAC;IAC7C,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG,gBAAgB,CAAC;CACnE;AA6BD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,gBAAgB,CAuD/E"}

package/dist/fp/factories/credential-accept.js

@@ -0,0 +1,135 @@
+/**
+ * Functional CredentialAccept factory — frozen-object style.
+ *
+ * Accepts a credential that was provisionally issued to the Account.
+ * Validation happens at construction; there is no way to construct an
+ * invalid tx.
+ *
+ *   import { credentialAccept } from 'xrplt/fp';
+ *   const tx = credentialAccept({
+ *     Account,
+ *     Issuer: iss,
+ *     CredentialType: '6D795F63726564656E7469616C',
+ *   });
+ *   const j = tx.toJSON();
+ *
+ * Affected amendments:
+ *   - `Credentials` — introduces this transaction type (XLS-0070 §4).
+ *
+ * @see https://xrpl.org/docs/references/protocol/transactions/types/credentialaccept
+ * @see https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0070-credentials
+ *
+ * ## Divergences
+ *
+ * The class-based API at `src/transactions/credential-accept.ts` is
+ * missing three rules that the canonical sources require. The factory
+ * adds them:
+ *
+ *   1. `CredentialType` must not be an empty string.
+ *      The class only checks `isString(this.CredentialType)`, so `""`
+ *      passes. XLS-0070 §2.1.3: "It has a maximum length of 64 bytes,
+ *      and cannot be an empty string." xrpl.js `validateCredentialType`
+ *      rejects `tx.CredentialType.length === 0`. xrpl-dev-portal's
+ *      `credentialaccept.md` field table likewise lists the minimum
+ *      length as 1 byte.
+ *      Source: XLS-0070 §2.1.3; xrpl.js
+ *              `models/transactions/common.ts:1061–1086`
+ *              (`validateCredentialType`).
+ *
+ *   2. `CredentialType` must be hex-encoded.
+ *      The class accepts any string (e.g. `"not-hex!"`). The spec
+ *      encodes `CredentialType` as a `Blob` (XLS-0070 §2.1 field table
+ *      row for `CredentialType`: Internal Type `Blob`). xrpl.js
+ *      `validateCredentialType` enforces `HEX_REGEX.test`.
+ *      Source: XLS-0070 §2.1 field table; xrpl.js
+ *              `models/transactions/common.ts:1088–1092`
+ *              (`validateCredentialType`).
+ *
+ *   3. `CredentialType` length must be at most 128 hex chars (64 bytes).
+ *      The class has no length check. XLS-0070 §2.1.3 caps the value at
+ *      64 bytes; the hex-encoded form is therefore at most 128 chars.
+ *      xrpl.js enforces `MAX_CREDENTIAL_TYPE_LENGTH = 128`
+ *      (`common.ts:30`). The hex form must also be even-length to round-
+ *      trip cleanly through the binary codec — the factory enforces
+ *      even length explicitly so users get a clear error.
+ *      Source: XLS-0070 §2.1.3; xrpl.js
+ *              `models/transactions/common.ts:30` and
+ *              `models/transactions/common.ts:1082–1086`.
+ *
+ *   4. `Account` is explicitly required and validated as a non-empty
+ *      string.
+ *      The class inherits its `Account` handling from
+ *      `Transaction.validate()` via `super.validate()` and never
+ *      re-checks the field. The factory has no inheritance chain, so
+ *      the requirement is enforced here. xrpl.js enforces the same via
+ *      `validateRequiredField(tx, 'Account', isString)`.
+ *      Source: XLS-0070 §4.1 (Account is required, JSON Type Address);
+ *              xrpl.js `models/transactions/CredentialAccept.ts:39`.
+ *
+ * Note on `Issuer`: the class uses `isAccount` (format-only XRPL
+ * address check). This is stricter than xrpl.js's `isString` and is
+ * retained here — `Issuer` is typed `AccountID` in XLS-0070 §4.1, so
+ * the format check is correct.
+ */
+import { isAccount, isHex, isString } from '../../validation/helpers.js';
+import { ValidationError } from '../../errors.js';
+import { buildFrozenTx, mergeForWith, require } from '../shape.js';
+// ─── Spec constants ──────────────────────────────────────────────────
+// CredentialType is a hex-encoded Blob capped at 64 bytes (XLS-0070 §2.1.3).
+const MAX_CREDENTIAL_TYPE_BYTES = 64;
+const MAX_CREDENTIAL_TYPE_HEX_LENGTH = MAX_CREDENTIAL_TYPE_BYTES * 2;
+// ─── Helpers ─────────────────────────────────────────────────────────
+function validateCredentialTypeHex(value) {
+    if (value.length === 0) {
+        throw new ValidationError('CredentialAccept: CredentialType cannot be an empty string');
+    }
+    if (!isHex(value)) {
+        throw new ValidationError('CredentialAccept: CredentialType must be encoded in hex');
+    }
+    if (value.length % 2 !== 0) {
+        throw new ValidationError('CredentialAccept: CredentialType must be a hex string with an even number of characters');
+    }
+    if (value.length > MAX_CREDENTIAL_TYPE_HEX_LENGTH) {
+        throw new ValidationError(`CredentialAccept: CredentialType length cannot be > ${MAX_CREDENTIAL_TYPE_HEX_LENGTH} (64 bytes)`);
+    }
+}
+// ─── Factory ─────────────────────────────────────────────────────────
+export function credentialAccept(props) {
+    // ── Account ── required, must be a non-empty string.
+    require(props.Account, 'CredentialAccept: Account is required', isString);
+    if (props.Account.length === 0) {
+        throw new ValidationError('CredentialAccept: Account is required');
+    }
+    // ── Issuer ── required, must look like an XRPL classic or X-address.
+    if (!isAccount(props.Issuer)) {
+        throw new ValidationError('CredentialAccept: missing or invalid Issuer');
+    }
+    // ── CredentialType ── required, hex, non-empty, even-length, ≤ 64 bytes.
+    if (props.CredentialType === undefined) {
+        throw new ValidationError('CredentialAccept: missing field CredentialType');
+    }
+    if (!isString(props.CredentialType)) {
+        throw new ValidationError('CredentialAccept: CredentialType must be a string');
+    }
+    validateCredentialTypeHex(props.CredentialType);
+    return buildFrozenTx('CredentialAccept', 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 credentialAccept(mergeForWith(this, overrides));
+        },
+    });
+}
+//# sourceMappingURL=credential-accept.js.map

package/dist/fp/factories/credential-accept.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-accept.js","sourceRoot":"","sources":["../../../src/fp/factories/credential-accept.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEnE,wEAAwE;AAExE,6EAA6E;AAC7E,MAAM,yBAAyB,GAAG,EAAE,CAAC;AACrC,MAAM,8BAA8B,GAAG,yBAAyB,GAAG,CAAC,CAAC;AA4BrE,wEAAwE;AAExE,SAAS,yBAAyB,CAAC,KAAa;IAC9C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,eAAe,CACvB,4DAA4D,CAC7D,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAClB,MAAM,IAAI,eAAe,CACvB,yDAAyD,CAC1D,CAAC;IACJ,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,eAAe,CACvB,yFAAyF,CAC1F,CAAC;IACJ,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,GAAG,8BAA8B,EAAE,CAAC;QAClD,MAAM,IAAI,eAAe,CACvB,uDAAuD,8BAA8B,aAAa,CACnG,CAAC;IACJ,CAAC;AACH,CAAC;AAED,wEAAwE;AAExE,MAAM,UAAU,gBAAgB,CAAC,KAA4B;IAC3D,sDAAsD;IACtD,OAAO,CACL,KAAK,CAAC,OAAO,EACb,uCAAuC,EACvC,QAAQ,CACT,CAAC;IACF,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,eAAe,CAAC,uCAAuC,CAAC,CAAC;IACrE,CAAC;IAED,sEAAsE;IACtE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,eAAe,CACvB,6CAA6C,CAC9C,CAAC;IACJ,CAAC;IAED,0EAA0E;IAC1E,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACvC,MAAM,IAAI,eAAe,CACvB,gDAAgD,CACjD,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,eAAe,CACvB,mDAAmD,CACpD,CAAC;IACJ,CAAC;IACD,yBAAyB,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAEhD,OAAO,aAAa,CAClB,kBAAkB,EAClB,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,CAEF,SAAyC;YAEzC,OAAO,gBAAgB,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;QACzD,CAAC;KACF,CACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,24 @@
+export interface CredentialCreateProps {
+    /** The issuer of the credential. */
+    Account: string;
+    /** The subject of the credential. */
+    Subject: string;
+    /** Hex-encoded credential type, 1–64 bytes. */
+    CredentialType: string;
+    /** Optional expiration (seconds since Ripple Epoch). */
+    Expiration?: number | undefined;
+    /** Optional hex-encoded URI, 1–256 bytes. */
+    URI?: string | undefined;
+    /** Bit-flags for this transaction. (No flags are defined for this tx.) */
+    Flags?: number | undefined;
+    Fee?: string | undefined;
+    Sequence?: number | undefined;
+}
+export interface CredentialCreate extends Readonly<CredentialCreateProps> {
+    readonly TransactionType: 'CredentialCreate';
+    validate(): void;
+    toJSON(): Record<string, unknown>;
+    with(overrides: Partial<CredentialCreateProps>): CredentialCreate;
+}
+export declare function credentialCreate(props: CredentialCreateProps): CredentialCreate;
+//# sourceMappingURL=credential-create.d.ts.map

package/dist/fp/factories/credential-create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-create.d.ts","sourceRoot":"","sources":["../../../src/fp/factories/credential-create.ts"],"names":[],"mappings":"AAkHA,MAAM,WAAW,qBAAqB;IACpC,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,cAAc,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,6CAA6C;IAC7C,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,gBACf,SAAQ,QAAQ,CAAC,qBAAqB,CAAC;IACvC,QAAQ,CAAC,eAAe,EAAE,kBAAkB,CAAC;IAC7C,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG,gBAAgB,CAAC;CACnE;AA8ED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,qBAAqB,GAC3B,gBAAgB,CAoElB"}