@sorandomains/holder 0.3.1 → 0.5.0

package/dist/native-types.d.ts

@@ -0,0 +1,166 @@
+import { xdr } from "@stellar/stellar-sdk";
+import { type PaymentDestination } from "./payment.js";
+export type ClaimAdmission = {
+    type: "open";
+} | {
+    type: "allowlist";
+    root: string;
+} | {
+    type: "approval";
+    account: string;
+};
+export type ClaimSettings = {
+    mode: "manual" | "public";
+    enabled: boolean;
+    admission: ClaimAdmission;
+    feeToken: string;
+    feeAmount: bigint;
+    feeRecipient: string;
+    walletLimit: bigint;
+    approvalAllowance: bigint;
+    approvalRateLimit: bigint;
+    approvalWindowSecs: bigint;
+    approvalTtlSecs: bigint;
+};
+export type ClaimConfig = {
+    settings: ClaimSettings;
+    ownerEpoch: bigint;
+    policyVersion: bigint;
+    grantEpoch: bigint;
+};
+export type RequestContext = {
+    network: string;
+    registry: string;
+    registrar: string;
+    namespace: string;
+    requestId: string;
+    validAfter: bigint;
+    deadline: bigint;
+};
+export type ClaimIntent = {
+    context: RequestContext;
+    label: string;
+    claimant: string;
+    destination: PaymentDestination;
+    resolver: string;
+    expectedGeneration: bigint | null;
+    expectedExpiry: bigint | null;
+    termSecs: bigint;
+    ownerEpoch: bigint;
+    policyVersion: bigint;
+    grantEpoch: bigint;
+    feeToken: string;
+    feeAmount: bigint;
+    feeRecipient: string;
+};
+export type ReservedIntent = {
+    context: RequestContext;
+    label: string;
+    holder: string;
+    destination: PaymentDestination;
+    resolver: string;
+    expectedGeneration: bigint | null;
+    expectedExpiry: bigint | null;
+    termSecs: bigint;
+    ownerEpoch: bigint;
+    policyVersion: bigint;
+};
+export type TransferIntent = {
+    context: RequestContext;
+    label: string;
+    from: string;
+    to: string;
+    expectedGeneration: bigint;
+    expectedExpiry: bigint;
+    proposalExpires: bigint;
+    destination: PaymentDestination;
+    resolver: string;
+};
+export type RenewIntent = {
+    context: RequestContext;
+    label: string;
+    holder: string;
+    expectedGeneration: bigint;
+    expectedExpiry: bigint;
+    termSecs: bigint;
+    minNewExpiry: bigint;
+    maxNewExpiry: bigint;
+};
+export type ClaimReceipt = {
+    operation: "claim" | "reserved" | "transfer" | "renew";
+    intentHash: string;
+    node: string;
+    holder: string;
+    generation: bigint;
+    expiresAt: bigint;
+    feeAmount: bigint;
+    feeToken: string;
+    feeRecipient: string | null;
+    ledger: number;
+    timestamp: bigint;
+};
+export type ClaimResult = {
+    status: "fresh" | "replayed";
+    receipt: ClaimReceipt;
+};
+export type ClaimUsage = {
+    publicClaims: bigint;
+    reservedIssues: bigint;
+};
+export type ApprovalUsage = {
+    total: bigint;
+    windowUsed: bigint;
+    windowEnds: bigint;
+};
+export type ClaimQuote = {
+    network: string;
+    registry: string;
+    registrar: string;
+    namespace: string;
+    resolver: string;
+    label: string;
+    node: string;
+    claimant: string;
+    config: ClaimConfig | null;
+    ownerEpoch: bigint;
+    policyVersion: bigint;
+    available: boolean;
+    reserved: boolean;
+    generation: bigint | null;
+    expiresAt: bigint | null;
+    termSecs: bigint;
+    now: bigint;
+    usage: ClaimUsage;
+    approvalUsage: ApprovalUsage;
+};
+export type DestinationPreview = {
+    node: string;
+    holder: string;
+    generation: bigint;
+    expiresAt: bigint;
+    active: boolean;
+    destination: PaymentDestination;
+};
+export declare function claimSettingsToScVal(value: ClaimSettings): xdr.ScVal;
+export declare const claimPolicyInputToScVal: typeof claimSettingsToScVal;
+export declare const claimLabelToScVal: (value: string) => xdr.ScVal;
+export declare const claimConfigFromNative: (value: unknown) => ClaimConfig;
+export declare const claimQuoteFromNative: (value: unknown) => ClaimQuote;
+export declare const claimUsageFromNative: (value: unknown) => ClaimUsage;
+export declare const approvalUsageFromNative: (value: unknown) => ApprovalUsage;
+export declare const destinationPreviewFromNative: (value: unknown) => DestinationPreview;
+export declare const claimReceiptFromNative: (value: unknown) => ClaimReceipt;
+export declare function claimIntentToScVal(value: ClaimIntent): xdr.ScVal;
+export declare function reservedIntentToScVal(value: ReservedIntent): xdr.ScVal;
+export declare function transferIntentToScVal(value: TransferIntent): xdr.ScVal;
+export declare function renewIntentToScVal(value: RenewIntent): xdr.ScVal;
+export declare const claimIntentFromNative: (value: unknown) => ClaimIntent;
+export declare const transferIntentFromNative: (value: unknown) => TransferIntent;
+export declare const renewIntentFromNative: (value: unknown) => RenewIntent;
+export declare function claimResultFromNative(value: unknown): ClaimResult;
+export declare function nativeIntentHash(method: "claim" | "issue_reserved_with_destination" | "accept_transfer_with_destination" | "renew_holder", value: xdr.ScVal): string;
+/** Lossless public recovery JSON; only declared bigint fields receive the tagged encoding. */
+export declare function stringifyNativeIntent(value: ClaimIntent | TransferIntent | RenewIntent | ReservedIntent): string;
+export declare function parseNativeClaimIntent(json: string): ClaimIntent;
+export declare function parseNativeTransferIntent(json: string): TransferIntent;
+export declare function parseNativeRenewIntent(json: string): RenewIntent;

package/dist/native-types.js

@@ -0,0 +1,98 @@
+import { hash, scValToNative, xdr } from "@stellar/stellar-sdk";
+import { destinationFromNative } from "./payment.js";
+import { NativeClaimError, address, amount, bool, bytes32, exactObject, hex, hex32, label, paymentDestinationToScVal, sc, struct, u32, u64, unhex, utf8 } from "./native-codec.js";
+const primitive = (validate, encode) => ({ encode: v => encode(validate(v)), decode: validate });
+const U64 = primitive(v => u64(v, "u64 field"), sc.u64), U32 = primitive(v => u32(v, "u32 field"), sc.u32), AMOUNT = primitive(v => amount(v, "fee amount"), sc.i128), BOOL = primitive(v => bool(v, "boolean field"), sc.bool);
+const ACCOUNT = primitive(v => address(v, "account", "account"), sc.address), CONTRACT = primitive(v => address(v, "contract", "contract"), sc.address), IDENTITY = primitive(v => address(v, "identity", "identity"), sc.address);
+const HEX = { encode: v => sc.bytes(unhex(hex32(v, "bytes32 field"))), decode: v => hex(bytes32(v, "bytes32 field")) };
+const LABEL = { encode: v => sc.bytes(utf8(label(v))), decode: v => { if (!(v instanceof Uint8Array))
+        throw new NativeClaimError("label must be on-chain Bytes"); return label(new TextDecoder("utf-8", { fatal: true }).decode(v)); } };
+const DESTINATION = { encode: v => paymentDestinationToScVal(v), decode: destinationFromNative };
+const optional = (inner) => ({ encode: v => v === null ? sc.option(null) : inner.encode(v), decode: v => v === null || v === undefined ? null : inner.decode(v) });
+const enumeration = (mapping) => ({ encode: v => { if (typeof v !== "string" || !Object.hasOwn(mapping, v))
+        throw new NativeClaimError("unsupported enum value"); return xdr.ScVal.scvVec([sc.symbol(mapping[v])]); }, decode: v => { if (!Array.isArray(v) || v.length !== 1)
+        throw new NativeClaimError("invalid enum result"); const entry = Object.entries(mapping).find(([, tag]) => tag === v[0]); if (!entry)
+        throw new NativeClaimError("unknown enum tag"); return entry[0]; } });
+const ADMISSION = { encode: v => { if (!v || typeof v !== "object")
+        throw new NativeClaimError("invalid admission"); const a = v; if (a.type === "open") {
+        exactObject(a, ["type"], "open admission");
+        return xdr.ScVal.scvVec([sc.symbol("Open")]);
+    } if (a.type === "allowlist") {
+        exactObject(a, ["type", "root"], "allowlist admission");
+        return xdr.ScVal.scvVec([sc.symbol("Allowlist"), HEX.encode(a.root)]);
+    } if (a.type === "approval") {
+        exactObject(a, ["type", "account"], "approval admission");
+        return xdr.ScVal.scvVec([sc.symbol("Approval"), ACCOUNT.encode(a.account)]);
+    } throw new NativeClaimError("unsupported admission"); }, decode: v => { if (!Array.isArray(v))
+        throw new NativeClaimError("invalid admission enum"); if (v.length === 1 && v[0] === "Open")
+        return { type: "open" }; if (v.length === 2 && v[0] === "Allowlist")
+        return { type: "allowlist", root: HEX.decode(v[1]) }; if (v.length === 2 && v[0] === "Approval")
+        return { type: "approval", account: ACCOUNT.decode(v[1]) }; throw new NativeClaimError("unknown admission enum"); } };
+const snake = (s) => s.replace(/[A-Z]/g, c => "_" + c.toLowerCase());
+function model(fields) { return { encode: v => { const value = exactObject(v, Object.keys(fields), "native input"); return struct(Object.fromEntries(Object.entries(fields).map(([name, codec]) => [snake(name), codec.encode(value[name])]))); }, decode: v => { const value = exactObject(v, Object.keys(fields).map(snake), "native result"); return Object.fromEntries(Object.entries(fields).map(([name, codec]) => [name, codec.decode(value[snake(name)])])); } }; }
+const SETTINGS = model({ mode: enumeration({ manual: "Manual", public: "Public" }), enabled: BOOL, admission: ADMISSION, feeToken: CONTRACT, feeAmount: AMOUNT, feeRecipient: ACCOUNT, walletLimit: U64, approvalAllowance: U64, approvalRateLimit: U64, approvalWindowSecs: U64, approvalTtlSecs: U64 });
+const CONFIG = model({ settings: SETTINGS, ownerEpoch: U64, policyVersion: U64, grantEpoch: U64 });
+const CONTEXT = model({ network: HEX, registry: CONTRACT, registrar: CONTRACT, namespace: HEX, requestId: HEX, validAfter: U64, deadline: U64 });
+const CLAIM = model({ context: CONTEXT, label: LABEL, claimant: ACCOUNT, destination: DESTINATION, resolver: CONTRACT, expectedGeneration: optional(U64), expectedExpiry: optional(U64), termSecs: U64, ownerEpoch: U64, policyVersion: U64, grantEpoch: U64, feeToken: CONTRACT, feeAmount: AMOUNT, feeRecipient: ACCOUNT });
+const RESERVED = model({ context: CONTEXT, label: LABEL, holder: ACCOUNT, destination: DESTINATION, resolver: CONTRACT, expectedGeneration: optional(U64), expectedExpiry: optional(U64), termSecs: U64, ownerEpoch: U64, policyVersion: U64 });
+const TRANSFER = model({ context: CONTEXT, label: LABEL, from: IDENTITY, to: ACCOUNT, expectedGeneration: U64, expectedExpiry: U64, proposalExpires: U64, destination: DESTINATION, resolver: CONTRACT });
+const RENEW = model({ context: CONTEXT, label: LABEL, holder: ACCOUNT, expectedGeneration: U64, expectedExpiry: U64, termSecs: U64, minNewExpiry: U64, maxNewExpiry: U64 });
+const USAGE = model({ publicClaims: U64, reservedIssues: U64 }), APPROVAL_USAGE = model({ total: U64, windowUsed: U64, windowEnds: U64 });
+const CONFIG_STATE = { encode: v => v === null ? xdr.ScVal.scvVec([sc.symbol("Unconfigured")]) : xdr.ScVal.scvVec([sc.symbol("Configured"), CONFIG.encode(v)]), decode: v => { if (!Array.isArray(v))
+        throw new NativeClaimError("invalid claim config state"); if (v.length === 1 && v[0] === "Unconfigured")
+        return null; if (v.length === 2 && v[0] === "Configured")
+        return CONFIG.decode(v[1]); throw new NativeClaimError("invalid claim config state"); } };
+const QUOTE = model({ network: HEX, registry: CONTRACT, registrar: CONTRACT, namespace: HEX, resolver: CONTRACT, label: LABEL, node: HEX, claimant: ACCOUNT, config: CONFIG_STATE, ownerEpoch: U64, policyVersion: U64, available: BOOL, reserved: BOOL, generation: optional(U64), expiresAt: optional(U64), termSecs: U64, now: U64, usage: USAGE, approvalUsage: APPROVAL_USAGE });
+const RECEIPT = model({ operation: enumeration({ claim: "Claim", reserved: "Reserved", transfer: "Transfer", renew: "Renew" }), intentHash: HEX, node: HEX, holder: IDENTITY, generation: U64, expiresAt: U64, feeAmount: AMOUNT, feeToken: CONTRACT, feeRecipient: optional(ACCOUNT), ledger: U32, timestamp: U64 });
+const PREVIEW = model({ node: HEX, holder: IDENTITY, generation: U64, expiresAt: U64, active: BOOL, destination: DESTINATION });
+export function claimSettingsToScVal(value) {
+    const encoded = SETTINGS.encode(value);
+    if (value.admission.type === "approval") {
+        if (value.approvalAllowance === 0n || value.approvalRateLimit === 0n || value.approvalWindowSecs === 0n || value.approvalWindowSecs > 31536000n || value.approvalTtlSecs === 0n || value.approvalTtlSecs > 3600n)
+            throw new NativeClaimError("approval mode requires explicit bounded admission budgets, window and lifetime");
+        if (value.admission.account === value.feeRecipient)
+            throw new NativeClaimError("eligibility account must differ from fee treasury");
+    }
+    else if (value.approvalAllowance !== 0n || value.approvalRateLimit !== 0n || value.approvalWindowSecs !== 0n || value.approvalTtlSecs !== 0n)
+        throw new NativeClaimError("approval settings must be zero outside approval mode");
+    return encoded;
+}
+export const claimPolicyInputToScVal = claimSettingsToScVal;
+export const claimLabelToScVal = (value) => LABEL.encode(value);
+export const claimConfigFromNative = (value) => CONFIG.decode(value);
+export const claimQuoteFromNative = (value) => QUOTE.decode(value);
+export const claimUsageFromNative = (value) => USAGE.decode(value);
+export const approvalUsageFromNative = (value) => APPROVAL_USAGE.decode(value);
+export const destinationPreviewFromNative = (value) => PREVIEW.decode(value);
+export const claimReceiptFromNative = (value) => RECEIPT.decode(value);
+function validContext(c) { if (c.deadline <= c.validAfter || c.deadline - c.validAfter > 3600n)
+    throw new NativeClaimError("business intent lifetime must be positive and at most 3600 seconds"); }
+export function claimIntentToScVal(value) { const result = CLAIM.encode(value); validContext(value.context); if ((value.expectedGeneration === null) !== (value.expectedExpiry === null))
+    throw new NativeClaimError("generation and expiry expectations must both be present or absent"); return result; }
+export function reservedIntentToScVal(value) { const result = RESERVED.encode(value); validContext(value.context); if ((value.expectedGeneration === null) !== (value.expectedExpiry === null))
+    throw new NativeClaimError("generation and expiry expectations must both be present or absent"); return result; }
+export function transferIntentToScVal(value) { const result = TRANSFER.encode(value); validContext(value.context); return result; }
+export function renewIntentToScVal(value) { const result = RENEW.encode(value); validContext(value.context); if (value.termSecs === 0n || value.maxNewExpiry < value.minNewExpiry)
+    throw new NativeClaimError("invalid renewal bounds"); return result; }
+export const claimIntentFromNative = (value) => CLAIM.decode(value);
+export const transferIntentFromNative = (value) => TRANSFER.decode(value);
+export const renewIntentFromNative = (value) => RENEW.decode(value);
+export function claimResultFromNative(value) { if (!Array.isArray(value) || value.length !== 2 || !["Fresh", "Replayed"].includes(value[0]))
+    throw new NativeClaimError("invalid claim result"); return { status: value[0] === "Fresh" ? "fresh" : "replayed", receipt: claimReceiptFromNative(value[1]) }; }
+export function nativeIntentHash(method, value) { return hex(hash(xdr.ScVal.scvVec([sc.symbol(method), value]).toXDR())); }
+/** Lossless public recovery JSON; only declared bigint fields receive the tagged encoding. */
+export function stringifyNativeIntent(value) { return JSON.stringify(value, (_key, v) => typeof v === "bigint" ? { $u64: v.toString() } : v); }
+export function parseNativeClaimIntent(json) { if (json.length > 16384)
+    throw new NativeClaimError("claim recovery reference is too large"); const raw = JSON.parse(json, (_key, v) => { if (v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).join(",") === "$u64") {
+    if (typeof v.$u64 !== "string" || !/^(0|[1-9][0-9]*)$/.test(v.$u64))
+        throw new NativeClaimError("invalid recovery integer");
+    return BigInt(v.$u64);
+} return v; }); return claimIntentFromNative(scValToNative(claimIntentToScVal(raw))); }
+export function parseNativeTransferIntent(json) { return parseLifecycleIntent(json, TRANSFER, transferIntentToScVal); }
+export function parseNativeRenewIntent(json) { return parseLifecycleIntent(json, RENEW, renewIntentToScVal); }
+function parseLifecycleIntent(json, codec, encode) { if (json.length > 16384)
+    throw new NativeClaimError("lifecycle intent is too large"); const raw = JSON.parse(json, (_key, v) => { if (v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).join(",") === "$u64") {
+    if (typeof v.$u64 !== "string" || !/^(0|[1-9][0-9]*)$/.test(v.$u64))
+        throw new NativeClaimError("invalid recovery integer");
+    return BigInt(v.$u64);
+} return v; }); return codec.decode(scValToNative(encode(raw))); }

package/dist/payment.d.ts

@@ -1,4 +1,4 @@
-/** Payment wire format v1. Kept identical in the independently published lookup
+/** Direct v1 and muxed v2 payment records. Kept identical in the independently published lookup
  * and holder packages; the conformance tests exercise both copies. */
 import { xdr } from "@stellar/stellar-sdk";
 export declare const PAYMENT_RECORD_KEY = "payment";
@@ -26,3 +26,12 @@ export declare function parsePaymentRecord(raw: string): PaymentDestination;
 export declare function paymentMemoToScVal(memo: PaymentMemo): xdr.ScVal;
 /** Decode Soroban contract enum values, checking arity and native types. */
 export declare function paymentFromNative(raw: unknown): PaymentDestination;
+/** Decode a full muxed destination without treating its operation ID as a memo. */
+export declare function decodeMuxedAddress(address: string): {
+    account: string;
+    id: string;
+};
+/** Encode only canonical G + exact decimal u64; numbers are never accepted. */
+export declare function encodeMuxedAddress(account: string, id: string): string;
+/** Strict additive on-chain destination enum; v1 payment structs stay separate. */
+export declare function destinationFromNative(raw: unknown): PaymentDestination;

package/dist/payment.js

@@ -1,4 +1,4 @@
-/** Payment wire format v1. Kept identical in the independently published lookup
+/** Direct v1 and muxed v2 payment records. Kept identical in the independently published lookup
  * and holder packages; the conformance tests exercise both copies. */
 import { StrKey, nativeToScVal, xdr } from "@stellar/stellar-sdk";
 export const PAYMENT_RECORD_KEY = "payment";
@@ -11,14 +11,16 @@ export function validatePaymentDestination(value) {
     const p = value;
     if (Object.keys(p).sort().join(",") !== "address,memo")
         throw new Error("unexpected payment fields");
-    if (typeof p.address !== "string" || (!StrKey.isValidEd25519PublicKey(p.address) && !StrKey.isValidContract(p.address)))
-        throw new Error("payment address must be a valid G or C address");
+    if (typeof p.address !== "string" || (!StrKey.isValidEd25519PublicKey(p.address) && !StrKey.isValidContract(p.address) && !StrKey.isValidMed25519PublicKey(p.address)))
+        throw new Error("payment address must be a valid G, C or M address");
     if (!p.memo || typeof p.memo !== "object" || Array.isArray(p.memo))
         throw new Error("invalid memo");
     const m = p.memo;
     if (m.type === "none") {
         if (Object.keys(m).join(",") !== "type")
             throw new Error("none memo cannot have a value");
+        if (StrKey.isValidMed25519PublicKey(p.address))
+            decodeMuxedAddress(p.address);
         return { address: p.address, memo: { type: "none" } };
     }
     if (!StrKey.isValidEd25519PublicKey(p.address))
@@ -45,6 +47,10 @@ export function validatePaymentDestination(value) {
 }
 export function encodePaymentRecord(value) {
     const p = validatePaymentDestination(value);
+    if (StrKey.isValidMed25519PublicKey(p.address)) {
+        const muxed = decodeMuxedAddress(p.address);
+        return `2|${muxed.account}|muxed|${muxed.id}`;
+    }
     return `1|${p.address}|${p.memo.type}|${p.memo.type === "none" ? "" : p.memo.value}`;
 }
 /** Empty/missing records are not explicit payment instructions. */
@@ -54,11 +60,16 @@ export function parsePaymentRecord(raw) {
     const first = raw.indexOf("|");
     const second = raw.indexOf("|", first + 1);
     const third = raw.indexOf("|", second + 1);
-    if (first < 0 || second < 0 || third < 0 || raw.slice(0, first) !== "1")
+    if (first < 0 || second < 0 || third < 0)
         throw new Error("unsupported payment record");
+    const version = raw.slice(0, first);
     const address = raw.slice(first + 1, second);
     const type = raw.slice(second + 1, third);
     const value = raw.slice(third + 1);
+    if (version === "2" && type === "muxed")
+        return { address: encodeMuxedAddress(address, value), memo: { type: "none" } };
+    if (version !== "1" || (!StrKey.isValidEd25519PublicKey(address) && !StrKey.isValidContract(address)))
+        throw new Error("unsupported payment record");
     if (type === "none" && value !== "")
         throw new Error("none memo cannot have a value");
     return validatePaymentDestination({ address, memo: type === "none" ? { type } : { type, value } });
@@ -79,6 +90,8 @@ export function paymentFromNative(raw) {
     const p = raw;
     if (Object.keys(p).sort().join(",") !== "address,memo" || !Array.isArray(p.memo))
         throw new Error("invalid payment result fields");
+    if (typeof p.address !== "string" || (!StrKey.isValidEd25519PublicKey(p.address) && !StrKey.isValidContract(p.address)))
+        throw new Error("direct payment must contain a G or C address");
     const m = p.memo;
     let memo;
     if (m.length === 1 && m[0] === "None")
@@ -93,3 +106,43 @@ export function paymentFromNative(raw) {
         throw new Error("invalid payment memo result");
     return validatePaymentDestination({ address: p.address, memo });
 }
+/** Decode a full muxed destination without treating its operation ID as a memo. */
+export function decodeMuxedAddress(address) {
+    if (typeof address !== "string" || !StrKey.isValidMed25519PublicKey(address))
+        throw new Error("invalid muxed M address");
+    const raw = StrKey.decodeMed25519PublicKey(address);
+    if (raw.length !== 40 || StrKey.encodeMed25519PublicKey(raw) !== address)
+        throw new Error("noncanonical muxed address");
+    let id = 0n;
+    for (const byte of raw.subarray(32))
+        id = (id << 8n) | BigInt(byte);
+    return { account: StrKey.encodeEd25519PublicKey(raw.subarray(0, 32)), id: id.toString() };
+}
+/** Encode only canonical G + exact decimal u64; numbers are never accepted. */
+export function encodeMuxedAddress(account, id) {
+    if (typeof account !== "string" || !StrKey.isValidEd25519PublicKey(account))
+        throw new Error("muxed base must be a G account");
+    if (typeof id !== "string" || !/^(0|[1-9][0-9]{0,19})$/.test(id) || BigInt(id) > MAX_U64)
+        throw new Error("muxed ID must be canonical decimal u64");
+    const raw = new Uint8Array(40);
+    raw.set(StrKey.decodeEd25519PublicKey(account));
+    let value = BigInt(id);
+    for (let i = 39; i >= 32; i--) {
+        raw[i] = Number(value & 255n);
+        value >>= 8n;
+    }
+    return StrKey.encodeMed25519PublicKey(raw);
+}
+/** Strict additive on-chain destination enum; v1 payment structs stay separate. */
+export function destinationFromNative(raw) {
+    if (!Array.isArray(raw) || raw.length !== 2)
+        throw new Error("invalid destination enum");
+    if (raw[0] === "Direct")
+        return paymentFromNative(raw[1]);
+    if (raw[0] !== "Muxed" || !raw[1] || typeof raw[1] !== "object" || Array.isArray(raw[1]))
+        throw new Error("invalid destination variant");
+    const value = raw[1];
+    if (Object.keys(value).sort().join(",") !== "account,id" || typeof value.account !== "string" || typeof value.id !== "bigint")
+        throw new Error("invalid muxed destination fields");
+    return { address: encodeMuxedAddress(value.account, value.id.toString()), memo: { type: "none" } };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorandomains/holder",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Manage your own Soran name on Stellar \u2014 records, profile, reverse, primary, and transfers, signed by your key.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,7 +19,7 @@
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "tsc",
     "check:browser": "esbuild dist/index.js --bundle --platform=browser --external:@stellar/stellar-sdk --outfile=browser-check.js --legal-comments=none --log-level=error && node -e \"const fs=require('fs');const s=fs.readFileSync('browser-check.js','utf8');fs.unlinkSync('browser-check.js');if(/\\bBuffer\\b/.test(s)){console.error('FAIL: bare Buffer reference in browser bundle');process.exit(1)}console.log('browser bundle clean')\"",
-    "test": "node --import tsx test/decode-failure.test.mts && node --import tsx --test test/payment.test.mts test/integration.test.mts"
+    "test": "node --import tsx test/decode-failure.test.mts && node --import tsx --test test/integration.test.mts test/payment.test.mts test/muxed.test.mts test/native-*.test.mts"
   },
   "license": "MIT",
   "repository": {