@ouronet/ouronet-core 4.3.6

package/dist/interactions/dexTrueFungibleFunctions.js

@@ -0,0 +1,220 @@
+/**
+ * dexTrueFungibleFunctions.ts
+ * True Fungible (TF) entity reads — LP entries, header, entries, native/frozen LP, button state, swpair lookup.
+ */
+import { KADENA_NAMESPACE } from "../constants/index.js";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+export async function getTrueFungibleLPEntry(account, swpair, izNative) {
+    try {
+        const boolStr = izNative ? "true" : "false";
+        const pactCode = izNative
+            ? `(${KADENA_NAMESPACE}.DPL-UR.URC_0008b_TrueFungibleLPEntry "${account}" "${swpair}" ${boolStr})`
+            : `(try false (${KADENA_NAMESPACE}.DPL-UR.URC_0008b_TrueFungibleLPEntry "${account}" "${swpair}" ${boolStr}))`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (!izNative && (typeof data === "boolean" || data === false))
+            return null;
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch (error) {
+        getLogger().error("Error in getTrueFungibleLPEntry:", error);
+        return null;
+    }
+}
+export async function getLPEntries(account, swpair) {
+    const [native, frozen] = await Promise.all([
+        getTrueFungibleLPEntry(account, swpair, true),
+        getTrueFungibleLPEntry(account, swpair, false),
+    ]);
+    return { native, frozen };
+}
+/**
+ * Fetch swap pairs owned by a specific Ouronet resident account.
+ * Returns a list of swpair IDs that the account can manage.
+ */
+export async function getOwnedSwapPairs(account) {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.SWP.URD_OwnedSwapPairs "${account}")`, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return [];
+        const data = response.result.data;
+        if (Array.isArray(data))
+            return data;
+        return [];
+    }
+    catch (error) {
+        getLogger().error("Error in getOwnedSwapPairs:", error);
+        return [];
+    }
+}
+/**
+ * Fetch True Fungible header data for an account.
+ * Returns global TF count, held TF list/count, managed TF list/count.
+ */
+export async function getTrueFungibleHeader(account) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0016_TruefungibleHeader "${account}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0016_TruefungibleHeader failed:", err);
+        return null;
+    }
+}
+/**
+ * Batch-fetch TrueFungibleEntry data for multiple token IDs using the chain mapper function.
+ * Works for Native, Frozen, and Reserved tokens (not LP).
+ * Uses URC_0008a_TrueFungibleEntryMapper(account, dptfs:[string])
+ */
+export async function getTrueFungibleEntries(account, tokenIds) {
+    if (tokenIds.length === 0)
+        return [];
+    try {
+        const listItems = tokenIds.map(id => `"${id}"`).join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0008a_TrueFungibleEntryMapper "${account}" [${listItems}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return tokenIds.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return tokenIds.map(() => null);
+        return data.map((item) => {
+            if (!item || typeof item !== "object" || item === false)
+                return null;
+            return item;
+        });
+    }
+    catch (err) {
+        getLogger().error("URC_0008a_TrueFungibleEntryMapper failed:", err);
+        return tokenIds.map(() => null);
+    }
+}
+/**
+ * Batch-fetch Native LP entry data using the chain mapper function.
+ * Uses URC_0008b_TrueFungibleNativeLPMapper(account, lp-ids:[string])
+ * Accepts LP token IDs directly — chain resolves swpairs internally.
+ */
+export async function getNativeLPEntries(account, lpIds) {
+    if (lpIds.length === 0)
+        return [];
+    try {
+        const listItems = lpIds.map(id => `"${id}"`).join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0008b_TrueFungibleNativeLPMapper "${account}" [${listItems}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return lpIds.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return lpIds.map(() => null);
+        return data.map((item) => {
+            if (!item || typeof item !== "object" || item === false)
+                return null;
+            return item;
+        });
+    }
+    catch (err) {
+        getLogger().error("URC_0008b_TrueFungibleNativeLPMapper failed:", err);
+        return lpIds.map(() => null);
+    }
+}
+/**
+ * Batch-fetch Frozen LP entry data using the chain mapper function.
+ * Uses URC_0008b_TrueFungibleFrozenLPMapper(account, lp-ids:[string])
+ * Accepts LP token IDs directly — chain resolves swpairs internally.
+ */
+export async function getFrozenLPEntries(account, lpIds) {
+    if (lpIds.length === 0)
+        return [];
+    try {
+        const listItems = lpIds.map(id => `"${id}"`).join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0008b_TrueFungibleFrozenLPMapper "${account}" [${listItems}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return lpIds.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return lpIds.map(() => null);
+        return data.map((item) => {
+            if (!item || typeof item !== "object" || item === false)
+                return null;
+            return item;
+        });
+    }
+    catch (err) {
+        getLogger().error("URC_0008b_TrueFungibleFrozenLPMapper failed:", err);
+        return lpIds.map(() => null);
+    }
+}
+/**
+ * Get the SWP-Pair ID from an LP token ID.
+ * Uses SWP.UR_GetLpSwpair on chain.
+ */
+export async function getSwpairFromLpId(lpId) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.SWP.UR_GetLpSwpair "${lpId}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (typeof data !== "string")
+            return null;
+        return data;
+    }
+    catch (error) {
+        getLogger().error("Error in getSwpairFromLpId:", error);
+        return null;
+    }
+}
+/**
+ * Batch-fetch SWP-Pair IDs for multiple LP token IDs using a single Pact (map ...) call.
+ */
+export async function getSwpairsFromLpIds(lpIds) {
+    if (lpIds.length === 0)
+        return [];
+    try {
+        const listItems = lpIds.map(id => `"${id}"`).join(" ");
+        const pactCode = `(map (lambda (lid:string) (try "" (${KADENA_NAMESPACE}.SWP.UR_GetLpSwpair lid))) [${listItems}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return lpIds.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return lpIds.map(() => null);
+        return data.map((v) => (typeof v === "string" && v !== "" ? v : null));
+    }
+    catch (error) {
+        getLogger().error("Error in getSwpairsFromLpIds:", error);
+        return lpIds.map(() => null);
+    }
+}
+/**
+ * Fetch button enable/disable state for a specific token held by an account.
+ * Uses URC_0017_TruefungibleButton(account, dptf)
+ */
+export async function getTrueFungibleButtonState(account, dptfId) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0017_TruefungibleButton "${account}" "${dptfId}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0017_TruefungibleButton failed:", err);
+        return null;
+    }
+}

package/dist/interactions/dexTypes.d.ts

@@ -0,0 +1,465 @@
+/**
+ * dexTypes.ts
+ * Cross-cutting interface and type-alias definitions for the DEX entity files.
+ * Sole non-local re-export: IKadenaKeypair from @stoachain/stoa-core/signing.
+ */
+export type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+import type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+export interface IOuroAccountKeypair {
+    readonly address: string;
+    readonly publicKey: string;
+    readonly privateKey?: string;
+}
+export interface DecimalValue {
+    readonly decimal: string;
+}
+export interface SwapPoolData {
+    readonly "liquid-fee": number;
+    readonly "lp-fee": number;
+    readonly "lp-supply": DecimalValue;
+    readonly "special-fee": number;
+    readonly "special-fee-targets-short": readonly string[];
+    readonly "pool-value-in-dwk": DecimalValue;
+    readonly "special-fee-targets": readonly string[];
+    readonly "tvl-in-$": string;
+    readonly "lp-value-in-$": string;
+    readonly "pool-type": string;
+    readonly "special-fee-targets-proportions": readonly number[];
+    readonly "pool-type-word": string;
+    readonly "pool-token-supplies": readonly DecimalValue[];
+    readonly "lp-value-in-dwk": DecimalValue;
+    readonly "total-fee": number;
+    readonly "pool-tokens": readonly string[];
+}
+export interface PoolPreviewData {
+    readonly "liquid-fee": number;
+    readonly "lp-fee": number;
+    readonly "lp-supply": DecimalValue;
+    readonly "special-fee": number;
+    readonly "special-fee-targets-short": readonly string[];
+    readonly "pool-value-in-dwk": DecimalValue;
+    readonly "special-fee-targets": readonly string[];
+    readonly "tvl-in-$": string;
+    readonly "lp-value-in-$": string;
+    readonly "pool-type": string;
+    readonly "special-fee-targets-proportions": readonly number[];
+    readonly "pool-type-word": string;
+    readonly "pool-token-supplies": readonly DecimalValue[];
+    readonly "lp-value-in-dwk": DecimalValue;
+    readonly "total-fee": number;
+    readonly "pool-tokens": readonly string[];
+    readonly "ft-pool-value-in-dwk": string;
+    readonly "ft-lp-supply": string;
+    readonly "ft-lp-value-in-dwk": string;
+    readonly "ft-pool-token-supplies": readonly string[];
+    readonly "weigths": readonly number[];
+}
+export interface SwpairInternalDashboard {
+    readonly "special-fee-target-proportions": readonly number[];
+    readonly "primality": string;
+    readonly "liquid-fee": number;
+    readonly "lp-fee": number;
+    readonly "lp-supply": DecimalValue;
+    readonly "special-fee": number;
+    readonly "ft-pool-value-in-dwk": string;
+    readonly "special-fee-targets-short": readonly string[];
+    readonly "pool-value-in-dwk": DecimalValue;
+    readonly "special-fee-targets": readonly string[];
+    readonly "tvl-in-$": string;
+    readonly "fee-lockup": string;
+    readonly "swapping-enabled": string;
+    readonly "ft-lp-supply": string;
+    readonly "genesis-supplies": readonly number[];
+    readonly "liquidity-enabled": string;
+    readonly "genesis-weights": readonly number[];
+    readonly "lp-value-in-$": string;
+    readonly "pool-type": string;
+    readonly "amplifier": number;
+    readonly "ft-genesis-supplies": readonly string[];
+    readonly "pool-type-word": string;
+    readonly "ft-lp-value-in-dwk": string;
+    readonly "pool-token-supplies": readonly DecimalValue[];
+    readonly "ft-pool-token-supplies": readonly string[];
+    readonly "lp-value-in-dwk": DecimalValue;
+    readonly "fee-unlocks": {
+        readonly "int": number;
+    };
+    readonly "weigths": readonly number[];
+    readonly "frozen-and-sleeping": string;
+    readonly "total-fee": number;
+    readonly "pool-tokens": readonly string[];
+}
+export interface SwapCalculationResult {
+    readonly "output-amount": string;
+    readonly "to-liquidity-providers": readonly string[];
+    readonly "to-liquid-boost": string;
+    readonly "to-special-targets": string;
+}
+export interface InverseSwapResult {
+    readonly [key: string]: any;
+}
+export interface CappedInverseResult {
+    readonly decimal: string;
+}
+export interface UserAccountSupplies {
+    readonly [key: string]: any;
+}
+export interface SwapLiquidityProviderItem {
+    readonly token: string;
+    readonly amount: number;
+}
+export interface SwapLiquidityProviderItemPrecise {
+    readonly token: string;
+    readonly amount: string;
+}
+export interface SwapExecutionParams {
+    readonly patronKeypair: IOuroAccountKeypair;
+    readonly kadenaKeypair: IKadenaKeypair;
+    readonly guardKeypair: IKadenaKeypair;
+    readonly account: string;
+    readonly swpair: string;
+    readonly outputId: string;
+}
+/**
+ * Slippage bounds object returned by SWPU.UDC_SpawnSlippageBounds
+ */
+export interface SlippageBounds {
+    readonly "expected-output-amount": number;
+    readonly "output-precision": number;
+    readonly "slippage-percent": number;
+}
+/**
+ * Return type for SmartSwap hopper preview
+ */
+export interface SmartSwapHopper {
+    readonly "output-amount"?: any;
+    readonly "best-output"?: any;
+    readonly "output"?: any;
+    readonly "hops"?: number | {
+        readonly int: number;
+    };
+    readonly "trace"?: readonly string[];
+    readonly "nodes"?: readonly string[];
+    readonly "edges"?: readonly string[];
+    readonly [key: string]: any;
+}
+/**
+ * Return type for SmartSwap slippage bounds
+ */
+export interface SmartSwapSlippageBounds {
+    readonly "expected-output-amount": DecimalValue | number;
+    readonly "output-precision": {
+        readonly int: number;
+    } | number;
+    readonly "slippage-percent": DecimalValue | number;
+}
+/**
+ * SmartSwap execution params
+ */
+export interface SmartSwapExecutionParams {
+    readonly patronKeypair: IOuroAccountKeypair;
+    readonly kadenaKeypair: IKadenaKeypair;
+    readonly guardKeypair: IKadenaKeypair;
+    readonly account: string;
+    readonly inputId: string;
+    readonly inputAmount: string | number;
+    readonly outputId: string;
+    readonly slippage?: number;
+}
+/** Response shape from URC_0008b_TrueFungibleLPEntry */
+export interface TrueFungibleLPEntry {
+    readonly t1: string;
+    readonly t2: string;
+    readonly "wallet-supply": {
+        readonly decimal: string;
+    } | number;
+    readonly "dptf-supply": {
+        readonly decimal: string;
+    } | number;
+    readonly "wallet-worth-in-stoa": {
+        readonly decimal: string;
+    } | number;
+    readonly "wallet-worth-in-dollarz": string;
+    readonly "token-worth-in-stoa": {
+        readonly decimal: string;
+    } | number;
+    readonly "token-worth-in-dollarz": string;
+}
+/**
+ * Response shape from URC_0016_TruefungibleHeader
+ */
+export interface TrueFungibleHeaderData {
+    readonly "total-true-fungible-number": number | {
+        readonly int: number;
+    };
+    readonly "held-tf": readonly string[];
+    readonly "held-tf-number": number | {
+        readonly int: number;
+    };
+    readonly "mngd-tf": readonly string[];
+    readonly "mngd-tf-number": number | {
+        readonly int: number;
+    };
+}
+/**
+ * Response shape from URC_0008a_TrueFungibleEntry (Native/Frozen/Reserved tokens)
+ */
+export interface TrueFungibleEntryData {
+    readonly t1: string;
+    readonly t2: string;
+    readonly "wallet-supply": {
+        readonly decimal: string;
+    } | number;
+    readonly "dptf-supply": {
+        readonly decimal: string;
+    } | number;
+    readonly "wallet-worth-in-stoa": {
+        readonly decimal: string;
+    } | number;
+    readonly "wallet-worth-in-dollarz": string;
+    readonly "token-worth-in-stoa": {
+        readonly decimal: string;
+    } | number;
+    readonly "token-worth-in-dollarz": string;
+}
+/**
+ * Response shape from URC_0017_TruefungibleButton
+ * Boolean per action key — true = button enabled, false = disabled.
+ * where-* keys provide target pool info for coil/curl/constrict/brumate.
+ */
+export interface TrueFungibleButtonState {
+    readonly mint: boolean;
+    readonly burn: boolean;
+    readonly wipe: boolean;
+    readonly unfold: boolean;
+    readonly freeze: boolean;
+    readonly reserve: boolean;
+    readonly vest: boolean;
+    readonly sleep: boolean;
+    readonly hibernate: boolean;
+    readonly coil: boolean;
+    readonly curl: boolean;
+    readonly constrict: boolean;
+    readonly brumate: boolean;
+    readonly recover: boolean;
+    readonly sublimate: boolean;
+    readonly compress: boolean;
+    readonly transmute: boolean;
+    readonly unwrap: boolean;
+    readonly transfer: boolean;
+    readonly "where-coil"?: any;
+    readonly "where-curl"?: any;
+    readonly "where-constrict"?: any;
+    readonly "where-brumate"?: any;
+}
+export interface OrtoFungibleHeaderData {
+    readonly "total-orto-fungible-number": number | {
+        readonly int: number;
+    };
+    readonly "total-orto-fungible-nonces": number | {
+        readonly int: number;
+    };
+    readonly "held-of": readonly string[];
+    readonly "held-of-number": number | {
+        readonly int: number;
+    };
+    readonly "mngd-of": readonly string[];
+    readonly "mngd-of-number": number | {
+        readonly int: number;
+    };
+}
+/**
+ * OrtoFungible token category, classified from the token-id prefix:
+ * Sleeping LP: Z|S|, Z|W|, Z|P|
+ * Vesting:     V|
+ * Sleeping:    Z| (but NOT Z|S|, Z|W|, Z|P|)
+ * Hibernating: H|
+ * Native:      everything else
+ */
+export type OrtoFungibleCategory = "native" | "vesting" | "sleeping" | "hibernating" | "sleeping-lp";
+/**
+ * Response shape from URC_0009a_OrtoFungibleEntryMapper
+ * Same as TrueFungibleEntryData but with extra "wallet-nonces" field.
+ */
+export interface OrtoFungibleEntryData {
+    readonly t1: string;
+    readonly t2: string;
+    readonly "wallet-supply": {
+        readonly decimal: string;
+    } | number;
+    readonly "dpof-supply": {
+        readonly decimal: string;
+    } | number;
+    readonly "wallet-worth-in-stoa": {
+        readonly decimal: string;
+    } | number;
+    readonly "wallet-worth-in-dollarz": string;
+    readonly "token-worth-in-stoa": {
+        readonly decimal: string;
+    } | number;
+    readonly "token-worth-in-dollarz": string;
+    readonly "wallet-nonces": readonly number[];
+    readonly "wallet-nonces-no": number | {
+        readonly int: number;
+    };
+}
+/**
+ * Hibernating nonce data — custom metadata for hibernating tokens.
+ * Returns: { dptf-id, nonce-supply, mint-time, release-time, hibernating-fee-promile, remainder, hibernating-fee }
+ */
+export interface HibernatingNonceData {
+    readonly "dptf-id": string;
+    readonly "nonce-supply": {
+        readonly decimal: string;
+    } | number;
+    readonly "mint-time": string;
+    readonly "release-time": string;
+    readonly "hibernating-fee-promile": {
+        readonly decimal: string;
+    } | number;
+    readonly "remainder": {
+        readonly decimal: string;
+    } | number;
+    readonly "hibernating-fee": {
+        readonly decimal: string;
+    } | number;
+}
+export interface OrtofungibleButtonState {
+    readonly transfer: boolean;
+    readonly transmit: boolean;
+    readonly redeem: boolean;
+    readonly "reverse-hrbt": boolean;
+    readonly unvest: boolean;
+    readonly unsleep: boolean;
+    readonly merge: boolean;
+    readonly awake: boolean;
+    readonly slumber: boolean;
+    readonly wipe: boolean;
+    readonly burn: boolean;
+    readonly mint: boolean;
+    readonly "add-quantity": boolean;
+    readonly [key: string]: boolean;
+}
+export interface CollectablesHeaderData {
+    readonly "total-semi-fungible-number": number | {
+        readonly int: number;
+    };
+    readonly "total-semi-fungible-nonces": number | {
+        readonly int: number;
+    };
+    readonly "held-sf": readonly string[];
+    readonly "held-sf-number": number | {
+        readonly int: number;
+    };
+    readonly "mngd-sf": readonly string[];
+    readonly "mngd-sf-no": number | {
+        readonly int: number;
+    };
+    readonly "total-non-fungible-number": number | {
+        readonly int: number;
+    };
+    readonly "total-non-fungible-nonces": number | {
+        readonly int: number;
+    };
+    readonly "held-nf": readonly string[];
+    readonly "held-nf-number": number | {
+        readonly int: number;
+    };
+    readonly "mngd-nf": readonly string[];
+    readonly "mngd-nf-no": number | {
+        readonly int: number;
+    };
+}
+export interface CollectableNonceEntry {
+    readonly nonce: number | {
+        readonly int: number;
+    };
+    readonly supply: number | {
+        readonly decimal: string;
+    } | {
+        readonly int: number;
+    };
+}
+export interface CollectableEntryData {
+    readonly t1: string;
+    readonly t2: string;
+    readonly "wallet-nonces": readonly CollectableNonceEntry[];
+    readonly "wallet-nonces-no": number | {
+        readonly int: number;
+    };
+}
+export interface NonceMetaData {
+    readonly score: number;
+    readonly composition: readonly number[];
+    readonly "meta-data": Readonly<Record<string, any>>;
+}
+export interface URIType {
+    readonly image: boolean;
+    readonly audio: boolean;
+    readonly video: boolean;
+    readonly document: boolean;
+    readonly archive: boolean;
+    readonly model: boolean;
+    readonly exotic: boolean;
+}
+export interface URIData {
+    readonly image: string;
+    readonly audio: string;
+    readonly video: string;
+    readonly document: string;
+    readonly archive: string;
+    readonly model: string;
+    readonly exotic: string;
+}
+export interface NonceData {
+    readonly royalty: number;
+    readonly ignis: number;
+    readonly name: string;
+    readonly description: string;
+    readonly "meta-data": NonceMetaData;
+    readonly "asset-type": URIType;
+    readonly "uri-primary": URIData;
+    readonly "uri-secondary": URIData;
+    readonly "uri-tertiary": URIData;
+}
+export interface SetAllowedNonceForPosition {
+    readonly "allowed-nonces": readonly number[] | ReadonlyArray<number | {
+        readonly int: number;
+    }>;
+}
+export interface SetAllowedClassForPosition {
+    readonly "allowed-sclass": number | {
+        readonly int: number;
+    };
+}
+export interface SetDefinition {
+    readonly "set-class": number | {
+        readonly int: number;
+    };
+    readonly "set-name": string;
+    readonly "set-score-multiplier": number | {
+        readonly decimal: string;
+    };
+    readonly "nonce-of-set": number | {
+        readonly int: number;
+    };
+    readonly "iz-active": boolean;
+    readonly "primordial": boolean;
+    readonly "composite": boolean;
+    readonly "primordial-set-definition": readonly SetAllowedNonceForPosition[];
+    readonly "composite-set-definition": readonly SetAllowedClassForPosition[];
+    readonly "nonce-data": any;
+    readonly "split-data": any;
+}
+export interface CollectablesButtonState {
+    readonly morph: boolean;
+    readonly "add-quantity": boolean;
+    readonly burn: boolean;
+    readonly respawn: boolean;
+    readonly wipe: boolean;
+    readonly fuse: boolean;
+    readonly split: boolean;
+    readonly "break-set": boolean;
+    readonly transfer: boolean;
+    readonly [key: string]: boolean;
+}

package/dist/interactions/dexTypes.js

@@ -0,0 +1,6 @@
+/**
+ * dexTypes.ts
+ * Cross-cutting interface and type-alias definitions for the DEX entity files.
+ * Sole non-local re-export: IKadenaKeypair from @stoachain/stoa-core/signing.
+ */
+export {};

package/dist/interactions/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Typed error for shape mismatches in Kadena RPC envelopes.
+ *
+ * Mirrors `InvalidEnvelopeError` (stoa-core/signing/partialSig.ts): extends
+ * Error (NOT TypeError — TypeError is reserved for input-validation seam
+ * errors), uses ES2022 Error.cause for original-envelope propagation.
+ */
+export declare class KadenaShapeError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}