@epoch-protocol/epoch-commons-sdk 0.1.18 → 0.1.20

package/dist/data/epochgraphtestnet.json

@@ -70,7 +70,7 @@
             "contractAddress": {
                 "Base": "0x2BB4FfD7E2c6D432b697554Efd77fA13bdbefd69",
                 "Mainnet": "0x2BB4FfD7E2c6D432b697554Efd77fA13bdbefd69",
-                "Miden": "0xfc90f0f4da30e51168453b60eafed7",
+                "Miden": "0x537c15a622074e91188aa894456c52",
                 "Optimism": "0x2BB4FfD7E2c6D432b697554Efd77fA13bdbefd69"
             },
             "decimals": 18,
@@ -83,7 +83,7 @@
                 "Base": "0xc30f1Ce05d1434d484E9A47283aA925fc8A8699a",
                 "Mainnet": "0xc30f1Ce05d1434d484E9A47283aA925fc8A8699a",
                 "Optimism": "0xc30f1Ce05d1434d484E9A47283aA925fc8A8699a",
-                "Miden": "0x176275876f2fd41103257e341832b9"
+                "Miden": "0xd17976f0809a8191412f2a126625df"
             },
             "decimals": 18,
             "decimalsByChain": {
@@ -94,7 +94,7 @@
             "contractAddress": {
                 "Base": "0xc04d2869665Be874881133943523723Be5782720",
                 "Mainnet": "0xc04d2869665Be874881133943523723Be5782720",
-                "Miden": "0x7725b0e9bb9406912d2ebeaeb05f4d",
+                "Miden": "0x6500ca8c2dd69e9147ab7eafad162c",
                 "Optimism": "0xc04d2869665Be874881133943523723Be5782720"
             },
             "decimals": 18,
@@ -107,7 +107,7 @@
                 "Base": "0x7946dd86eE310D0aC16804A37787289Fa5b88A8A",
                 "Mainnet": "0x7946dd86eE310D0aC16804A37787289Fa5b88A8A",
                 "Optimism": "0x7946dd86eE310D0aC16804A37787289Fa5b88A8A",
-                "Miden": "0xa54717f6bd3210d128aeeaa8a2b7f3"
+                "Miden": "0x4a09f13153d9cd114c078bfb62a7ec"
             },
             "decimals": 18,
             "decimalsByChain": {
@@ -119,7 +119,7 @@
                 "Base": "0x9b2a2754a9182fD65360E23afCDf3BeFF51796E9",
                 "Mainnet": "0x9b2a2754a9182fD65360E23afCDf3BeFF51796E9",
                 "Optimism": "0x9b2a2754a9182fD65360E23afCDf3BeFF51796E9",
-                "Miden": "0x151823cde4b7bd91352617729d7614"
+                "Miden": "0x5fd2e6fd17712c51404d09c2b847f7"
             },
             "decimals": 18,
             "decimalsByChain": {

package/dist/types/index.d.ts

@@ -279,6 +279,11 @@ export type QueuedTransactionForIntent = {
     transactionHash: string | null;
     /** EIP-7702 authorization list for relay txs (enable delegation). */
     authorizationList?: Record<string, unknown>[];
+    /**
+     * Compact / Miden reservation keys so the queue worker can finalize those
+     * reservations on SUCCESS or FAILED.
+     */
+    processedCompactKeys?: string[];
 };
 export type CompactDataForQueue = {
     intentNonce: string;

package/dist/utils/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./compact.js";
+export * from "./miden-intent.js";
 export * from "./path.js";
 export * from "./witness-typestring.js";

package/dist/utils/index.js

@@ -1,3 +1,4 @@
 export * from "./compact.js";
+export * from "./miden-intent.js";
 export * from "./path.js";
 export * from "./witness-typestring.js";

package/dist/utils/miden-intent.d.ts

@@ -0,0 +1,29 @@
+import { EVM_TO_MIDEN_EXTRA_TYPESTRING, EVM_TO_MIDEN_FIELD_NAMES, MIDEN_MARKER_FIELD_NAMES, MIDEN_TO_EVM_EXTRA_TYPESTRING, MIDEN_TO_EVM_FIELD_NAMES } from "./witness-typestring.js";
+export type MidenBridgeDirection = "miden-to-evm" | "evm-to-miden";
+export interface MidenExtraData {
+    midenSourceAccount?: string;
+    midenRecipientAccount?: string;
+    midenFaucetId?: string;
+    midenNoteType?: string;
+    midenNoteId?: string;
+}
+/** True when mandate/extra data carries any Miden bridge marker field. */
+export declare function hasMidenMarkersInData(data?: Record<string, unknown>): boolean;
+/** True when a witness/extra typestring declares any Miden bridge marker field. */
+export declare function hasMidenMarkersInTypestring(typestring: string): boolean;
+/**
+ * True iff the intent is a Miden bridge intent (markers in typestring and/or data).
+ * At least one of `typestring` or `data` must be provided.
+ */
+export declare function isMidenIntent(typestring?: string, data?: Record<string, unknown>): boolean;
+/** EVM→Miden: recipient set, source account absent. */
+export declare function isEVMToMidenIntent(data?: Record<string, unknown>): boolean;
+/** Miden→EVM: source account set. */
+export declare function isMidenToEvmIntent(data?: Record<string, unknown>): boolean;
+export declare function hasMidenToEvmTypestringMarker(typestring: string): boolean;
+export declare function hasEvmToMidenTypestringMarker(typestring: string): boolean;
+export declare function resolveMidenBridgeDirection(typestring: string, data?: Record<string, unknown>): MidenBridgeDirection | "conflict" | null;
+export declare function getMidenMetadata(data?: Record<string, unknown>, typestring?: string): MidenExtraData | null;
+/** @deprecated Use {@link isEVMToMidenIntent}. */
+export declare function isEVMToMidenMandate(mandate?: Record<string, unknown>): boolean;
+export { EVM_TO_MIDEN_EXTRA_TYPESTRING, EVM_TO_MIDEN_FIELD_NAMES, MIDEN_TO_EVM_EXTRA_TYPESTRING, MIDEN_TO_EVM_FIELD_NAMES, MIDEN_MARKER_FIELD_NAMES, };

package/dist/utils/miden-intent.js

@@ -0,0 +1,79 @@
+import { EVM_TO_MIDEN_EXTRA_TYPESTRING, EVM_TO_MIDEN_FIELD_NAMES, MIDEN_MARKER_FIELD_NAMES, MIDEN_RECIPIENT_ACCOUNT_FIELD_NAME, MIDEN_SOURCE_ACCOUNT_FIELD_NAME, MIDEN_TO_EVM_EXTRA_TYPESTRING, MIDEN_TO_EVM_FIELD_NAMES, } from "./witness-typestring.js";
+function hasTruthyField(data, fieldName) {
+    return data[fieldName] != null && data[fieldName] !== "";
+}
+/** True when mandate/extra data carries any Miden bridge marker field. */
+export function hasMidenMarkersInData(data) {
+    if (!data)
+        return false;
+    return MIDEN_MARKER_FIELD_NAMES.some((name) => hasTruthyField(data, name));
+}
+/** True when a witness/extra typestring declares any Miden bridge marker field. */
+export function hasMidenMarkersInTypestring(typestring) {
+    if (!typestring.trim())
+        return false;
+    return MIDEN_MARKER_FIELD_NAMES.some((name) => typestring.includes(name));
+}
+/**
+ * True iff the intent is a Miden bridge intent (markers in typestring and/or data).
+ * At least one of `typestring` or `data` must be provided.
+ */
+export function isMidenIntent(typestring, data) {
+    const hasTypestring = typestring !== undefined && typestring.trim() !== "";
+    const hasData = data !== undefined;
+    if (!hasTypestring && !hasData) {
+        throw new Error("isMidenIntent requires typestring and/or data");
+    }
+    return ((hasTypestring && hasMidenMarkersInTypestring(typestring)) ||
+        hasMidenMarkersInData(data));
+}
+/** EVM→Miden: recipient set, source account absent. */
+export function isEVMToMidenIntent(data) {
+    if (!data)
+        return false;
+    return (hasTruthyField(data, MIDEN_RECIPIENT_ACCOUNT_FIELD_NAME) &&
+        !hasTruthyField(data, MIDEN_SOURCE_ACCOUNT_FIELD_NAME));
+}
+/** Miden→EVM: source account set. */
+export function isMidenToEvmIntent(data) {
+    if (!data)
+        return false;
+    return hasTruthyField(data, MIDEN_SOURCE_ACCOUNT_FIELD_NAME);
+}
+export function hasMidenToEvmTypestringMarker(typestring) {
+    return typestring.includes(MIDEN_SOURCE_ACCOUNT_FIELD_NAME);
+}
+export function hasEvmToMidenTypestringMarker(typestring) {
+    return typestring.includes(MIDEN_RECIPIENT_ACCOUNT_FIELD_NAME);
+}
+export function resolveMidenBridgeDirection(typestring, data) {
+    const toEvm = isMidenToEvmIntent(data) || hasMidenToEvmTypestringMarker(typestring);
+    const fromEvm = isEVMToMidenIntent(data) || hasEvmToMidenTypestringMarker(typestring);
+    if (toEvm && fromEvm)
+        return "conflict";
+    if (toEvm)
+        return "miden-to-evm";
+    if (fromEvm)
+        return "evm-to-miden";
+    // Match server routing: other Miden markers without a recipient use collateral path.
+    if (isMidenIntent(typestring, data))
+        return "miden-to-evm";
+    return null;
+}
+export function getMidenMetadata(data, typestring) {
+    if (!data || !isMidenIntent(typestring, data))
+        return null;
+    return {
+        midenSourceAccount: data?.midenSourceAccount,
+        midenRecipientAccount: data?.midenRecipientAccount,
+        midenFaucetId: data?.midenFaucetId,
+        midenNoteType: data?.midenNoteType,
+        midenNoteId: data?.midenNoteId,
+    };
+}
+/** @deprecated Use {@link isEVMToMidenIntent}. */
+export function isEVMToMidenMandate(mandate) {
+    return isEVMToMidenIntent(mandate);
+}
+// Re-export canonical typestrings for callers that import direction helpers here.
+export { EVM_TO_MIDEN_EXTRA_TYPESTRING, EVM_TO_MIDEN_FIELD_NAMES, MIDEN_TO_EVM_EXTRA_TYPESTRING, MIDEN_TO_EVM_FIELD_NAMES, MIDEN_MARKER_FIELD_NAMES, };

package/dist/utils/witness-typestring.d.ts

@@ -1,35 +1,53 @@
+export declare function parseWitnessTypestringFields(witnessTypeString: string): Array<{
+    type: string;
+    name: string;
+}>;
+export declare function fieldNamesFromExtraTypestring(typestring: string): string[];
 /** Base Mandate fields shared by all Epoch intents (matches `getTaskData`). */
 export declare const BASE_MANDATE_TYPESTRING = "address tokenIn,uint256 tokenInAmount,address tokenOut,uint256 minTokenOut,uint256 destinationChainId,bytes4 taskType,bytes32 protocolHashIdentifier,address recipient";
 /** Miden → EVM cross-chain bridge witness suffix (canonical). */
 export declare const MIDEN_TO_EVM_EXTRA_TYPESTRING = "string midenSourceAccount,string midenFaucetId,string midenNoteType,string midenNoteId";
 /** EVM → Miden cross-chain bridge witness suffix (canonical). */
 export declare const EVM_TO_MIDEN_EXTRA_TYPESTRING = "string midenRecipientAccount,string midenFaucetId";
-export declare const MIDEN_TO_EVM_WITNESS_TYPESTRING = "address tokenIn,uint256 tokenInAmount,address tokenOut,uint256 minTokenOut,uint256 destinationChainId,bytes4 taskType,bytes32 protocolHashIdentifier,address recipient,string midenSourceAccount,string midenFaucetId,string midenNoteType,string midenNoteId";
-export declare const EVM_TO_MIDEN_WITNESS_TYPESTRING = "address tokenIn,uint256 tokenInAmount,address tokenOut,uint256 minTokenOut,uint256 destinationChainId,bytes4 taskType,bytes32 protocolHashIdentifier,address recipient,string midenRecipientAccount,string midenFaucetId";
+/** Lending DEPOSIT extraData suffix (canonical). */
+export declare const DEPOSIT_EXTRADATA_TYPESTRING = "string marketUid,string action,string payAsset,bool isAll";
+/** Lending WITHDRAW extraData suffix (canonical). */
+export declare const WITHDRAW_EXTRADATA_TYPESTRING = "string marketUid,string action,string payAsset,bool isAll";
+export declare const MIDEN_TO_EVM_FIELD_NAMES: string[];
+export declare const EVM_TO_MIDEN_FIELD_NAMES: string[];
+/** Union of all Miden bridge field names from the canonical extra typestrings. */
+export declare const MIDEN_MARKER_FIELD_NAMES: string[];
+/** Fields declared only on the Miden→EVM extra typestring. */
+export declare const MIDEN_TO_EVM_ONLY_FIELD_NAMES: string[];
+/** Fields declared only on the EVM→Miden extra typestring. */
+export declare const EVM_TO_MIDEN_ONLY_FIELD_NAMES: string[];
+export declare const MIDEN_SOURCE_ACCOUNT_FIELD_NAME: "midenSourceAccount";
+export declare const MIDEN_RECIPIENT_ACCOUNT_FIELD_NAME: "midenRecipientAccount";
 export type WitnessTypestringValidationResult = {
     valid: true;
 } | {
     valid: false;
     error: string;
 };
-export declare function parseWitnessTypestringFields(witnessTypeString: string): Array<{
-    type: string;
-    name: string;
-}>;
 /**
- * When a mandate includes Miden bridge metadata, the witness typestring must end
- * with the canonical Miden suffix. Direction (Miden→EVM vs EVM→Miden) is inferred
- * from the mandate and from the typestring's own suffix.
+ * Validate Miden `extraDataTypestring` / `extraData` for task assembly.
+ * Required Miden fields must be declared and present; additional protocol fields
+ * are allowed when declared in the typestring.
+ */
+export declare function validateMidenExtraFields(extraDataTypestring: string, extraData?: Record<string, unknown>): WitnessTypestringValidationResult;
+/**
+ * When a mandate includes Miden bridge metadata, the witness typestring must
+ * declare every required Miden field for the detected direction. Additional
+ * non-Miden fields may appear before or after the Miden fields.
  *
  * No-op for pure EVM intents — Miden checks run only when {@link isMidenIntent}.
  */
-export declare function assertMidenWitnessSuffix(witnessTypeString: string, mandate?: Record<string, unknown>): WitnessTypestringValidationResult;
-export declare function isEVMToMidenMandate(mandate?: Record<string, unknown>): boolean;
+export declare function assertMidenWitnessFields(witnessTypeString: string, mandate?: Record<string, unknown>): WitnessTypestringValidationResult;
 /**
  * Validates a witness typestring against its data. Handles both the full witness
  * (base mandate + extra suffix) and a bare extra suffix — the same rules apply to
  * either: comma spacing, "type name" format, key alignment with the data object,
- * and the canonical Miden bridge suffix. Pass the assembled typestring and the
+ * and required Miden bridge fields when applicable. Pass the assembled typestring and the
  * merged data; there is no separate extra-suffix validator.
  */
 export declare function validateWitnessTypeString(witnessTypeString: string, mandate?: Record<string, unknown>): WitnessTypestringValidationResult;

package/dist/utils/witness-typestring.js

@@ -1,11 +1,4 @@
-/** Base Mandate fields shared by all Epoch intents (matches `getTaskData`). */
-export const BASE_MANDATE_TYPESTRING = "address tokenIn,uint256 tokenInAmount,address tokenOut,uint256 minTokenOut,uint256 destinationChainId,bytes4 taskType,bytes32 protocolHashIdentifier,address recipient";
-/** Miden → EVM cross-chain bridge witness suffix (canonical). */
-export const MIDEN_TO_EVM_EXTRA_TYPESTRING = "string midenSourceAccount,string midenFaucetId,string midenNoteType,string midenNoteId";
-/** EVM → Miden cross-chain bridge witness suffix (canonical). */
-export const EVM_TO_MIDEN_EXTRA_TYPESTRING = "string midenRecipientAccount,string midenFaucetId";
-export const MIDEN_TO_EVM_WITNESS_TYPESTRING = `${BASE_MANDATE_TYPESTRING},${MIDEN_TO_EVM_EXTRA_TYPESTRING}`;
-export const EVM_TO_MIDEN_WITNESS_TYPESTRING = `${BASE_MANDATE_TYPESTRING},${EVM_TO_MIDEN_EXTRA_TYPESTRING}`;
+import { isMidenIntent, resolveMidenBridgeDirection } from "./miden-intent.js";
 export function parseWitnessTypestringFields(witnessTypeString) {
     return witnessTypeString
         .split(",")
@@ -21,6 +14,41 @@ export function parseWitnessTypestringFields(witnessTypeString) {
         return { type, name };
     });
 }
+export function fieldNamesFromExtraTypestring(typestring) {
+    return parseWitnessTypestringFields(typestring).map((field) => field.name);
+}
+function uniqueFieldNames(typestrings) {
+    return [
+        ...new Set(typestrings.flatMap((typestring) => fieldNamesFromExtraTypestring(typestring))),
+    ];
+}
+function onlyInLeft(left, right) {
+    const rightSet = new Set(right);
+    return left.filter((name) => !rightSet.has(name));
+}
+/** Base Mandate fields shared by all Epoch intents (matches `getTaskData`). */
+export const BASE_MANDATE_TYPESTRING = "address tokenIn,uint256 tokenInAmount,address tokenOut,uint256 minTokenOut,uint256 destinationChainId,bytes4 taskType,bytes32 protocolHashIdentifier,address recipient";
+/** Miden → EVM cross-chain bridge witness suffix (canonical). */
+export const MIDEN_TO_EVM_EXTRA_TYPESTRING = "string midenSourceAccount,string midenFaucetId,string midenNoteType,string midenNoteId";
+/** EVM → Miden cross-chain bridge witness suffix (canonical). */
+export const EVM_TO_MIDEN_EXTRA_TYPESTRING = "string midenRecipientAccount,string midenFaucetId";
+/** Lending DEPOSIT extraData suffix (canonical). */
+export const DEPOSIT_EXTRADATA_TYPESTRING = "string marketUid,string action,string payAsset,bool isAll";
+/** Lending WITHDRAW extraData suffix (canonical). */
+export const WITHDRAW_EXTRADATA_TYPESTRING = "string marketUid,string action,string payAsset,bool isAll";
+export const MIDEN_TO_EVM_FIELD_NAMES = fieldNamesFromExtraTypestring(MIDEN_TO_EVM_EXTRA_TYPESTRING);
+export const EVM_TO_MIDEN_FIELD_NAMES = fieldNamesFromExtraTypestring(EVM_TO_MIDEN_EXTRA_TYPESTRING);
+/** Union of all Miden bridge field names from the canonical extra typestrings. */
+export const MIDEN_MARKER_FIELD_NAMES = uniqueFieldNames([
+    MIDEN_TO_EVM_EXTRA_TYPESTRING,
+    EVM_TO_MIDEN_EXTRA_TYPESTRING,
+]);
+/** Fields declared only on the Miden→EVM extra typestring. */
+export const MIDEN_TO_EVM_ONLY_FIELD_NAMES = onlyInLeft(MIDEN_TO_EVM_FIELD_NAMES, EVM_TO_MIDEN_FIELD_NAMES);
+/** Fields declared only on the EVM→Miden extra typestring. */
+export const EVM_TO_MIDEN_ONLY_FIELD_NAMES = onlyInLeft(EVM_TO_MIDEN_FIELD_NAMES, MIDEN_TO_EVM_FIELD_NAMES);
+export const MIDEN_SOURCE_ACCOUNT_FIELD_NAME = MIDEN_TO_EVM_ONLY_FIELD_NAMES.find((name) => name === "midenSourceAccount");
+export const MIDEN_RECIPIENT_ACCOUNT_FIELD_NAME = EVM_TO_MIDEN_ONLY_FIELD_NAMES.find((name) => name === "midenRecipientAccount");
 function assertNoSpacesAroundCommas(typestring) {
     if (/,(\s)|(\s),/.test(typestring)) {
         return {
@@ -63,70 +91,113 @@ function assertKeysMatchTypestring(typestring, data, dataLabel = "extraData", ty
     }
     return { valid: true };
 }
-function isEvmToMidenMandate(mandate) {
-    return (mandate?.midenRecipientAccount != null &&
-        mandate?.midenSourceAccount == null);
+function requiredMidenExtraTypestring(direction) {
+    return direction === "miden-to-evm"
+        ? MIDEN_TO_EVM_EXTRA_TYPESTRING
+        : EVM_TO_MIDEN_EXTRA_TYPESTRING;
 }
-function isMidenToEvmMandate(mandate) {
-    return mandate?.midenSourceAccount != null;
+function assertMidenFieldsDeclared(typestring, requiredExtraTypestring, typestringLabel) {
+    const requiredFields = parseWitnessTypestringFields(requiredExtraTypestring);
+    let declaredFields;
+    try {
+        declaredFields = parseWitnessTypestringFields(typestring);
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: error instanceof Error
+                ? error.message
+                : "Invalid witnessTypeString format",
+        };
+    }
+    const declaredByName = new Map(declaredFields.map((field) => [field.name, field.type]));
+    for (const field of requiredFields) {
+        const declaredType = declaredByName.get(field.name);
+        if (declaredType === undefined) {
+            return {
+                valid: false,
+                error: `${typestringLabel} is missing required Miden field "${field.type} ${field.name}"`,
+            };
+        }
+        if (declaredType !== field.type) {
+            return {
+                valid: false,
+                error: `${typestringLabel} field "${field.name}" must be type "${field.type}", got "${declaredType}"`,
+            };
+        }
+    }
+    return { valid: true };
 }
-function hasMidenToEvmSuffix(witnessTypeString) {
-    return witnessTypeString.includes("midenSourceAccount");
+function assertMidenFieldsPresentInData(data, requiredExtraTypestring, dataLabel) {
+    const requiredNames = parseWitnessTypestringFields(requiredExtraTypestring).map((field) => field.name);
+    for (const name of requiredNames) {
+        if (!Object.prototype.hasOwnProperty.call(data, name)) {
+            return {
+                valid: false,
+                error: `${dataLabel} is missing required Miden field "${name}"`,
+            };
+        }
+    }
+    return { valid: true };
 }
-function hasEvmToMidenSuffix(witnessTypeString) {
-    return (witnessTypeString.includes("midenRecipientAccount") &&
-        !witnessTypeString.includes("midenSourceAccount"));
+function validateRequiredMidenFields(typestring, data, typestringLabel, dataLabel) {
+    const direction = resolveMidenBridgeDirection(typestring, data);
+    if (direction === "conflict") {
+        return {
+            valid: false,
+            error: "Miden witness cannot include both midenSourceAccount and midenRecipientAccount",
+        };
+    }
+    if (!direction) {
+        return {
+            valid: false,
+            error: "Unable to determine Miden bridge direction",
+        };
+    }
+    const requiredExtraTypestring = requiredMidenExtraTypestring(direction);
+    const declarationCheck = assertMidenFieldsDeclared(typestring, requiredExtraTypestring, typestringLabel);
+    if (!declarationCheck.valid)
+        return declarationCheck;
+    if (!data) {
+        return {
+            valid: false,
+            error: `${dataLabel} is required for Miden intents`,
+        };
+    }
+    return assertMidenFieldsPresentInData(data, requiredExtraTypestring, dataLabel);
 }
 /**
- * True iff the intent is a Miden bridge intent — i.e. it carries Miden markers
- * either in the mandate (midenSourceAccount / midenRecipientAccount) or in the
- * witness typestring itself. Pure EVM intents carry none of these, so all Miden
- * validation is skipped for them.
+ * Validate Miden `extraDataTypestring` / `extraData` for task assembly.
+ * Required Miden fields must be declared and present; additional protocol fields
+ * are allowed when declared in the typestring.
  */
-function isMidenIntent(witnessTypeString, mandate) {
-    return (isMidenToEvmMandate(mandate) ||
-        isEvmToMidenMandate(mandate) ||
-        hasMidenToEvmSuffix(witnessTypeString) ||
-        hasEvmToMidenSuffix(witnessTypeString));
+export function validateMidenExtraFields(extraDataTypestring, extraData) {
+    if (!extraDataTypestring.trim() && extraData === undefined) {
+        return { valid: true };
+    }
+    if (!isMidenIntent(extraDataTypestring, extraData)) {
+        return { valid: true };
+    }
+    return validateRequiredMidenFields(extraDataTypestring, extraData, "extraDataTypestring", "extraData");
 }
 /**
- * When a mandate includes Miden bridge metadata, the witness typestring must end
- * with the canonical Miden suffix. Direction (Miden→EVM vs EVM→Miden) is inferred
- * from the mandate and from the typestring's own suffix.
+ * When a mandate includes Miden bridge metadata, the witness typestring must
+ * declare every required Miden field for the detected direction. Additional
+ * non-Miden fields may appear before or after the Miden fields.
  *
  * No-op for pure EVM intents — Miden checks run only when {@link isMidenIntent}.
  */
-export function assertMidenWitnessSuffix(witnessTypeString, mandate) {
+export function assertMidenWitnessFields(witnessTypeString, mandate) {
     if (!isMidenIntent(witnessTypeString, mandate)) {
         return { valid: true };
     }
-    const toEvm = isMidenToEvmMandate(mandate) || hasMidenToEvmSuffix(witnessTypeString);
-    const fromEvm = isEvmToMidenMandate(mandate) || hasEvmToMidenSuffix(witnessTypeString);
-    if (toEvm && fromEvm) {
-        return {
-            valid: false,
-            error: "Miden witness cannot include both midenSourceAccount and midenRecipientAccount",
-        };
-    }
-    const expectedSuffix = toEvm
-        ? MIDEN_TO_EVM_EXTRA_TYPESTRING
-        : EVM_TO_MIDEN_EXTRA_TYPESTRING;
-    if (!witnessTypeString.endsWith(expectedSuffix)) {
-        return {
-            valid: false,
-            error: `Invalid Miden witness suffix. Expected typestring to end with "${expectedSuffix}".`,
-        };
-    }
-    return { valid: true };
-}
-export function isEVMToMidenMandate(mandate) {
-    return isEvmToMidenMandate(mandate);
+    return validateRequiredMidenFields(witnessTypeString, mandate, "witnessTypeString", "mandate");
 }
 /**
  * Validates a witness typestring against its data. Handles both the full witness
  * (base mandate + extra suffix) and a bare extra suffix — the same rules apply to
  * either: comma spacing, "type name" format, key alignment with the data object,
- * and the canonical Miden bridge suffix. Pass the assembled typestring and the
+ * and required Miden bridge fields when applicable. Pass the assembled typestring and the
  * merged data; there is no separate extra-suffix validator.
  */
 export function validateWitnessTypeString(witnessTypeString, mandate) {
@@ -159,7 +230,7 @@ export function validateWitnessTypeString(witnessTypeString, mandate) {
         if (!keyCheck.valid)
             return keyCheck;
     }
-    const midenCheck = assertMidenWitnessSuffix(witnessTypeString, mandate);
+    const midenCheck = assertMidenWitnessFields(witnessTypeString, mandate);
     if (!midenCheck.valid)
         return midenCheck;
     return { valid: true };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epoch-protocol/epoch-commons-sdk",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "SDK for interacting with Epoch Commons Protocol",
   "type": "module",
   "main": "dist/index.js",