@integraledger/lcp-binding-canton-x402 0.9.0

package/dist/constants.js

@@ -0,0 +1,47 @@
+/**
+ * Canton / Daml constants for the LCP transfer-memo binding.
+ *
+ * **Canton has a native arbitrary-bytes carrier, and this binding uses it.** x402's `exact` scheme for
+ * Canton defines `PaymentRequirements.extra.memo` — "Seller-defined UTF-8 string, max 256 bytes. When
+ * present, the client MUST include it in the transfer's metadata" — and its facilitator rule 12 rejects
+ * `invalid_exact_canton_memo_mismatch` when the transfer metadata does not carry the identical value under
+ * `x402.memo`. Seller-committed, payer-echoed, facilitator-verified, and riding the same transaction as
+ * the value.
+ *
+ * Daml is often said to have no native arbitrary-bytes carrier — no memo, no metadata label, no nonce. That
+ * is true of the LEDGER's own primitives and false of a payment settled through x402, which is why this
+ * rail exists beside `@integraledger/lcp-binding-canton`'s overlay contract rather than instead of it.
+ */
+/**
+ * The transfer-metadata key the facilitator compares against `extra.memo`. The host's, read exactly: a
+ * metadata map carrying our value under a different key is a transfer no facilitator checked.
+ */
+export const CANTON_X402_MEMO_KEY = "x402.memo";
+/** The scheme's stated ceiling for `extra.memo`. A canonical atrHash is 66 UTF-8 bytes. */
+export const CANTON_X402_MEMO_MAX_BYTES = 256;
+const SANDBOX = {
+    network: "sandbox",
+    explorerBase: "http://localhost:7500",
+    caip2: "canton:sandbox",
+};
+const DEVNET = {
+    network: "devnet",
+    explorerBase: "https://scan.global.dev.sync.global",
+    caip2: "canton:devnet",
+};
+const MAINNET = {
+    network: "mainnet",
+    explorerBase: "https://scan.sync.global",
+    caip2: "canton:mainnet",
+};
+/** The constants for one environment. Which Canton rail you want is the real choice: this one only reaches
+ *  payments settled through x402's Canton-Coin scheme, and `@integraledger/lcp-binding-canton`'s overlay
+ *  covers everything else. */
+export function getCantonX402Config(network) {
+    if (network === "sandbox")
+        return SANDBOX;
+    if (network === "devnet")
+        return DEVNET;
+    return MAINNET;
+}
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,WAAW,CAAC;AAEhD,2FAA2F;AAC3F,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAC;AAe9C,MAAM,OAAO,GAA4B;IACvC,OAAO,EAAE,SAAS;IAClB,YAAY,EAAE,uBAAuB;IACrC,KAAK,EAAE,gBAAgB;CACxB,CAAC;AAEF,MAAM,MAAM,GAA4B;IACtC,OAAO,EAAE,QAAQ;IACjB,YAAY,EAAE,qCAAqC;IACnD,KAAK,EAAE,eAAe;CACvB,CAAC;AAEF,MAAM,OAAO,GAA4B;IACvC,OAAO,EAAE,SAAS;IAClB,YAAY,EAAE,0BAA0B;IACxC,KAAK,EAAE,gBAAgB;CACxB,CAAC;AAEF;;8BAE8B;AAC9B,MAAM,UAAU,mBAAmB,CACjC,OAA0B;IAE1B,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,OAAO,CAAC;IAC1C,IAAI,OAAO,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC;IACxC,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { type CantonX402Adapter, type CantonX402Reader, type CantonX402ReaderConfig, type CantonX402Settlement, type CantonX402SettlementRef, type CantonX402TransferView, createCantonX402Adapter, makeCantonX402Reader, } from "./adapter.js";
+export { CANTON_X402_MEMO_KEY, CANTON_X402_MEMO_MAX_BYTES, type CantonX402Network, type CantonX402NetworkConfig, getCantonX402Config, } from "./constants.js";
+export { CANTON_X402_MANIFEST } from "./manifest.js";
+export { decodeTransferMemo, encodeTransferMemo, readTransferMemoAtrHash, x402MemoRequirement, } from "./memo.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { createCantonX402Adapter, makeCantonX402Reader, } from "./adapter.js";
+export { CANTON_X402_MEMO_KEY, CANTON_X402_MEMO_MAX_BYTES, getCantonX402Config, } from "./constants.js";
+export { CANTON_X402_MANIFEST } from "./manifest.js";
+export { decodeTransferMemo, encodeTransferMemo, readTransferMemoAtrHash, x402MemoRequirement, } from "./memo.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAG1B,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,WAAW,CAAC"}

package/dist/manifest.d.ts

@@ -0,0 +1,62 @@
+import type { BindingManifest } from "@integraledger/lcp-binding-core";
+/**
+ * The Canton transfer-memo binding manifest.
+ *
+ * **pattern = "native-field"** (canonical LCP §8.3.1). x402's `exact` scheme for Canton defines
+ * `PaymentRequirements.extra.memo` — "Seller-defined UTF-8 string, max 256 bytes. When present, the
+ * client MUST include it in the transfer's metadata" — and its facilitator safety check 12 rejects
+ * `invalid_exact_canton_memo_mismatch` unless the transfer metadata carries the identical value under
+ * `x402.memo`. The atrHash therefore rides a field the host defined, on the transaction that moves the
+ * money.
+ *
+ * **THIS IS A SECOND CANTON RAIL, NOT A REPLACEMENT.** `@integraledger/lcp-binding-canton` binds the same
+ * chain through an `LcpAnchor` overlay contract, and it is not obsolete: x402's exact-Canton scheme
+ * settles **Canton Coin only** ("`asset`: `\"CC\"`. Settles Canton Coin only", instrument fixed to
+ * `Amulet`, via `transfer-factory`, relayed by a facilitator). Every other Canton deployment — any
+ * instrument, any synchronizer, DvP and fund and bond workflows, no facilitator — still has no native
+ * field to ride, and the overlay is the only carrier there.
+ *
+ * Where BOTH apply, this one wins on every axis: the weld rides the SAME transaction as the payment
+ * rather than a separate contract create; it is enforced by the facilitator rather than by nobody; and it
+ * binds the asset rather than declaring `assetBinding: "none"`. That is LCP §8.3's own ordering, and it is
+ * why the overlay's docblock now says it is an overlay by CHOICE rather than by necessity — the claim that
+ * Daml has no native arbitrary-bytes carrier was simply false.
+ *
+ * One chain, two carriers, two bindings, for the same reason EVM has three (`evm:x402`, `evm:escrow`,
+ * `evm:mpp`): a manifest can honestly describe exactly one carrier.
+ *
+ * **protocol = "x402"**, and the declaration is substantive. `extra.memo` is x402's field, its 256-byte
+ * ceiling is x402's ceiling, and the enforcement is an x402 facilitator's. A deployment settling Canton
+ * Coin outside x402 does not get this carrier, and saying so is the point of the axis: an absent
+ * `protocol` is a positive claim of protocol-neutrality, which this binding cannot make.
+ *
+ * **assetBinding = "carried"** — the memo rides a `TransferFactory_Transfer` whose own fields name the
+ * receiver, the amount and the instrument, and `CantonX402TransferView` carries all three to the caller. That
+ * is the axis's actual test: not that the value exists on-chain, but that a consumer can reach it. The
+ * overlay could not, which is why it honestly said `"none"`.
+ *
+ * **recovery.zeroPartyRecoverable = false** — unchanged, and for the unchanged reason. Daml contract and
+ * transaction visibility is limited to stakeholders, so a neutral verifier holding only a settlement
+ * reference sees nothing until the payer, the merchant or the DSO grants access. §8.3 asks whether an
+ * auditor can reconstruct the atrHash from the settlement reference alone WITHOUT trusting either party to
+ * produce records; on Canton they cannot, whichever carrier is used. WLD-3 makes the direction of the
+ * error normative — understating costs nothing, overstating is non-conformance.
+ *
+ * **recovery.forwardIndexable = false** — a participant's update stream is one participant's view, not a
+ * chain-global forward index, and the memo is a metadata value rather than an indexed key. Honest for the
+ * same reason the overlay's participant query was.
+ *
+ * **successGate = "structural"** — a Canton transfer that did not commit produces no update, so there is
+ * no failed view whose memo could be misread as a settlement. The transfer either executed and its
+ * metadata exists, or it did not and nothing does.
+ *
+ * **weldGrades["x402-memo"] = "tx"** — the memo is committed by the payer's signed
+ * `TransferFactory_Transfer`, not by a detached signature over the atrHash bytes. The payer signs the
+ * prepared transaction (which contains the memo), so the commitment rides the transaction. Per LCP §8.3 /
+ * WLD-3 that is tx-grade.
+ *
+ * **finality.reversible = false** — once the transfer executes, its input holdings are consumed and Canton
+ * has no reversal; recourse is the record's elected forum (PAY-3/RCS-5), never dispute resolution.
+ */
+export declare const CANTON_X402_MANIFEST: BindingManifest;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAmBlC,CAAC"}

package/dist/manifest.js

@@ -0,0 +1,81 @@
+import { CANTON_X402_MEMO_KEY } from "./constants.js";
+/**
+ * The Canton transfer-memo binding manifest.
+ *
+ * **pattern = "native-field"** (canonical LCP §8.3.1). x402's `exact` scheme for Canton defines
+ * `PaymentRequirements.extra.memo` — "Seller-defined UTF-8 string, max 256 bytes. When present, the
+ * client MUST include it in the transfer's metadata" — and its facilitator safety check 12 rejects
+ * `invalid_exact_canton_memo_mismatch` unless the transfer metadata carries the identical value under
+ * `x402.memo`. The atrHash therefore rides a field the host defined, on the transaction that moves the
+ * money.
+ *
+ * **THIS IS A SECOND CANTON RAIL, NOT A REPLACEMENT.** `@integraledger/lcp-binding-canton` binds the same
+ * chain through an `LcpAnchor` overlay contract, and it is not obsolete: x402's exact-Canton scheme
+ * settles **Canton Coin only** ("`asset`: `\"CC\"`. Settles Canton Coin only", instrument fixed to
+ * `Amulet`, via `transfer-factory`, relayed by a facilitator). Every other Canton deployment — any
+ * instrument, any synchronizer, DvP and fund and bond workflows, no facilitator — still has no native
+ * field to ride, and the overlay is the only carrier there.
+ *
+ * Where BOTH apply, this one wins on every axis: the weld rides the SAME transaction as the payment
+ * rather than a separate contract create; it is enforced by the facilitator rather than by nobody; and it
+ * binds the asset rather than declaring `assetBinding: "none"`. That is LCP §8.3's own ordering, and it is
+ * why the overlay's docblock now says it is an overlay by CHOICE rather than by necessity — the claim that
+ * Daml has no native arbitrary-bytes carrier was simply false.
+ *
+ * One chain, two carriers, two bindings, for the same reason EVM has three (`evm:x402`, `evm:escrow`,
+ * `evm:mpp`): a manifest can honestly describe exactly one carrier.
+ *
+ * **protocol = "x402"**, and the declaration is substantive. `extra.memo` is x402's field, its 256-byte
+ * ceiling is x402's ceiling, and the enforcement is an x402 facilitator's. A deployment settling Canton
+ * Coin outside x402 does not get this carrier, and saying so is the point of the axis: an absent
+ * `protocol` is a positive claim of protocol-neutrality, which this binding cannot make.
+ *
+ * **assetBinding = "carried"** — the memo rides a `TransferFactory_Transfer` whose own fields name the
+ * receiver, the amount and the instrument, and `CantonX402TransferView` carries all three to the caller. That
+ * is the axis's actual test: not that the value exists on-chain, but that a consumer can reach it. The
+ * overlay could not, which is why it honestly said `"none"`.
+ *
+ * **recovery.zeroPartyRecoverable = false** — unchanged, and for the unchanged reason. Daml contract and
+ * transaction visibility is limited to stakeholders, so a neutral verifier holding only a settlement
+ * reference sees nothing until the payer, the merchant or the DSO grants access. §8.3 asks whether an
+ * auditor can reconstruct the atrHash from the settlement reference alone WITHOUT trusting either party to
+ * produce records; on Canton they cannot, whichever carrier is used. WLD-3 makes the direction of the
+ * error normative — understating costs nothing, overstating is non-conformance.
+ *
+ * **recovery.forwardIndexable = false** — a participant's update stream is one participant's view, not a
+ * chain-global forward index, and the memo is a metadata value rather than an indexed key. Honest for the
+ * same reason the overlay's participant query was.
+ *
+ * **successGate = "structural"** — a Canton transfer that did not commit produces no update, so there is
+ * no failed view whose memo could be misread as a settlement. The transfer either executed and its
+ * metadata exists, or it did not and nothing does.
+ *
+ * **weldGrades["x402-memo"] = "tx"** — the memo is committed by the payer's signed
+ * `TransferFactory_Transfer`, not by a detached signature over the atrHash bytes. The payer signs the
+ * prepared transaction (which contains the memo), so the commitment rides the transaction. Per LCP §8.3 /
+ * WLD-3 that is tx-grade.
+ *
+ * **finality.reversible = false** — once the transfer executes, its input holdings are consumed and Canton
+ * has no reversal; recourse is the record's elected forum (PAY-3/RCS-5), never dispute resolution.
+ */
+export const CANTON_X402_MANIFEST = {
+    rail: "canton:x402",
+    pattern: "native-field",
+    protocol: "x402",
+    nativeField: CANTON_X402_MEMO_KEY,
+    recovery: {
+        onChain: true,
+        zeroPartyRecoverable: false,
+        forwardIndexable: false,
+    },
+    assetBinding: "carried",
+    successGate: "structural",
+    indexing: `participant-updates:transfer.meta.${CANTON_X402_MEMO_KEY}`,
+    finality: {
+        reversible: false,
+        note: "a Canton transfer consumes the input holdings it names and Canton has no reversal, so an executed transfer's memo is permanent; recourse is the record's elected forum (PAY-3/RCS-5), never dispute resolution",
+    },
+    weldGrades: { "x402-memo": "tx" },
+    lifecycleStates: ["proposed", "settled"],
+};
+//# sourceMappingURL=manifest.js.map

package/dist/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAoB;IACnD,IAAI,EAAE,aAAa;IACnB,OAAO,EAAE,cAAc;IACvB,QAAQ,EAAE,MAAM;IAChB,WAAW,EAAE,oBAAoB;IACjC,QAAQ,EAAE;QACR,OAAO,EAAE,IAAI;QACb,oBAAoB,EAAE,KAAK;QAC3B,gBAAgB,EAAE,KAAK;KACxB;IACD,YAAY,EAAE,SAAS;IACvB,WAAW,EAAE,YAAY;IACzB,QAAQ,EAAE,qCAAqC,oBAAoB,EAAE;IACrE,QAAQ,EAAE;QACR,UAAU,EAAE,KAAK;QACjB,IAAI,EAAE,gNAAgN;KACvN;IACD,UAAU,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE;IACjC,eAAe,EAAE,CAAC,UAAU,EAAE,SAAS,CAAC;CACzC,CAAC"}

package/dist/memo.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The `extra` fragment a Canton seller merges into its x402 `PaymentRequirements`.
+ *
+ * Returned as an object rather than a bare string so the call site reads as what it is — the seller
+ * ADVERTISING a value it is committing to — and so a future scheme field can join it without changing
+ * every caller. Mirrors `binding-tempo-mpp`'s `mppMethodDetailsMemo`.
+ */
+export declare function x402MemoRequirement(atrHash: string): {
+    readonly memo: string;
+};
+/**
+ * The memo string carrying `atrHash`: the canonical `0x`-prefixed lowercase form, verbatim.
+ *
+ * No bare-hex variant is emitted or accepted. The host calls this a "seller-defined UTF-8 string" and
+ * compares it byte-for-byte against the transfer metadata, so any second spelling would be a second wire
+ * value that a facilitator would reject against the first.
+ */
+export declare function encodeTransferMemo(atrHash: string): string;
+/** Decode a memo string back to an atrHash, or `null` if it is not a well-formed one. */
+export declare function decodeTransferMemo(memo: string): `0x${string}` | null;
+/**
+ * Read the atrHash out of a transfer's on-ledger metadata map, or `null` if it carries none.
+ *
+ * The key is the host's — `x402.memo`, quoted in rule 12 above — and it is read EXACTLY. A metadata map
+ * carrying our value under some other key is a transfer that no facilitator checked, so treating it as a
+ * weld would assert a commitment nobody made.
+ */
+export declare function readTransferMemoAtrHash(meta: Readonly<Record<string, string>> | undefined): `0x${string}` | null;
+//# sourceMappingURL=memo.d.ts.map

package/dist/memo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo.d.ts","sourceRoot":"","sources":["../src/memo.ts"],"names":[],"mappings":"AAqCA;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAEA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,yFAAyF;AACzF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,GAAG,IAAI,CAErE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,GACjD,KAAK,MAAM,EAAE,GAAG,IAAI,CAItB"}

package/dist/memo.js

@@ -0,0 +1,73 @@
+/**
+ * The Canton transfer-memo atrHash codec — PURE, no Daml SDK, no HTTP.
+ *
+ * **THE CARRIER.** x402's `exact` scheme for Canton defines `PaymentRequirements.extra.memo`:
+ *
+ * > `extra.memo` (optional): Seller-defined UTF-8 string, max 256 bytes. When present, the client MUST
+ * > include it in the transfer's metadata.
+ *
+ * and makes it facilitator-enforced (scheme §Safety Checks, rule 12):
+ *
+ * > **Memo.** If `paymentRequirements.extra.memo` is set, the transfer metadata MUST carry the identical
+ * > value under `x402.memo`. Reject with `invalid_exact_canton_memo_mismatch`.
+ *
+ * So the SELLER names the value, the PAYER must echo it into the transfer that moves the money, and a
+ * THIRD PARTY refuses to relay the payment if they disagree. That is a §8.3.1 Native Field with an
+ * unusually strong commitment story, and it rides the same transaction as the value — which is what the
+ * overlay it replaces could never do.
+ *
+ * **WHY THIS CARRIER AND NOT AN OVERLAY CONTRACT.** Canton's other binding,
+ * `@integraledger/lcp-binding-canton`, welds through a custom `LcpAnchor` Daml template. Where this scheme
+ * applies, the memo is stronger on every axis: it rides the SAME transaction as the payment rather than a
+ * separate contract create, the facilitator checks it before relaying, and the transfer's own fields name
+ * the asset. LCP §8.3's ordering puts Overlay Contract below Native Field for exactly these reasons. The
+ * overlay covers what this scheme cannot reach — it settles Canton Coin only.
+ *
+ * **THE 256-BYTE CEILING NEEDS NO RUNTIME CHECK.** A canonical atrHash is exactly 66 UTF-8 bytes and the
+ * host allows 256, so a length guard here could never fire — it would be an unreachable branch asserting
+ * a fact the type of the input already settles. `CANTON_X402_MEMO_MAX_BYTES` records the host's limit and
+ * `constants.test.ts` proves an atrHash fits inside it; that is where a fact about the host belongs.
+ *
+ * `encodeTransferMemo` fails LOUD on a malformed atrHash (never advertise a memo we could not later
+ * verify); `decodeTransferMemo` returns `null` for anything that is not one, so a scan over a party's
+ * transfers can skip foreign memos without treating them as errors.
+ */
+import { canonicalAtrHash, isAtrHash } from "@integraledger/lcp-kernel";
+import { CANTON_X402_MEMO_KEY } from "./constants.js";
+/**
+ * The `extra` fragment a Canton seller merges into its x402 `PaymentRequirements`.
+ *
+ * Returned as an object rather than a bare string so the call site reads as what it is — the seller
+ * ADVERTISING a value it is committing to — and so a future scheme field can join it without changing
+ * every caller. Mirrors `binding-tempo-mpp`'s `mppMethodDetailsMemo`.
+ */
+export function x402MemoRequirement(atrHash) {
+    return { memo: encodeTransferMemo(atrHash) };
+}
+/**
+ * The memo string carrying `atrHash`: the canonical `0x`-prefixed lowercase form, verbatim.
+ *
+ * No bare-hex variant is emitted or accepted. The host calls this a "seller-defined UTF-8 string" and
+ * compares it byte-for-byte against the transfer metadata, so any second spelling would be a second wire
+ * value that a facilitator would reject against the first.
+ */
+export function encodeTransferMemo(atrHash) {
+    return canonicalAtrHash(atrHash, "encodeTransferMemo");
+}
+/** Decode a memo string back to an atrHash, or `null` if it is not a well-formed one. */
+export function decodeTransferMemo(memo) {
+    return isAtrHash(memo) ? canonicalAtrHash(memo, "decodeTransferMemo") : null;
+}
+/**
+ * Read the atrHash out of a transfer's on-ledger metadata map, or `null` if it carries none.
+ *
+ * The key is the host's — `x402.memo`, quoted in rule 12 above — and it is read EXACTLY. A metadata map
+ * carrying our value under some other key is a transfer that no facilitator checked, so treating it as a
+ * weld would assert a commitment nobody made.
+ */
+export function readTransferMemoAtrHash(meta) {
+    // `?? ""` rather than an `undefined` branch: an absent key and a foreign memo are the same answer, and
+    // "" is not a well-formed atrHash, so the decoder already gives it.
+    return decodeTransferMemo(meta?.[CANTON_X402_MEMO_KEY] ?? "");
+}
+//# sourceMappingURL=memo.js.map

package/dist/memo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo.js","sourceRoot":"","sources":["../src/memo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAAe;IAGjD,OAAO,EAAE,IAAI,EAAE,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC;AAC/C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAe;IAChD,OAAO,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC;AACzD,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAkD;IAElD,uGAAuG;IACvG,oEAAoE;IACpE,OAAO,kBAAkB,CAAC,IAAI,EAAE,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC,CAAC;AAChE,CAAC"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@integraledger/lcp-binding-canton-x402",
+  "version": "0.9.0",
+  "description": "Welds an ATR hash into a Canton Coin settlement over x402's exact scheme.",
+  "keywords": [
+    "lcp",
+    "legal-context-protocol",
+    "legal-terms",
+    "agentic-commerce",
+    "settlement",
+    "atr-hash",
+    "canton",
+    "daml",
+    "x402"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/IntegraLedger/integra-protocol.git",
+    "directory": "packages/binding-canton-x402"
+  },
+  "bugs": {
+    "url": "https://github.com/IntegraLedger/integra-protocol/issues"
+  },
+  "homepage": "https://github.com/IntegraLedger/integra-protocol/tree/main/packages/binding-canton-x402#readme",
+  "dependencies": {
+    "@integraledger/lcp-kernel": "0.9.0",
+    "@integraledger/lcp-binding-core": "0.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.3",
+    "vitest": "4.1.10"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}