@ocap/tx-protocols 1.29.4 → 1.29.6

package/esm/index.mjs

@@ -1,3 +1,4 @@
+import { WriteLedger } from "./pipes/write-ledger.mjs";
 import execute_default from "./execute.mjs";
 import delegate_default from "./protocols/account/delegate.mjs";
 import migrate_default from "./protocols/account/migrate.mjs";
@@ -97,4 +98,4 @@ const { execute } = defaultExecutor;
 var src_default = defaultExecutor;
 
 //#endregion
-export { createExecutor, src_default as default, execute };
+export { WriteLedger, createExecutor, src_default as default, execute };

package/esm/pipes/write-ledger.d.mts

@@ -0,0 +1,73 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+import { ILedger } from "@ocap/types";
+
+//#region src/pipes/write-ledger.d.ts
+
+/**
+ * Context with ledger support
+ */
+interface IWriteLedgerContext {
+  /** VLedger instance (optional - skipped if not configured) */
+  ledger?: ILedger;
+  /** Transaction hash */
+  txHash: string;
+  /** Transaction type */
+  txType: string;
+  /** Raw transaction (base64) */
+  txBase64?: string;
+  /** Decoded transaction */
+  tx?: {
+    from?: string;
+    nonce?: number;
+    pk?: string;
+    signature?: string;
+    chainId?: string;
+  };
+  /** Chain ID from config */
+  config?: {
+    chainId?: string;
+  };
+  /** Transaction time (ISO string from DecodeTx pipe) */
+  txTime?: string;
+  /** Ledger sequence number (set after successful write) */
+  ledgerSequence?: number;
+  /** Logger */
+  logger?: {
+    debug: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+  };
+  /** Extended context (passkey verification, gas staking headers, etc.) */
+  extra?: {
+    /** Passkey verification data */
+    txExtra?: Record<string, unknown>;
+    /** Gas staking signature headers */
+    gasStakeHeaders?: {
+      token: string;
+      pk: string;
+    };
+    [key: string]: unknown;
+  };
+}
+/**
+ * Error codes for ledger write failures
+ */
+declare const LEDGER_ERRORS: {
+  readonly WRITE_FAILED: "LEDGER_WRITE_FAILED";
+  readonly NOT_INITIALIZED: "LEDGER_NOT_INITIALIZED";
+};
+/**
+ * Create a WriteLedger pipe function
+ *
+ * @returns Pipe function that writes verified tx to ledger
+ *
+ * @example
+ * ```typescript
+ * import { WriteLedger } from '@ocap/tx-protocols/pipes/write-ledger';
+ *
+ * // In pipeline setup (after VerifySignature):
+ * runner.use(WriteLedger);
+ * ```
+ */
+declare const WriteLedger: PipeFunction<IWriteLedgerContext>;
+//#endregion
+export { LEDGER_ERRORS, WriteLedger, WriteLedger as default };

package/esm/pipes/write-ledger.mjs

@@ -0,0 +1,97 @@
+import Debug from "debug";
+import { formatMessage } from "@ocap/message";
+
+//#region src/pipes/write-ledger.ts
+/**
+* WriteLedger Pipe
+*
+* Writes verified transactions to the Ledger append-only log.
+* Must be placed AFTER VerifySignature to ensure only authenticated txs are recorded.
+*
+* The ledger provides:
+* - Append-only immutable transaction log
+* - Merkle tree proofs for auditability
+* - Checkpoint mechanism for consistency
+*
+* NOTE: Ledger write failures will abort the pipeline to ensure data integrity.
+*/
+const debug = Debug("@ocap/tx-protocols:pipes:write-ledger");
+/**
+* Error codes for ledger write failures
+*/
+const LEDGER_ERRORS = {
+	WRITE_FAILED: "LEDGER_WRITE_FAILED",
+	NOT_INITIALIZED: "LEDGER_NOT_INITIALIZED"
+};
+/**
+* Create a WriteLedger pipe function
+*
+* @returns Pipe function that writes verified tx to ledger
+*
+* @example
+* ```typescript
+* import { WriteLedger } from '@ocap/tx-protocols/pipes/write-ledger';
+*
+* // In pipeline setup (after VerifySignature):
+* runner.use(WriteLedger);
+* ```
+*/
+const WriteLedger = async (context, next) => {
+	const { ledger, txHash, txType, txBase64, tx, config, txTime, extra } = context;
+	if (!ledger) {
+		debug("No ledger configured, skipping write", { txHash });
+		return next();
+	}
+	if (!txHash || !txType || !txBase64 || !tx) {
+		debug("Missing required tx fields, skipping write", {
+			txHash,
+			txType
+		});
+		return next();
+	}
+	try {
+		let txExtra;
+		if (extra?.txExtra || extra?.gasStakeHeaders) {
+			txExtra = {};
+			if (extra.txExtra) txExtra.txExtra = extra.txExtra;
+			if (extra.gasStakeHeaders) txExtra.gasStakeHeaders = extra.gasStakeHeaders;
+		}
+		const formattedTx = formatMessage("Transaction", tx);
+		const txInput = {
+			txRaw: txBase64,
+			tx: formattedTx,
+			txHash,
+			txType,
+			from: tx.from || "",
+			nonce: tx.nonce || 0,
+			pk: formattedTx.pk || "",
+			signature: formattedTx.signature || "",
+			chainId: tx.chainId || config?.chainId || "",
+			timestamp: txTime ? new Date(txTime).getTime() : Date.now(),
+			txExtra
+		};
+		const entry = await ledger.append(txInput);
+		context.ledgerSequence = entry.sequence;
+		debug("Transaction written to ledger", {
+			txHash,
+			sequence: entry.sequence,
+			entryHash: entry.entryHash
+		});
+		return next();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		context.logger?.error("Failed to write tx to ledger", {
+			txHash,
+			error: message
+		});
+		debug("Ledger write failed", {
+			txHash,
+			error: message
+		});
+		return next(/* @__PURE__ */ new Error(`${LEDGER_ERRORS.WRITE_FAILED}: ${message}`));
+	}
+};
+var write_ledger_default = WriteLedger;
+
+//#endregion
+export { LEDGER_ERRORS, WriteLedger, write_ledger_default as default };

package/esm/protocols/account/delegate.d.mts

@@ -1,4 +1,55 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IReadyContext, IWithDelegation, IWithReceiver, IWithSender, TDelegateTx } from "@ocap/types";
+
 //#region src/protocols/account/delegate.d.ts
-declare const runner: any;
+
+/**
+ * Context type for delegate protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, Partial<IWithReceiver>, Partial<IWithDelegation>
+ */
+type Context = IReadyContext<TDelegateTx> & Partial<IWithSender> & Partial<IWithReceiver> & Partial<IWithDelegation> & {
+  /** Formatted itx from formatMessage */
+  formattedItx?: {
+    ops: Array<{
+      typeUrl: string;
+      limit?: {
+        tokens?: Array<{
+          rate?: {
+            anchor?: number;
+          };
+          [key: string]: unknown;
+        }>;
+        assets?: Array<{
+          rate?: {
+            anchor?: number;
+          };
+          [key: string]: unknown;
+        }>;
+      };
+      [key: string]: unknown;
+    }>;
+  };
+  /** Validated itx after Joi validation */
+  validatedItx?: {
+    opsList: Array<{
+      limit: {
+        tokensList: Array<{
+          txCount?: number;
+          txAllowance?: string;
+          totalAllowance?: string;
+          validUntil?: number;
+          rate?: unknown;
+        }>;
+        assetsList: Array<{
+          txCount?: number;
+          validUntil?: number;
+          rate?: unknown;
+        }>;
+      };
+    }>;
+  };
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { runner as default };

package/esm/protocols/account/migrate.d.mts

@@ -1,4 +1,18 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IAccountState, IReadyContext, IWithSender, TAccountMigrateTx } from "@ocap/types";
+
 //#region src/protocols/account/migrate.d.ts
-declare const runner: any;
+
+/**
+ * Context type for account_migrate protocol.
+ *
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: Partial<IWithSender> - sender may not exist for new accounts
+ */
+type Context = IReadyContext<TAccountMigrateTx> & Partial<IWithSender> & {
+  /** Receiver state - created during business logic */
+  receiverState?: IAccountState;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { runner as default };

package/esm/protocols/account/revoke-delegate.d.mts

@@ -1,4 +1,17 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IReadyContext, IWithDelegation, IWithSender, TRevokeDelegateTx } from "@ocap/types";
+
 //#region src/protocols/account/revoke-delegate.d.ts
-declare const runner: any;
+
+/**
+ * Context type for revoke-delegate protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender (required), IWithDelegation (required)
+ */
+type Context = IReadyContext<TRevokeDelegateTx> & IWithSender & IWithDelegation & {
+  /** Type URLs to revoke from delegation */
+  typeUrls?: string[];
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { runner as default };

package/esm/protocols/asset/acquire-v2.d.mts

@@ -1,9 +1,47 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IAccountState, IAssetFactoryState, IAssetState, IReadyContext, ITokenState, IWithAsset, IWithDelegation, IWithDelegator, IWithFactory, IWithOwner, IWithSender, TAcquireAssetV2Tx } from "@ocap/types";
+
 //#region src/protocols/asset/acquire-v2.d.ts
 /** Token input type */
 interface TokenInput {
   address: string;
   value: string;
 }
-declare const runner: any;
+/**
+ * Context type for acquire-asset-v2 protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, IWithDelegator, IWithFactory, IWithOwner, IWithAsset, IWithDelegation
+ */
+type Context = IReadyContext<TAcquireAssetV2Tx> & Partial<IWithSender> & Partial<IWithDelegator> & Partial<IWithFactory> & Partial<IWithOwner> & Partial<IWithAsset> & Partial<IWithDelegation> & {
+  /** Duplicate asset state if exists */
+  duplicateAsset?: IAssetState;
+  /** Factory owner state */
+  factoryOwnerState?: IAccountState;
+  /** Trusted issuer states from factory */
+  issuerStates?: IAccountState[];
+  /** Issuer state from itx */
+  issuerState?: IAccountState;
+  /** Asset states from itx.assetsList */
+  assetStates?: IAssetState[];
+  /** Expected factory states for input assets */
+  expectedFactoryStates?: IAssetFactoryState[];
+  /** Token addresses from factory input */
+  tokenAddress?: string[];
+  /** Token states for factory input tokens */
+  tokenStates?: ITokenState[];
+  /** Factory token inputs */
+  factoryTokens?: TokenInput[];
+  /** Asset owner state (buyer) */
+  assetOwner?: IAccountState;
+  /** Whether delegation was changed */
+  isDelegationChanged?: boolean;
+  /** Minted asset data */
+  mintedAsset?: Record<string, unknown>;
+  /** Minted asset address */
+  mintedAddress?: string;
+  /** Token updates for factory (non-instant settlement) */
+  tokenUpdates?: Record<string, string>;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { TokenInput, runner as default };

package/esm/protocols/asset/acquire-v3.d.mts

@@ -1,3 +1,6 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IAccountState, IAssetFactoryState, IAssetState, IReadyContext, ITokenState, IWithAsset, IWithFactory, IWithOwner, IWithReceiver, IWithSender, IWithSigners, TAcquireAssetV3Tx } from "@ocap/types";
+
 //#region src/protocols/asset/acquire-v3.d.ts
 /** Token input type */
 interface TokenInput {
@@ -12,6 +15,45 @@ interface MultiInput {
   assetsList?: string[];
   assets?: string[];
 }
-declare const runner: any;
+/**
+ * Context type for acquire-asset-v3 protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, IWithSigners, IWithFactory, IWithOwner, IWithReceiver, IWithAsset
+ */
+type Context = IReadyContext<TAcquireAssetV3Tx> & Partial<IWithSender> & Partial<IWithSigners> & Partial<IWithFactory> & Partial<IWithOwner> & Partial<IWithReceiver> & Partial<IWithAsset> & {
+  /** Duplicate asset state if exists */
+  duplicateAsset?: IAssetState;
+  /** Parsed inputs from itx */
+  inputs?: MultiInput[];
+  /** Sender addresses from inputs */
+  senders?: string[];
+  /** Token addresses from inputs */
+  tokens?: string[];
+  /** Asset addresses from inputs */
+  assets?: string[];
+  /** Token addresses from factory input */
+  tokenAddress?: string[];
+  /** Factory owner state */
+  factoryOwnerState?: IAccountState;
+  /** Trusted issuer states from factory */
+  issuerStates?: IAccountState[];
+  /** Issuer state from itx */
+  issuerState?: IAccountState;
+  /** Factory token inputs */
+  factoryTokens?: TokenInput[];
+  /** Token states for input tokens */
+  tokenStates?: ITokenState[];
+  /** Asset states from itx inputs */
+  assetStates?: IAssetState[];
+  /** Expected factory states for input assets */
+  expectedFactoryStates?: IAssetFactoryState[];
+  /** Minted asset data */
+  mintedAsset?: Record<string, unknown>;
+  /** Minted asset address */
+  mintedAddress?: string;
+  /** Token updates for factory (non-instant settlement) */
+  tokenUpdates?: Record<string, string>;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { MultiInput, TokenInput, runner as default };

package/esm/protocols/asset/calls/transfer-token.d.mts

@@ -1,4 +1,7 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IBaseContext } from "@ocap/types";
+
 //#region src/protocols/asset/calls/transfer-token.d.ts
-declare const runner: any;
+declare const runner: Runner<IBaseContext<unknown>>;
 //#endregion
 export { runner as default };

package/esm/protocols/asset/calls/transfer.d.mts

@@ -1,4 +1,7 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IBaseContext } from "@ocap/types";
+
 //#region src/protocols/asset/calls/transfer.d.ts
-declare const runner: any;
+declare const runner: Runner<IBaseContext<unknown>>;
 //#endregion
 export { runner as default };

package/esm/protocols/asset/consume.d.mts

@@ -1,4 +1,17 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IReadyContext, IWithAsset, IWithIssuer, IWithOwner, IWithSender, IWithSigners, TConsumeAssetTx } from "@ocap/types";
+
 //#region src/protocols/asset/consume.d.ts
-declare const runner: any;
+
+/**
+ * Context type for consume-asset protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithAsset, IWithSender, IWithIssuer, IWithOwner, IWithSigners (all required)
+ */
+type Context = IReadyContext<TConsumeAssetTx> & IWithAsset & IWithSender & IWithIssuer & IWithOwner & IWithSigners & {
+  /** Signer addresses (owner + issuer) */
+  signers: string[];
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { runner as default };

package/esm/protocols/asset/create.d.mts

@@ -1,4 +1,26 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { AnyData } from "@ocap/message";
+import { IAssetFactoryState, IAssetState, IReadyContext, IWithAsset, IWithDelegation, IWithDelegator, IWithIssuer, IWithSender, TCreateAssetTx } from "@ocap/types";
+
 //#region src/protocols/asset/create.d.ts
-declare const runner: any;
+
+/**
+ * Context type for create-asset protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, IWithIssuer, IWithDelegator, IWithDelegation (all optional as states may not exist)
+ */
+type Context = IReadyContext<TCreateAssetTx> & Partial<IWithSender> & Partial<IWithIssuer> & Partial<IWithDelegator> & Partial<IWithDelegation> & Partial<IWithAsset> & {
+  /** Decoded asset data from itx */
+  assetData?: AnyData | null;
+  /** Signer addresses (issuer) */
+  signers?: string[];
+  /** Factory state if parent is a factory */
+  factoryState?: IAssetFactoryState;
+  /** Parent asset state */
+  parentAsset?: IAssetState;
+  /** Whether delegation was changed during tx */
+  isDelegationChanged?: boolean;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { runner as default };

package/esm/protocols/asset/mint.d.mts

@@ -1,4 +1,31 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IAccountState, IAssetFactoryState, IAssetState, IReadyContext, IWithFactory, IWithOwner, IWithReceiver, IWithSender, TMintAssetTx } from "@ocap/types";
+
 //#region src/protocols/asset/mint.d.ts
-declare const runner: any;
+
+/**
+ * Context type for mint-asset protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, IWithFactory, IWithOwner, IWithReceiver
+ */
+type Context = IReadyContext<TMintAssetTx> & Partial<IWithSender> & Partial<IWithFactory> & Partial<IWithOwner> & Partial<IWithReceiver> & {
+  /** Duplicate asset state if exists */
+  duplicateAsset?: IAssetState;
+  /** Factory owner state */
+  factoryOwnerState?: IAccountState;
+  /** Trusted issuer states from factory */
+  issuerStates?: IAccountState[];
+  /** Asset states from itx.assetsList */
+  assetStates?: IAssetState[];
+  /** Expected factory states for input assets */
+  expectedFactoryStates?: IAssetFactoryState[];
+  /** Minted asset data */
+  mintedAsset?: Record<string, unknown>;
+  /** Minted asset address */
+  mintedAddress?: string;
+  /** Owner address (resolved) */
+  ownerAddress?: string;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { runner as default };

package/esm/protocols/asset/update.d.mts

@@ -1,4 +1,18 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { AnyData } from "@ocap/message";
+import { IReadyContext, IWithAsset, IWithIssuer, IWithSender, TUpdateAssetTx } from "@ocap/types";
+
 //#region src/protocols/asset/update.d.ts
-declare const runner: any;
+
+/**
+ * Context type for update-asset protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithAsset (required), IWithSender (required), IWithIssuer (optional)
+ */
+type Context = IReadyContext<TUpdateAssetTx> & IWithAsset & IWithSender & Partial<IWithIssuer> & {
+  /** Decoded new data for asset update, null means no update */
+  newData: AnyData | null;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { runner as default };

package/esm/protocols/factory/create.d.mts

@@ -1,3 +1,6 @@
+import { Runner } from "@ocap/tx-pipeline";
+import { IAccountState, IAssetFactoryState, IAssetState, IReadyContext, ITokenState, IWithDelegation, IWithDelegator, IWithFactory, IWithSender, TCreateFactoryTx } from "@ocap/types";
+
 //#region src/protocols/factory/create.d.ts
 /** Formatted factory properties from formatMessage */
 interface FormattedFactoryProps {
@@ -24,6 +27,25 @@ interface FormattedFactoryProps {
   display?: unknown;
   data?: unknown;
 }
-declare const runner: any;
+/**
+ * Context type for create-factory protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, IWithDelegator, IWithDelegation, IWithFactory
+ */
+type Context = IReadyContext<TCreateFactoryTx> & Partial<IWithSender> & Partial<IWithDelegator> & Partial<IWithDelegation> & Partial<IWithFactory> & {
+  /** Formatted factory props from formatMessage */
+  factoryProps?: FormattedFactoryProps;
+  /** Token states for factory input tokens */
+  tokenStates?: ITokenState[];
+  /** Asset states for factory input assets */
+  inputAssetStates?: IAssetState[];
+  /** Factory states for factory input assets (that are factories) */
+  inputFactoryStates?: IAssetFactoryState[];
+  /** Trusted issuer states */
+  issuerStates?: IAccountState[];
+  /** Whether delegation was changed */
+  isDelegationChanged?: boolean;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { FormattedFactoryProps, runner as default };

package/esm/protocols/governance/claim-stake.d.mts

@@ -1,4 +1,6 @@
+import { Runner } from "@ocap/tx-pipeline";
 import { BN } from "@ocap/util";
+import { IReadyContext, ITxState, IWithAssets, IWithEvidence, IWithReceivers, IWithSender, IWithStake, IWithTokens, TClaimStakeTx } from "@ocap/types";
 
 //#region src/protocols/governance/claim-stake.d.ts
 /** Token input type */
@@ -22,6 +24,27 @@ interface TokenCondition {
     value: BN;
   }>;
 }
-declare const runner: any;
+/**
+ * Context type for claim-stake protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, IWithStake, IWithEvidence, IWithReceivers, IWithTokens, IWithAssets
+ */
+type Context = IReadyContext<TClaimStakeTx> & IWithSender & IWithStake & Partial<IWithEvidence> & Partial<IWithReceivers> & Partial<IWithTokens> & Partial<IWithAssets> & {
+  /** Transaction state for evidence */
+  txState?: ITxState;
+  /** Parsed outputs from evidence tx */
+  outputs?: MultiOutput[];
+  /** Receiver addresses from outputs */
+  receivers?: string[];
+  /** Token addresses from outputs */
+  tokens?: string[];
+  /** Asset addresses from outputs */
+  assets?: string[];
+  /** Token condition for balance verification */
+  tokenCondition?: TokenCondition;
+  /** Revoked tokens to claim */
+  revokedTokens?: TokenInput[];
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { MultiOutput, TokenCondition, TokenInput, runner as default };

package/esm/protocols/governance/return-stake.d.mts

@@ -1,4 +1,6 @@
+import { Runner } from "@ocap/tx-pipeline";
 import { BN } from "@ocap/util";
+import { IReadyContext, IWithAssets, IWithLocked, IWithReceivers, IWithSender, IWithStake, IWithTokens, TReturnStakeTx } from "@ocap/types";
 
 //#region src/protocols/governance/return-stake.d.ts
 /** Token input type */
@@ -22,6 +24,23 @@ interface TokenCondition {
     value: BN;
   }>;
 }
-declare const runner: any;
+/**
+ * Context type for return-stake protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, IWithReceivers, IWithStake, IWithTokens, IWithAssets, IWithLocked
+ */
+type Context = IReadyContext<TReturnStakeTx> & IWithSender & IWithStake & Partial<IWithReceivers> & Partial<IWithTokens> & Partial<IWithAssets> & Partial<IWithLocked> & {
+  /** Parsed outputs from itx */
+  outputs?: MultiInput[];
+  /** Receiver addresses from outputs */
+  receivers?: string[];
+  /** Token addresses from outputs */
+  tokens?: string[];
+  /** Asset addresses from outputs */
+  assets?: string[];
+  /** Token condition for balance verification */
+  tokenCondition?: TokenCondition;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { MultiInput, TokenCondition, TokenInput, runner as default };

package/esm/protocols/governance/revoke-stake.d.mts

@@ -1,4 +1,6 @@
+import { Runner } from "@ocap/tx-pipeline";
 import { BN } from "@ocap/util";
+import { IReadyContext, IWithAssets, IWithReceivers, IWithSender, IWithStake, IWithTokens, TRevokeStakeTx } from "@ocap/types";
 
 //#region src/protocols/governance/revoke-stake.d.ts
 /** Token input type */
@@ -22,6 +24,23 @@ interface TokenCondition {
     value: BN;
   }>;
 }
-declare const runner: any;
+/**
+ * Context type for revoke-stake protocol.
+ * Phase: IReadyContext (after TakeStateSnapshot)
+ * Mixins: IWithSender, IWithStake, IWithReceivers, IWithTokens, IWithAssets
+ */
+type Context = IReadyContext<TRevokeStakeTx> & IWithSender & IWithStake & Partial<IWithReceivers> & Partial<IWithTokens> & Partial<IWithAssets> & {
+  /** Parsed outputs from itx */
+  outputs?: MultiOutput[];
+  /** Receiver addresses from outputs */
+  receivers?: string[];
+  /** Token addresses from outputs */
+  tokens?: string[];
+  /** Asset addresses from outputs */
+  assets?: string[];
+  /** Token condition for balance verification */
+  tokenCondition?: TokenCondition;
+};
+declare const runner: Runner<Context>;
 //#endregion
 export { MultiOutput, TokenCondition, TokenInput, runner as default };