@zkp2p/contracts-v2 0.3.0 → 0.3.1-rc.1

package/types/contracts/interfaces/{IRiskTierManager.ts → IRiskManager.ts}

@@ -27,57 +27,98 @@ import type {
   PromiseOrValue,
 } from "../../common";
 
-export declare namespace IRiskTierManager {
-  export type PlatformRiskConfigStruct = {
-    enabled: PromiseOrValue<boolean>;
+export declare namespace IIntentRiskHook {
+  export type FeeAllocationStruct = {
+    feeType: PromiseOrValue<BigNumberish>;
+    recipient: PromiseOrValue<string>;
+    amount: PromiseOrValue<BigNumberish>;
+  };
+
+  export type FeeAllocationStructOutput = [number, string, BigNumber] & {
+    feeType: number;
+    recipient: string;
+    amount: BigNumber;
+  };
+
+  export type RiskSettlementContextStruct = {
+    intentHash: PromiseOrValue<BytesLike>;
+    token: PromiseOrValue<string>;
+    recipient: PromiseOrValue<string>;
+    grossAmount: PromiseOrValue<BigNumberish>;
+    executableAmount: PromiseOrValue<BigNumberish>;
+    isManualRelease: PromiseOrValue<boolean>;
+    feeAllocations: IIntentRiskHook.FeeAllocationStruct[];
+  };
+
+  export type RiskSettlementContextStructOutput = [
+    string,
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    boolean,
+    IIntentRiskHook.FeeAllocationStructOutput[]
+  ] & {
+    intentHash: string;
+    token: string;
+    recipient: string;
+    grossAmount: BigNumber;
+    executableAmount: BigNumber;
+    isManualRelease: boolean;
+    feeAllocations: IIntentRiskHook.FeeAllocationStructOutput[];
+  };
+}
+
+export declare namespace IRiskManager {
+  export type ChargebackConfigStruct = {
     chargebackable: PromiseOrValue<boolean>;
     deferredPayoutEnabled: PromiseOrValue<boolean>;
-    reserveBps: PromiseOrValue<BigNumberish>;
     riskWindow: PromiseOrValue<BigNumberish>;
-    tierCaps: [
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>
-    ];
+  };
+
+  export type ChargebackConfigStructOutput = [boolean, boolean, BigNumber] & {
+    chargebackable: boolean;
+    deferredPayoutEnabled: boolean;
+    riskWindow: BigNumber;
+  };
+
+  export type PlatformRiskConfigStruct = {
+    enabled: PromiseOrValue<boolean>;
+    chargeback: IRiskManager.ChargebackConfigStruct;
+    extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>;
   };
 
   export type PlatformRiskConfigStructOutput = [
     boolean,
-    boolean,
-    boolean,
-    number,
-    BigNumber,
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]
+    IRiskManager.ChargebackConfigStructOutput,
+    number
   ] & {
     enabled: boolean;
-    chargebackable: boolean;
-    deferredPayoutEnabled: boolean;
-    reserveBps: number;
-    riskWindow: BigNumber;
-    tierCaps: [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber];
+    chargeback: IRiskManager.ChargebackConfigStructOutput;
+    extensionPenaltyBpsPerHour: number;
   };
 
   export type RiskPositionStruct = {
     taker: PromiseOrValue<string>;
     stakeOwner: PromiseOrValue<string>;
-    maker: PromiseOrValue<string>;
+    extensionStakeOwner: PromiseOrValue<string>;
+    lp: PromiseOrValue<string>;
+    payoutRecipient: PromiseOrValue<string>;
     paymentMethod: PromiseOrValue<BytesLike>;
     mode: PromiseOrValue<BigNumberish>;
     status: PromiseOrValue<BigNumberish>;
-    countsTowardConcurrency: PromiseOrValue<boolean>;
-    deferredPayoutHook: PromiseOrValue<string>;
-    payoutRecipient: PromiseOrValue<string>;
-    reserveBps: PromiseOrValue<BigNumberish>;
+    isManualRelease: PromiseOrValue<boolean>;
+    extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>;
     riskWindow: PromiseOrValue<BigNumberish>;
-    settlementBuffer: PromiseOrValue<BigNumberish>;
-    settledAt: PromiseOrValue<BigNumberish>;
-    slashDeadline: PromiseOrValue<BigNumberish>;
-    releaseTime: PromiseOrValue<BigNumberish>;
-    reservedAmount: PromiseOrValue<BigNumberish>;
-    releasedAmount: PromiseOrValue<BigNumberish>;
-    slashedAmount: PromiseOrValue<BigNumberish>;
+    createdAt: PromiseOrValue<BigNumberish>;
+    baseIntentExpiry: PromiseOrValue<BigNumberish>;
+    totalExtensionTime: PromiseOrValue<BigNumberish>;
+    coverageDeadline: PromiseOrValue<BigNumberish>;
+    intentAmount: PromiseOrValue<BigNumberish>;
+    extensionAmount: PromiseOrValue<BigNumberish>;
+    coverageAmount: PromiseOrValue<BigNumberish>;
+    grossReleasedAmount: PromiseOrValue<BigNumberish>;
+    executableAmount: PromiseOrValue<BigNumberish>;
   };
 
   export type RiskPositionStructOutput = [
@@ -85,11 +126,11 @@ export declare namespace IRiskTierManager {
     string,
     string,
     string,
+    string,
+    string,
     number,
     number,
     boolean,
-    string,
-    string,
     number,
     BigNumber,
     BigNumber,
@@ -98,124 +139,112 @@ export declare namespace IRiskTierManager {
     BigNumber,
     BigNumber,
     BigNumber,
+    BigNumber,
+    BigNumber,
     BigNumber
   ] & {
     taker: string;
     stakeOwner: string;
-    maker: string;
+    extensionStakeOwner: string;
+    lp: string;
+    payoutRecipient: string;
     paymentMethod: string;
     mode: number;
     status: number;
-    countsTowardConcurrency: boolean;
-    deferredPayoutHook: string;
-    payoutRecipient: string;
-    reserveBps: number;
+    isManualRelease: boolean;
+    extensionPenaltyBpsPerHour: number;
     riskWindow: BigNumber;
-    settlementBuffer: BigNumber;
-    settledAt: BigNumber;
-    slashDeadline: BigNumber;
-    releaseTime: BigNumber;
-    reservedAmount: BigNumber;
-    releasedAmount: BigNumber;
-    slashedAmount: BigNumber;
+    createdAt: BigNumber;
+    baseIntentExpiry: BigNumber;
+    totalExtensionTime: BigNumber;
+    coverageDeadline: BigNumber;
+    intentAmount: BigNumber;
+    extensionAmount: BigNumber;
+    coverageAmount: BigNumber;
+    grossReleasedAmount: BigNumber;
+    executableAmount: BigNumber;
   };
 
   export type ChargebackAttestationStruct = {
-    chainId: PromiseOrValue<BigNumberish>;
-    riskTierManager: PromiseOrValue<string>;
-    orchestrator: PromiseOrValue<string>;
     intentHash: PromiseOrValue<BytesLike>;
-    paymentMethod: PromiseOrValue<BytesLike>;
-    chargebackAmount: PromiseOrValue<BigNumberish>;
-    evidenceId: PromiseOrValue<BytesLike>;
-    nonce: PromiseOrValue<BigNumberish>;
-    validAfter: PromiseOrValue<BigNumberish>;
-    validUntil: PromiseOrValue<BigNumberish>;
+    dataHash: PromiseOrValue<BytesLike>;
+    signatures: PromiseOrValue<BytesLike>[];
+    data: PromiseOrValue<BytesLike>;
   };
 
   export type ChargebackAttestationStructOutput = [
-    BigNumber,
-    string,
     string,
     string,
-    string,
-    BigNumber,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber
+    string[],
+    string
   ] & {
-    chainId: BigNumber;
-    riskTierManager: string;
-    orchestrator: string;
     intentHash: string;
-    paymentMethod: string;
-    chargebackAmount: BigNumber;
-    evidenceId: string;
-    nonce: BigNumber;
-    validAfter: BigNumber;
-    validUntil: BigNumber;
+    dataHash: string;
+    signatures: string[];
+    data: string;
   };
 }
 
-export interface IRiskTierManagerInterface extends utils.Interface {
+export interface IRiskManagerInterface extends utils.Interface {
   functions: {
     "acceptVaultController()": FunctionFragment;
-    "activeIntentCount(address)": FunctionFragment;
+    "attestationVerifier()": FunctionFragment;
+    "calculateIntentExtensionCost(uint256,uint64,uint32)": FunctionFragment;
+    "calculateIntentExtensionPenalty(uint256,uint64,uint64,uint64,uint32)": FunctionFragment;
+    "extendIntent(bytes32,uint64)": FunctionFragment;
+    "extensionLockId(bytes32)": FunctionFragment;
+    "getDeferredFeeAllocations(bytes32)": FunctionFragment;
     "getPlatformRiskConfig(bytes32)": FunctionFragment;
     "getRiskPosition(bytes32)": FunctionFragment;
     "getTakerState(address)": FunctionFragment;
-    "getTier(address)": FunctionFragment;
-    "getTierForStake(uint256)": FunctionFragment;
-    "hashChargebackAttestation((uint256,address,address,bytes32,bytes32,uint256,bytes32,uint256,uint64,uint64))": FunctionFragment;
+    "hashChargebackAttestation((bytes32,bytes32,bytes[],bytes))": FunctionFragment;
+    "nullifierRegistry()": FunctionFragment;
     "onIntentCancelled(bytes32)": FunctionFragment;
     "onIntentCreated(bytes32)": FunctionFragment;
-    "onIntentFulfilled(bytes32,uint256)": FunctionFragment;
-    "onIntentReleased(bytes32,uint256)": FunctionFragment;
     "orchestrator()": FunctionFragment;
-    "reconcileSettlement(bytes32)": FunctionFragment;
-    "reconcileSettlements(bytes32[])": FunctionFragment;
-    "registerDeferredPayout(bytes32,address,uint256)": FunctionFragment;
+    "reconcileCancellation(bytes32)": FunctionFragment;
+    "reconcileCancellations(bytes32[])": FunctionFragment;
     "releaseMaturedPosition(bytes32)": FunctionFragment;
     "releaseMaturedPositions(bytes32[])": FunctionFragment;
-    "setAdmissionPaused(bool)": FunctionFragment;
+    "riskTakingPaused()": FunctionFragment;
     "setAttestationVerifier(address)": FunctionFragment;
-    "setConcurrencyLimits(uint256[5])": FunctionFragment;
-    "setDeferredPayoutHook(address)": FunctionFragment;
-    "setPlatformRiskConfig(bytes32,(bool,bool,bool,uint16,uint64,uint256[5]))": FunctionFragment;
-    "setTierThresholds(uint256[4])": FunctionFragment;
-    "setTimingConfig(uint64,uint64)": FunctionFragment;
-    "submitChargeback((uint256,address,address,bytes32,bytes32,uint256,bytes32,uint256,uint64,uint64),bytes[],bytes)": FunctionFragment;
+    "setPlatformRiskConfig(bytes32,(bool,(bool,bool,uint64),uint32))": FunctionFragment;
+    "setRiskTakingPaused(bool)": FunctionFragment;
+    "settleIntent((bytes32,address,address,uint256,uint256,bool,(uint8,address,uint256)[]))": FunctionFragment;
+    "stakeVault()": FunctionFragment;
+    "submitChargeback((bytes32,bytes32,bytes[],bytes))": FunctionFragment;
+    "usedChargebackNullifiers(bytes32)": FunctionFragment;
   };
 
   getFunction(
     nameOrSignatureOrTopic:
       | "acceptVaultController"
-      | "activeIntentCount"
+      | "attestationVerifier"
+      | "calculateIntentExtensionCost"
+      | "calculateIntentExtensionPenalty"
+      | "extendIntent"
+      | "extensionLockId"
+      | "getDeferredFeeAllocations"
       | "getPlatformRiskConfig"
       | "getRiskPosition"
       | "getTakerState"
-      | "getTier"
-      | "getTierForStake"
       | "hashChargebackAttestation"
+      | "nullifierRegistry"
       | "onIntentCancelled"
       | "onIntentCreated"
-      | "onIntentFulfilled"
-      | "onIntentReleased"
       | "orchestrator"
-      | "reconcileSettlement"
-      | "reconcileSettlements"
-      | "registerDeferredPayout"
+      | "reconcileCancellation"
+      | "reconcileCancellations"
       | "releaseMaturedPosition"
       | "releaseMaturedPositions"
-      | "setAdmissionPaused"
+      | "riskTakingPaused"
       | "setAttestationVerifier"
-      | "setConcurrencyLimits"
-      | "setDeferredPayoutHook"
       | "setPlatformRiskConfig"
-      | "setTierThresholds"
-      | "setTimingConfig"
+      | "setRiskTakingPaused"
+      | "settleIntent"
+      | "stakeVault"
       | "submitChargeback"
+      | "usedChargebackNullifiers"
   ): FunctionFragment;
 
   encodeFunctionData(
@@ -223,8 +252,38 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "activeIntentCount",
-    values: [PromiseOrValue<string>]
+    functionFragment: "attestationVerifier",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "calculateIntentExtensionCost",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "calculateIntentExtensionPenalty",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "extendIntent",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "extensionLockId",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDeferredFeeAllocations",
+    values: [PromiseOrValue<BytesLike>]
   ): string;
   encodeFunctionData(
     functionFragment: "getPlatformRiskConfig",
@@ -239,16 +298,12 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "getTier",
-    values: [PromiseOrValue<string>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "getTierForStake",
-    values: [PromiseOrValue<BigNumberish>]
+    functionFragment: "hashChargebackAttestation",
+    values: [IRiskManager.ChargebackAttestationStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "hashChargebackAttestation",
-    values: [IRiskTierManager.ChargebackAttestationStruct]
+    functionFragment: "nullifierRegistry",
+    values?: undefined
   ): string;
   encodeFunctionData(
     functionFragment: "onIntentCancelled",
@@ -258,34 +313,18 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     functionFragment: "onIntentCreated",
     values: [PromiseOrValue<BytesLike>]
   ): string;
-  encodeFunctionData(
-    functionFragment: "onIntentFulfilled",
-    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "onIntentReleased",
-    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
-  ): string;
   encodeFunctionData(
     functionFragment: "orchestrator",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "reconcileSettlement",
+    functionFragment: "reconcileCancellation",
     values: [PromiseOrValue<BytesLike>]
   ): string;
   encodeFunctionData(
-    functionFragment: "reconcileSettlements",
+    functionFragment: "reconcileCancellations",
     values: [PromiseOrValue<BytesLike>[]]
   ): string;
-  encodeFunctionData(
-    functionFragment: "registerDeferredPayout",
-    values: [
-      PromiseOrValue<BytesLike>,
-      PromiseOrValue<string>,
-      PromiseOrValue<BigNumberish>
-    ]
-  ): string;
   encodeFunctionData(
     functionFragment: "releaseMaturedPosition",
     values: [PromiseOrValue<BytesLike>]
@@ -295,58 +334,36 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     values: [PromiseOrValue<BytesLike>[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "setAdmissionPaused",
-    values: [PromiseOrValue<boolean>]
+    functionFragment: "riskTakingPaused",
+    values?: undefined
   ): string;
   encodeFunctionData(
     functionFragment: "setAttestationVerifier",
     values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "setConcurrencyLimits",
-    values: [
-      [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ]
-    ]
+    functionFragment: "setPlatformRiskConfig",
+    values: [PromiseOrValue<BytesLike>, IRiskManager.PlatformRiskConfigStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "setDeferredPayoutHook",
-    values: [PromiseOrValue<string>]
+    functionFragment: "setRiskTakingPaused",
+    values: [PromiseOrValue<boolean>]
   ): string;
   encodeFunctionData(
-    functionFragment: "setPlatformRiskConfig",
-    values: [
-      PromiseOrValue<BytesLike>,
-      IRiskTierManager.PlatformRiskConfigStruct
-    ]
+    functionFragment: "settleIntent",
+    values: [IIntentRiskHook.RiskSettlementContextStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "setTierThresholds",
-    values: [
-      [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ]
-    ]
+    functionFragment: "stakeVault",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "setTimingConfig",
-    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+    functionFragment: "submitChargeback",
+    values: [IRiskManager.ChargebackAttestationStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "submitChargeback",
-    values: [
-      IRiskTierManager.ChargebackAttestationStruct,
-      PromiseOrValue<BytesLike>[],
-      PromiseOrValue<BytesLike>
-    ]
+    functionFragment: "usedChargebackNullifiers",
+    values: [PromiseOrValue<BytesLike>]
   ): string;
 
   decodeFunctionResult(
@@ -354,84 +371,83 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "activeIntentCount",
+    functionFragment: "attestationVerifier",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getPlatformRiskConfig",
+    functionFragment: "calculateIntentExtensionCost",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getRiskPosition",
+    functionFragment: "calculateIntentExtensionPenalty",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getTakerState",
+    functionFragment: "extendIntent",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "getTier", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "getTierForStake",
+    functionFragment: "extensionLockId",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "hashChargebackAttestation",
+    functionFragment: "getDeferredFeeAllocations",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "onIntentCancelled",
+    functionFragment: "getPlatformRiskConfig",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "onIntentCreated",
+    functionFragment: "getRiskPosition",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "onIntentFulfilled",
+    functionFragment: "getTakerState",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "onIntentReleased",
+    functionFragment: "hashChargebackAttestation",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "orchestrator",
+    functionFragment: "nullifierRegistry",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "reconcileSettlement",
+    functionFragment: "onIntentCancelled",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "reconcileSettlements",
+    functionFragment: "onIntentCreated",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "registerDeferredPayout",
+    functionFragment: "orchestrator",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "releaseMaturedPosition",
+    functionFragment: "reconcileCancellation",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "releaseMaturedPositions",
+    functionFragment: "reconcileCancellations",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setAdmissionPaused",
+    functionFragment: "releaseMaturedPosition",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setAttestationVerifier",
+    functionFragment: "releaseMaturedPositions",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setConcurrencyLimits",
+    functionFragment: "riskTakingPaused",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setDeferredPayoutHook",
+    functionFragment: "setAttestationVerifier",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -439,60 +455,50 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setTierThresholds",
+    functionFragment: "setRiskTakingPaused",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setTimingConfig",
+    functionFragment: "settleIntent",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "stakeVault", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "submitChargeback",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "usedChargebackNullifiers",
+    data: BytesLike
+  ): Result;
 
   events: {
-    "AdmissionPausedUpdated(bool)": EventFragment;
     "AttestationVerifierUpdated(address,address)": EventFragment;
-    "ChargebackSettled(bytes32,address,address,uint8,uint256,uint256,uint256,uint256,bytes32)": EventFragment;
-    "ConcurrencyLimitsUpdated(uint256,uint256,uint256,uint256,uint256)": EventFragment;
-    "DeferredPayoutHookUpdated(address,address)": EventFragment;
-    "DeferredPayoutRegistered(bytes32,address,uint256,uint64)": EventFragment;
-    "PlatformRiskConfigUpdated(bytes32,bool,bool,bool,uint16,uint64,uint256,uint256,uint256,uint256,uint256)": EventFragment;
-    "RiskPositionCancelled(bytes32,address,uint256)": EventFragment;
-    "RiskPositionCreated(bytes32,address,address,address,bytes32,uint8,address,address,uint256,uint64,uint64)": EventFragment;
-    "RiskPositionFulfilled(bytes32,address,uint8,uint256,uint256,uint64,uint64,uint64)": EventFragment;
+    "ChargebackSettled(bytes32,address,address,uint8,uint256,bytes32)": EventFragment;
+    "DeferredSettlementFunded(bytes32,address,uint256,uint256,uint256,uint64)": EventFragment;
+    "IntentExtended(bytes32,address,address,address,uint64,uint64,uint256,uint256)": EventFragment;
+    "IntentExtensionResolved(bytes32,address,address,uint64,uint64,uint256,uint256)": EventFragment;
+    "PlatformRiskConfigUpdated(bytes32,bool,bool,bool,uint64,uint32)": EventFragment;
+    "RiskPositionCancelled(bytes32,address,address,uint64,uint256,uint256)": EventFragment;
+    "RiskPositionCreated(bytes32,address,address,address,bytes32,uint8,uint256,uint256,uint64,uint64,uint32)": EventFragment;
     "RiskPositionReleased(bytes32,address,uint8,uint256)": EventFragment;
-    "TierThresholdsUpdated(uint256,uint256,uint256,uint256)": EventFragment;
-    "TimingConfigUpdated(uint64,uint64)": EventFragment;
+    "RiskPositionSettled(bytes32,address,address,uint8,uint256,uint256,uint256,uint64,bool)": EventFragment;
+    "RiskTakingPausedUpdated(bool)": EventFragment;
   };
 
-  getEvent(nameOrSignatureOrTopic: "AdmissionPausedUpdated"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "AttestationVerifierUpdated"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "ChargebackSettled"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "ConcurrencyLimitsUpdated"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "DeferredPayoutHookUpdated"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "DeferredPayoutRegistered"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "DeferredSettlementFunded"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "IntentExtended"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "IntentExtensionResolved"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "PlatformRiskConfigUpdated"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "RiskPositionCancelled"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "RiskPositionCreated"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "RiskPositionFulfilled"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "RiskPositionReleased"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "TierThresholdsUpdated"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "TimingConfigUpdated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RiskPositionSettled"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RiskTakingPausedUpdated"): EventFragment;
 }
 
-export interface AdmissionPausedUpdatedEventObject {
-  paused: boolean;
-}
-export type AdmissionPausedUpdatedEvent = TypedEvent<
-  [boolean],
-  AdmissionPausedUpdatedEventObject
->;
-
-export type AdmissionPausedUpdatedEventFilter =
-  TypedEventFilter<AdmissionPausedUpdatedEvent>;
-
 export interface AttestationVerifierUpdatedEventObject {
   previousVerifier: string;
   newVerifier: string;
@@ -507,101 +513,80 @@ export type AttestationVerifierUpdatedEventFilter =
 
 export interface ChargebackSettledEventObject {
   intentHash: string;
-  taker: string;
-  maker: string;
+  stakeOwner: string;
+  lp: string;
   mode: number;
-  attestedAmount: BigNumber;
-  slashedAmount: BigNumber;
-  totalSlashed: BigNumber;
-  remainingCoverage: BigNumber;
-  evidenceId: string;
+  compensatedAmount: BigNumber;
+  disputeId: string;
 }
 export type ChargebackSettledEvent = TypedEvent<
-  [
-    string,
-    string,
-    string,
-    number,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    string
-  ],
+  [string, string, string, number, BigNumber, string],
   ChargebackSettledEventObject
 >;
 
 export type ChargebackSettledEventFilter =
   TypedEventFilter<ChargebackSettledEvent>;
 
-export interface ConcurrencyLimitsUpdatedEventObject {
-  peasant: BigNumber;
-  peer: BigNumber;
-  plus: BigNumber;
-  pro: BigNumber;
-  platinum: BigNumber;
+export interface DeferredSettlementFundedEventObject {
+  intentHash: string;
+  payoutRecipient: string;
+  grossAmount: BigNumber;
+  executableAmount: BigNumber;
+  deferredFees: BigNumber;
+  coverageDeadline: BigNumber;
 }
-export type ConcurrencyLimitsUpdatedEvent = TypedEvent<
-  [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
-  ConcurrencyLimitsUpdatedEventObject
+export type DeferredSettlementFundedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber, BigNumber],
+  DeferredSettlementFundedEventObject
 >;
 
-export type ConcurrencyLimitsUpdatedEventFilter =
-  TypedEventFilter<ConcurrencyLimitsUpdatedEvent>;
+export type DeferredSettlementFundedEventFilter =
+  TypedEventFilter<DeferredSettlementFundedEvent>;
 
-export interface DeferredPayoutHookUpdatedEventObject {
-  previousHook: string;
-  newHook: string;
+export interface IntentExtendedEventObject {
+  intentHash: string;
+  taker: string;
+  extensionStakeOwner: string;
+  caller: string;
+  additionalTime: BigNumber;
+  newExpiry: BigNumber;
+  additionalAmount: BigNumber;
+  totalAmount: BigNumber;
 }
-export type DeferredPayoutHookUpdatedEvent = TypedEvent<
-  [string, string],
-  DeferredPayoutHookUpdatedEventObject
+export type IntentExtendedEvent = TypedEvent<
+  [string, string, string, string, BigNumber, BigNumber, BigNumber, BigNumber],
+  IntentExtendedEventObject
 >;
 
-export type DeferredPayoutHookUpdatedEventFilter =
-  TypedEventFilter<DeferredPayoutHookUpdatedEvent>;
+export type IntentExtendedEventFilter = TypedEventFilter<IntentExtendedEvent>;
 
-export interface DeferredPayoutRegisteredEventObject {
+export interface IntentExtensionResolvedEventObject {
   intentHash: string;
-  beneficiary: string;
-  amount: BigNumber;
-  releaseTime: BigNumber;
+  extensionStakeOwner: string;
+  lp: string;
+  terminalAt: BigNumber;
+  chargeableTime: BigNumber;
+  penalty: BigNumber;
+  releasedAmount: BigNumber;
 }
-export type DeferredPayoutRegisteredEvent = TypedEvent<
-  [string, string, BigNumber, BigNumber],
-  DeferredPayoutRegisteredEventObject
+export type IntentExtensionResolvedEvent = TypedEvent<
+  [string, string, string, BigNumber, BigNumber, BigNumber, BigNumber],
+  IntentExtensionResolvedEventObject
 >;
 
-export type DeferredPayoutRegisteredEventFilter =
-  TypedEventFilter<DeferredPayoutRegisteredEvent>;
+export type IntentExtensionResolvedEventFilter =
+  TypedEventFilter<IntentExtensionResolvedEvent>;
 
 export interface PlatformRiskConfigUpdatedEventObject {
   paymentMethod: string;
   enabled: boolean;
   chargebackable: boolean;
   deferredPayoutEnabled: boolean;
-  reserveBps: number;
   riskWindow: BigNumber;
-  peasantCap: BigNumber;
-  peerCap: BigNumber;
-  plusCap: BigNumber;
-  proCap: BigNumber;
-  platinumCap: BigNumber;
+  extensionPenaltyBpsPerHour: number;
 }
 export type PlatformRiskConfigUpdatedEvent = TypedEvent<
-  [
-    string,
-    boolean,
-    boolean,
-    boolean,
-    number,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber
-  ],
+  [string, boolean, boolean, boolean, BigNumber, number],
   PlatformRiskConfigUpdatedEventObject
 >;
 
@@ -610,11 +595,14 @@ export type PlatformRiskConfigUpdatedEventFilter =
 
 export interface RiskPositionCancelledEventObject {
   intentHash: string;
-  taker: string;
-  releasedReservation: BigNumber;
+  stakeOwner: string;
+  lp: string;
+  cancelledAt: BigNumber;
+  extensionPenalty: BigNumber;
+  releasedCoverage: BigNumber;
 }
 export type RiskPositionCancelledEvent = TypedEvent<
-  [string, string, BigNumber],
+  [string, string, string, BigNumber, BigNumber, BigNumber],
   RiskPositionCancelledEventObject
 >;
 
@@ -623,16 +611,16 @@ export type RiskPositionCancelledEventFilter =
 
 export interface RiskPositionCreatedEventObject {
   intentHash: string;
-  taker: string;
-  maker: string;
   stakeOwner: string;
+  lp: string;
+  taker: string;
   paymentMethod: string;
   mode: number;
-  deferredPayoutHook: string;
-  payoutRecipient: string;
-  reservedAmount: BigNumber;
-  settlementBuffer: BigNumber;
-  fallbackReleaseTime: BigNumber;
+  intentAmount: BigNumber;
+  coverageAmount: BigNumber;
+  baseIntentExpiry: BigNumber;
+  riskWindow: BigNumber;
+  extensionPenaltyBpsPerHour: number;
 }
 export type RiskPositionCreatedEvent = TypedEvent<
   [
@@ -642,11 +630,11 @@ export type RiskPositionCreatedEvent = TypedEvent<
     string,
     string,
     number,
-    string,
-    string,
     BigNumber,
     BigNumber,
-    BigNumber
+    BigNumber,
+    BigNumber,
+    number
   ],
   RiskPositionCreatedEventObject
 >;
@@ -654,38 +642,11 @@ export type RiskPositionCreatedEvent = TypedEvent<
 export type RiskPositionCreatedEventFilter =
   TypedEventFilter<RiskPositionCreatedEvent>;
 
-export interface RiskPositionFulfilledEventObject {
-  intentHash: string;
-  taker: string;
-  mode: number;
-  releasedAmount: BigNumber;
-  reservedAmount: BigNumber;
-  settledAt: BigNumber;
-  slashDeadline: BigNumber;
-  releaseTime: BigNumber;
-}
-export type RiskPositionFulfilledEvent = TypedEvent<
-  [
-    string,
-    string,
-    number,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber
-  ],
-  RiskPositionFulfilledEventObject
->;
-
-export type RiskPositionFulfilledEventFilter =
-  TypedEventFilter<RiskPositionFulfilledEvent>;
-
 export interface RiskPositionReleasedEventObject {
   intentHash: string;
-  taker: string;
+  stakeOwner: string;
   mode: number;
-  releasedAmount: BigNumber;
+  releasedCoverage: BigNumber;
 }
 export type RiskPositionReleasedEvent = TypedEvent<
   [string, string, number, BigNumber],
@@ -695,38 +656,52 @@ export type RiskPositionReleasedEvent = TypedEvent<
 export type RiskPositionReleasedEventFilter =
   TypedEventFilter<RiskPositionReleasedEvent>;
 
-export interface TierThresholdsUpdatedEventObject {
-  peer: BigNumber;
-  plus: BigNumber;
-  pro: BigNumber;
-  platinum: BigNumber;
+export interface RiskPositionSettledEventObject {
+  intentHash: string;
+  stakeOwner: string;
+  lp: string;
+  mode: number;
+  grossAmount: BigNumber;
+  executableAmount: BigNumber;
+  coverageAmount: BigNumber;
+  coverageDeadline: BigNumber;
+  isManualRelease: boolean;
 }
-export type TierThresholdsUpdatedEvent = TypedEvent<
-  [BigNumber, BigNumber, BigNumber, BigNumber],
-  TierThresholdsUpdatedEventObject
+export type RiskPositionSettledEvent = TypedEvent<
+  [
+    string,
+    string,
+    string,
+    number,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    boolean
+  ],
+  RiskPositionSettledEventObject
 >;
 
-export type TierThresholdsUpdatedEventFilter =
-  TypedEventFilter<TierThresholdsUpdatedEvent>;
+export type RiskPositionSettledEventFilter =
+  TypedEventFilter<RiskPositionSettledEvent>;
 
-export interface TimingConfigUpdatedEventObject {
-  maxIntentLifetime: BigNumber;
-  settlementBuffer: BigNumber;
+export interface RiskTakingPausedUpdatedEventObject {
+  paused: boolean;
 }
-export type TimingConfigUpdatedEvent = TypedEvent<
-  [BigNumber, BigNumber],
-  TimingConfigUpdatedEventObject
+export type RiskTakingPausedUpdatedEvent = TypedEvent<
+  [boolean],
+  RiskTakingPausedUpdatedEventObject
 >;
 
-export type TimingConfigUpdatedEventFilter =
-  TypedEventFilter<TimingConfigUpdatedEvent>;
+export type RiskTakingPausedUpdatedEventFilter =
+  TypedEventFilter<RiskTakingPausedUpdatedEvent>;
 
-export interface IRiskTierManager extends BaseContract {
+export interface IRiskManager extends BaseContract {
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: IRiskTierManagerInterface;
+  interface: IRiskManagerInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,
@@ -752,91 +727,93 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    activeIntentCount(
-      _stakeOwner: PromiseOrValue<string>,
+    attestationVerifier(overrides?: CallOverrides): Promise<[string]>;
+
+    calculateIntentExtensionCost(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _extensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
+    calculateIntentExtensionPenalty(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _baseIntentExpiry: PromiseOrValue<BigNumberish>,
+      _terminalAt: PromiseOrValue<BigNumberish>,
+      _totalExtensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { penalty: BigNumber; chargeableTime: BigNumber }
+    >;
+
+    extendIntent(
+      _intentHash: PromiseOrValue<BytesLike>,
+      _additionalTime: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    extensionLockId(
+      _intentHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getDeferredFeeAllocations(
+      _intentHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[IIntentRiskHook.FeeAllocationStructOutput[]]>;
+
     getPlatformRiskConfig(
       _paymentMethod: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
-    ): Promise<[IRiskTierManager.PlatformRiskConfigStructOutput]>;
+    ): Promise<[IRiskManager.PlatformRiskConfigStructOutput]>;
 
     getRiskPosition(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
-    ): Promise<[IRiskTierManager.RiskPositionStructOutput]>;
+    ): Promise<[IRiskManager.RiskPositionStructOutput]>;
 
     getTakerState(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<
-      [number, BigNumber, BigNumber, BigNumber, boolean, BigNumber] & {
-        tier: number;
+      [string, BigNumber, BigNumber, BigNumber] & {
+        stakeOwner: string;
         totalStake: BigNumber;
-        reserved: BigNumber;
-        free: BigNumber;
-        exiting: boolean;
-        activeIntents: BigNumber;
+        lockedStake: BigNumber;
+        freeStake: BigNumber;
       }
     >;
 
-    getTier(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[number]>;
-
-    getTierForStake(
-      _stake: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<[number]>;
-
     hashChargebackAttestation(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
+      _attestation: IRiskManager.ChargebackAttestationStruct,
       overrides?: CallOverrides
     ): Promise<[string]>;
 
-    onIntentCancelled(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    onIntentCreated(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    onIntentFulfilled(
+    nullifierRegistry(overrides?: CallOverrides): Promise<[string]>;
+
+    onIntentCancelled(
       _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    onIntentReleased(
+    onIntentCreated(
       _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
     orchestrator(overrides?: CallOverrides): Promise<[string]>;
 
-    reconcileSettlement(
+    reconcileCancellation(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    reconcileSettlements(
+    reconcileCancellations(
       _intentHashes: PromiseOrValue<BytesLike>[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    registerDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
     releaseMaturedPosition(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
@@ -847,110 +824,111 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    setAdmissionPaused(
-      _paused: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    riskTakingPaused(overrides?: CallOverrides): Promise<[boolean]>;
 
     setAttestationVerifier(
       _verifier: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    setConcurrencyLimits(
-      _limits: [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ],
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    setDeferredPayoutHook(
-      _hook: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
     setPlatformRiskConfig(
       _paymentMethod: PromiseOrValue<BytesLike>,
-      _config: IRiskTierManager.PlatformRiskConfigStruct,
+      _config: IRiskManager.PlatformRiskConfigStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    setTierThresholds(
-      _thresholds: [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ],
+    setRiskTakingPaused(
+      _paused: PromiseOrValue<boolean>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    setTimingConfig(
-      _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-      _settlementBuffer: PromiseOrValue<BigNumberish>,
+    settleIntent(
+      _context: IIntentRiskHook.RiskSettlementContextStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
+    stakeVault(overrides?: CallOverrides): Promise<[string]>;
+
     submitChargeback(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
-      _signatures: PromiseOrValue<BytesLike>[],
-      _verificationData: PromiseOrValue<BytesLike>,
+      _attestation: IRiskManager.ChargebackAttestationStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
+
+    usedChargebackNullifiers(
+      _nullifier: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
   };
 
   acceptVaultController(
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  activeIntentCount(
-    _stakeOwner: PromiseOrValue<string>,
+  attestationVerifier(overrides?: CallOverrides): Promise<string>;
+
+  calculateIntentExtensionCost(
+    _intentAmount: PromiseOrValue<BigNumberish>,
+    _extensionTime: PromiseOrValue<BigNumberish>,
+    _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  calculateIntentExtensionPenalty(
+    _intentAmount: PromiseOrValue<BigNumberish>,
+    _baseIntentExpiry: PromiseOrValue<BigNumberish>,
+    _terminalAt: PromiseOrValue<BigNumberish>,
+    _totalExtensionTime: PromiseOrValue<BigNumberish>,
+    _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { penalty: BigNumber; chargeableTime: BigNumber }
+  >;
+
+  extendIntent(
+    _intentHash: PromiseOrValue<BytesLike>,
+    _additionalTime: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  extensionLockId(
+    _intentHash: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getDeferredFeeAllocations(
+    _intentHash: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<IIntentRiskHook.FeeAllocationStructOutput[]>;
+
   getPlatformRiskConfig(
     _paymentMethod: PromiseOrValue<BytesLike>,
     overrides?: CallOverrides
-  ): Promise<IRiskTierManager.PlatformRiskConfigStructOutput>;
+  ): Promise<IRiskManager.PlatformRiskConfigStructOutput>;
 
   getRiskPosition(
     _intentHash: PromiseOrValue<BytesLike>,
     overrides?: CallOverrides
-  ): Promise<IRiskTierManager.RiskPositionStructOutput>;
+  ): Promise<IRiskManager.RiskPositionStructOutput>;
 
   getTakerState(
     _taker: PromiseOrValue<string>,
     overrides?: CallOverrides
   ): Promise<
-    [number, BigNumber, BigNumber, BigNumber, boolean, BigNumber] & {
-      tier: number;
+    [string, BigNumber, BigNumber, BigNumber] & {
+      stakeOwner: string;
       totalStake: BigNumber;
-      reserved: BigNumber;
-      free: BigNumber;
-      exiting: boolean;
-      activeIntents: BigNumber;
+      lockedStake: BigNumber;
+      freeStake: BigNumber;
     }
   >;
 
-  getTier(
-    _taker: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<number>;
-
-  getTierForStake(
-    _stake: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
-  ): Promise<number>;
-
   hashChargebackAttestation(
-    _attestation: IRiskTierManager.ChargebackAttestationStruct,
+    _attestation: IRiskManager.ChargebackAttestationStruct,
     overrides?: CallOverrides
   ): Promise<string>;
 
+  nullifierRegistry(overrides?: CallOverrides): Promise<string>;
+
   onIntentCancelled(
     _intentHash: PromiseOrValue<BytesLike>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
@@ -961,37 +939,18 @@ export interface IRiskTierManager extends BaseContract {
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  onIntentFulfilled(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _releasedAmount: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  onIntentReleased(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _releasedAmount: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
   orchestrator(overrides?: CallOverrides): Promise<string>;
 
-  reconcileSettlement(
+  reconcileCancellation(
     _intentHash: PromiseOrValue<BytesLike>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  reconcileSettlements(
+  reconcileCancellations(
     _intentHashes: PromiseOrValue<BytesLike>[],
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  registerDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _beneficiary: PromiseOrValue<string>,
-    _amount: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
   releaseMaturedPosition(
     _intentHash: PromiseOrValue<BytesLike>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
@@ -1002,108 +961,109 @@ export interface IRiskTierManager extends BaseContract {
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  setAdmissionPaused(
-    _paused: PromiseOrValue<boolean>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  riskTakingPaused(overrides?: CallOverrides): Promise<boolean>;
 
   setAttestationVerifier(
     _verifier: PromiseOrValue<string>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  setConcurrencyLimits(
-    _limits: [
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>
-    ],
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  setDeferredPayoutHook(
-    _hook: PromiseOrValue<string>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
   setPlatformRiskConfig(
     _paymentMethod: PromiseOrValue<BytesLike>,
-    _config: IRiskTierManager.PlatformRiskConfigStruct,
+    _config: IRiskManager.PlatformRiskConfigStruct,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  setTierThresholds(
-    _thresholds: [
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>
-    ],
+  setRiskTakingPaused(
+    _paused: PromiseOrValue<boolean>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  setTimingConfig(
-    _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-    _settlementBuffer: PromiseOrValue<BigNumberish>,
+  settleIntent(
+    _context: IIntentRiskHook.RiskSettlementContextStruct,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
+  stakeVault(overrides?: CallOverrides): Promise<string>;
+
   submitChargeback(
-    _attestation: IRiskTierManager.ChargebackAttestationStruct,
-    _signatures: PromiseOrValue<BytesLike>[],
-    _verificationData: PromiseOrValue<BytesLike>,
+    _attestation: IRiskManager.ChargebackAttestationStruct,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
+  usedChargebackNullifiers(
+    _nullifier: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
   callStatic: {
     acceptVaultController(overrides?: CallOverrides): Promise<void>;
 
-    activeIntentCount(
-      _stakeOwner: PromiseOrValue<string>,
+    attestationVerifier(overrides?: CallOverrides): Promise<string>;
+
+    calculateIntentExtensionCost(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _extensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    calculateIntentExtensionPenalty(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _baseIntentExpiry: PromiseOrValue<BigNumberish>,
+      _terminalAt: PromiseOrValue<BigNumberish>,
+      _totalExtensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { penalty: BigNumber; chargeableTime: BigNumber }
+    >;
+
+    extendIntent(
+      _intentHash: PromiseOrValue<BytesLike>,
+      _additionalTime: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    extensionLockId(
+      _intentHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getDeferredFeeAllocations(
+      _intentHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<IIntentRiskHook.FeeAllocationStructOutput[]>;
+
     getPlatformRiskConfig(
       _paymentMethod: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
-    ): Promise<IRiskTierManager.PlatformRiskConfigStructOutput>;
+    ): Promise<IRiskManager.PlatformRiskConfigStructOutput>;
 
     getRiskPosition(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
-    ): Promise<IRiskTierManager.RiskPositionStructOutput>;
+    ): Promise<IRiskManager.RiskPositionStructOutput>;
 
     getTakerState(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<
-      [number, BigNumber, BigNumber, BigNumber, boolean, BigNumber] & {
-        tier: number;
+      [string, BigNumber, BigNumber, BigNumber] & {
+        stakeOwner: string;
         totalStake: BigNumber;
-        reserved: BigNumber;
-        free: BigNumber;
-        exiting: boolean;
-        activeIntents: BigNumber;
+        lockedStake: BigNumber;
+        freeStake: BigNumber;
       }
     >;
 
-    getTier(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<number>;
-
-    getTierForStake(
-      _stake: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<number>;
-
     hashChargebackAttestation(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
+      _attestation: IRiskManager.ChargebackAttestationStruct,
       overrides?: CallOverrides
     ): Promise<string>;
 
+    nullifierRegistry(overrides?: CallOverrides): Promise<string>;
+
     onIntentCancelled(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
@@ -1112,39 +1072,20 @@ export interface IRiskTierManager extends BaseContract {
     onIntentCreated(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
-    ): Promise<boolean>;
-
-    onIntentFulfilled(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    onIntentReleased(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
     ): Promise<void>;
 
     orchestrator(overrides?: CallOverrides): Promise<string>;
 
-    reconcileSettlement(
+    reconcileCancellation(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    reconcileSettlements(
+    reconcileCancellations(
       _intentHashes: PromiseOrValue<BytesLike>[],
       overrides?: CallOverrides
     ): Promise<void>;
 
-    registerDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
     releaseMaturedPosition(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
@@ -1155,68 +1096,43 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: CallOverrides
     ): Promise<void>;
 
-    setAdmissionPaused(
-      _paused: PromiseOrValue<boolean>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    riskTakingPaused(overrides?: CallOverrides): Promise<boolean>;
 
     setAttestationVerifier(
       _verifier: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    setConcurrencyLimits(
-      _limits: [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ],
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    setDeferredPayoutHook(
-      _hook: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
     setPlatformRiskConfig(
       _paymentMethod: PromiseOrValue<BytesLike>,
-      _config: IRiskTierManager.PlatformRiskConfigStruct,
+      _config: IRiskManager.PlatformRiskConfigStruct,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    setTierThresholds(
-      _thresholds: [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ],
+    setRiskTakingPaused(
+      _paused: PromiseOrValue<boolean>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    setTimingConfig(
-      _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-      _settlementBuffer: PromiseOrValue<BigNumberish>,
+    settleIntent(
+      _context: IIntentRiskHook.RiskSettlementContextStruct,
       overrides?: CallOverrides
     ): Promise<void>;
 
+    stakeVault(overrides?: CallOverrides): Promise<string>;
+
     submitChargeback(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
-      _signatures: PromiseOrValue<BytesLike>[],
-      _verificationData: PromiseOrValue<BytesLike>,
+      _attestation: IRiskManager.ChargebackAttestationStruct,
       overrides?: CallOverrides
     ): Promise<void>;
+
+    usedChargebackNullifiers(
+      _nullifier: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
   };
 
   filters: {
-    "AdmissionPausedUpdated(bool)"(
-      paused?: null
-    ): AdmissionPausedUpdatedEventFilter;
-    AdmissionPausedUpdated(paused?: null): AdmissionPausedUpdatedEventFilter;
-
     "AttestationVerifierUpdated(address,address)"(
       previousVerifier?: PromiseOrValue<string> | null,
       newVerifier?: PromiseOrValue<string> | null
@@ -1226,186 +1142,181 @@ export interface IRiskTierManager extends BaseContract {
       newVerifier?: PromiseOrValue<string> | null
     ): AttestationVerifierUpdatedEventFilter;
 
-    "ChargebackSettled(bytes32,address,address,uint8,uint256,uint256,uint256,uint256,bytes32)"(
+    "ChargebackSettled(bytes32,address,address,uint8,uint256,bytes32)"(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
-      maker?: PromiseOrValue<string> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
       mode?: null,
-      attestedAmount?: null,
-      slashedAmount?: null,
-      totalSlashed?: null,
-      remainingCoverage?: null,
-      evidenceId?: null
+      compensatedAmount?: null,
+      disputeId?: null
     ): ChargebackSettledEventFilter;
     ChargebackSettled(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
-      maker?: PromiseOrValue<string> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
       mode?: null,
-      attestedAmount?: null,
-      slashedAmount?: null,
-      totalSlashed?: null,
-      remainingCoverage?: null,
-      evidenceId?: null
+      compensatedAmount?: null,
+      disputeId?: null
     ): ChargebackSettledEventFilter;
 
-    "ConcurrencyLimitsUpdated(uint256,uint256,uint256,uint256,uint256)"(
-      peasant?: null,
-      peer?: null,
-      plus?: null,
-      pro?: null,
-      platinum?: null
-    ): ConcurrencyLimitsUpdatedEventFilter;
-    ConcurrencyLimitsUpdated(
-      peasant?: null,
-      peer?: null,
-      plus?: null,
-      pro?: null,
-      platinum?: null
-    ): ConcurrencyLimitsUpdatedEventFilter;
-
-    "DeferredPayoutHookUpdated(address,address)"(
-      previousHook?: PromiseOrValue<string> | null,
-      newHook?: PromiseOrValue<string> | null
-    ): DeferredPayoutHookUpdatedEventFilter;
-    DeferredPayoutHookUpdated(
-      previousHook?: PromiseOrValue<string> | null,
-      newHook?: PromiseOrValue<string> | null
-    ): DeferredPayoutHookUpdatedEventFilter;
-
-    "DeferredPayoutRegistered(bytes32,address,uint256,uint64)"(
+    "DeferredSettlementFunded(bytes32,address,uint256,uint256,uint256,uint64)"(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      amount?: null,
-      releaseTime?: null
-    ): DeferredPayoutRegisteredEventFilter;
-    DeferredPayoutRegistered(
+      payoutRecipient?: PromiseOrValue<string> | null,
+      grossAmount?: null,
+      executableAmount?: null,
+      deferredFees?: null,
+      coverageDeadline?: null
+    ): DeferredSettlementFundedEventFilter;
+    DeferredSettlementFunded(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      amount?: null,
-      releaseTime?: null
-    ): DeferredPayoutRegisteredEventFilter;
+      payoutRecipient?: PromiseOrValue<string> | null,
+      grossAmount?: null,
+      executableAmount?: null,
+      deferredFees?: null,
+      coverageDeadline?: null
+    ): DeferredSettlementFundedEventFilter;
+
+    "IntentExtended(bytes32,address,address,address,uint64,uint64,uint256,uint256)"(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      taker?: PromiseOrValue<string> | null,
+      extensionStakeOwner?: PromiseOrValue<string> | null,
+      caller?: null,
+      additionalTime?: null,
+      newExpiry?: null,
+      additionalAmount?: null,
+      totalAmount?: null
+    ): IntentExtendedEventFilter;
+    IntentExtended(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      taker?: PromiseOrValue<string> | null,
+      extensionStakeOwner?: PromiseOrValue<string> | null,
+      caller?: null,
+      additionalTime?: null,
+      newExpiry?: null,
+      additionalAmount?: null,
+      totalAmount?: null
+    ): IntentExtendedEventFilter;
+
+    "IntentExtensionResolved(bytes32,address,address,uint64,uint64,uint256,uint256)"(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      extensionStakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      terminalAt?: null,
+      chargeableTime?: null,
+      penalty?: null,
+      releasedAmount?: null
+    ): IntentExtensionResolvedEventFilter;
+    IntentExtensionResolved(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      extensionStakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      terminalAt?: null,
+      chargeableTime?: null,
+      penalty?: null,
+      releasedAmount?: null
+    ): IntentExtensionResolvedEventFilter;
 
-    "PlatformRiskConfigUpdated(bytes32,bool,bool,bool,uint16,uint64,uint256,uint256,uint256,uint256,uint256)"(
+    "PlatformRiskConfigUpdated(bytes32,bool,bool,bool,uint64,uint32)"(
       paymentMethod?: PromiseOrValue<BytesLike> | null,
       enabled?: null,
       chargebackable?: null,
       deferredPayoutEnabled?: null,
-      reserveBps?: null,
       riskWindow?: null,
-      peasantCap?: null,
-      peerCap?: null,
-      plusCap?: null,
-      proCap?: null,
-      platinumCap?: null
+      extensionPenaltyBpsPerHour?: null
     ): PlatformRiskConfigUpdatedEventFilter;
     PlatformRiskConfigUpdated(
       paymentMethod?: PromiseOrValue<BytesLike> | null,
       enabled?: null,
       chargebackable?: null,
       deferredPayoutEnabled?: null,
-      reserveBps?: null,
       riskWindow?: null,
-      peasantCap?: null,
-      peerCap?: null,
-      plusCap?: null,
-      proCap?: null,
-      platinumCap?: null
+      extensionPenaltyBpsPerHour?: null
     ): PlatformRiskConfigUpdatedEventFilter;
 
-    "RiskPositionCancelled(bytes32,address,uint256)"(
+    "RiskPositionCancelled(bytes32,address,address,uint64,uint256,uint256)"(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
-      releasedReservation?: null
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      cancelledAt?: null,
+      extensionPenalty?: null,
+      releasedCoverage?: null
     ): RiskPositionCancelledEventFilter;
     RiskPositionCancelled(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
-      releasedReservation?: null
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      cancelledAt?: null,
+      extensionPenalty?: null,
+      releasedCoverage?: null
     ): RiskPositionCancelledEventFilter;
 
-    "RiskPositionCreated(bytes32,address,address,address,bytes32,uint8,address,address,uint256,uint64,uint64)"(
+    "RiskPositionCreated(bytes32,address,address,address,bytes32,uint8,uint256,uint256,uint64,uint64,uint32)"(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
-      maker?: PromiseOrValue<string> | null,
-      stakeOwner?: null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      taker?: null,
       paymentMethod?: null,
       mode?: null,
-      deferredPayoutHook?: null,
-      payoutRecipient?: null,
-      reservedAmount?: null,
-      settlementBuffer?: null,
-      fallbackReleaseTime?: null
+      intentAmount?: null,
+      coverageAmount?: null,
+      baseIntentExpiry?: null,
+      riskWindow?: null,
+      extensionPenaltyBpsPerHour?: null
     ): RiskPositionCreatedEventFilter;
     RiskPositionCreated(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
-      maker?: PromiseOrValue<string> | null,
-      stakeOwner?: null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      taker?: null,
       paymentMethod?: null,
       mode?: null,
-      deferredPayoutHook?: null,
-      payoutRecipient?: null,
-      reservedAmount?: null,
-      settlementBuffer?: null,
-      fallbackReleaseTime?: null
+      intentAmount?: null,
+      coverageAmount?: null,
+      baseIntentExpiry?: null,
+      riskWindow?: null,
+      extensionPenaltyBpsPerHour?: null
     ): RiskPositionCreatedEventFilter;
 
-    "RiskPositionFulfilled(bytes32,address,uint8,uint256,uint256,uint64,uint64,uint64)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
-      mode?: null,
-      releasedAmount?: null,
-      reservedAmount?: null,
-      settledAt?: null,
-      slashDeadline?: null,
-      releaseTime?: null
-    ): RiskPositionFulfilledEventFilter;
-    RiskPositionFulfilled(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
-      mode?: null,
-      releasedAmount?: null,
-      reservedAmount?: null,
-      settledAt?: null,
-      slashDeadline?: null,
-      releaseTime?: null
-    ): RiskPositionFulfilledEventFilter;
-
     "RiskPositionReleased(bytes32,address,uint8,uint256)"(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
       mode?: null,
-      releasedAmount?: null
+      releasedCoverage?: null
     ): RiskPositionReleasedEventFilter;
     RiskPositionReleased(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
       mode?: null,
-      releasedAmount?: null
+      releasedCoverage?: null
     ): RiskPositionReleasedEventFilter;
 
-    "TierThresholdsUpdated(uint256,uint256,uint256,uint256)"(
-      peer?: null,
-      plus?: null,
-      pro?: null,
-      platinum?: null
-    ): TierThresholdsUpdatedEventFilter;
-    TierThresholdsUpdated(
-      peer?: null,
-      plus?: null,
-      pro?: null,
-      platinum?: null
-    ): TierThresholdsUpdatedEventFilter;
-
-    "TimingConfigUpdated(uint64,uint64)"(
-      maxIntentLifetime?: null,
-      settlementBuffer?: null
-    ): TimingConfigUpdatedEventFilter;
-    TimingConfigUpdated(
-      maxIntentLifetime?: null,
-      settlementBuffer?: null
-    ): TimingConfigUpdatedEventFilter;
+    "RiskPositionSettled(bytes32,address,address,uint8,uint256,uint256,uint256,uint64,bool)"(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      mode?: null,
+      grossAmount?: null,
+      executableAmount?: null,
+      coverageAmount?: null,
+      coverageDeadline?: null,
+      isManualRelease?: null
+    ): RiskPositionSettledEventFilter;
+    RiskPositionSettled(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      mode?: null,
+      grossAmount?: null,
+      executableAmount?: null,
+      coverageAmount?: null,
+      coverageDeadline?: null,
+      isManualRelease?: null
+    ): RiskPositionSettledEventFilter;
+
+    "RiskTakingPausedUpdated(bool)"(
+      paused?: null
+    ): RiskTakingPausedUpdatedEventFilter;
+    RiskTakingPausedUpdated(paused?: null): RiskTakingPausedUpdatedEventFilter;
   };
 
   estimateGas: {
@@ -1413,82 +1324,84 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    activeIntentCount(
-      _stakeOwner: PromiseOrValue<string>,
+    attestationVerifier(overrides?: CallOverrides): Promise<BigNumber>;
+
+    calculateIntentExtensionCost(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _extensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getPlatformRiskConfig(
-      _paymentMethod: PromiseOrValue<BytesLike>,
+    calculateIntentExtensionPenalty(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _baseIntentExpiry: PromiseOrValue<BigNumberish>,
+      _terminalAt: PromiseOrValue<BigNumberish>,
+      _totalExtensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getRiskPosition(
+    extendIntent(
       _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
+      _additionalTime: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    getTakerState(
-      _taker: PromiseOrValue<string>,
+    extensionLockId(
+      _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getTier(
-      _taker: PromiseOrValue<string>,
+    getDeferredFeeAllocations(
+      _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getTierForStake(
-      _stake: PromiseOrValue<BigNumberish>,
+    getPlatformRiskConfig(
+      _paymentMethod: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    hashChargebackAttestation(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
+    getRiskPosition(
+      _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    onIntentCancelled(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    getTakerState(
+      _taker: PromiseOrValue<string>,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    onIntentCreated(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    hashChargebackAttestation(
+      _attestation: IRiskManager.ChargebackAttestationStruct,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    onIntentFulfilled(
+    nullifierRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+
+    onIntentCancelled(
       _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    onIntentReleased(
+    onIntentCreated(
       _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
     orchestrator(overrides?: CallOverrides): Promise<BigNumber>;
 
-    reconcileSettlement(
+    reconcileCancellation(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    reconcileSettlements(
+    reconcileCancellations(
       _intentHashes: PromiseOrValue<BytesLike>[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    registerDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
     releaseMaturedPosition(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
@@ -1499,60 +1412,40 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    setAdmissionPaused(
-      _paused: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    riskTakingPaused(overrides?: CallOverrides): Promise<BigNumber>;
 
     setAttestationVerifier(
       _verifier: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    setConcurrencyLimits(
-      _limits: [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ],
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    setDeferredPayoutHook(
-      _hook: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
     setPlatformRiskConfig(
       _paymentMethod: PromiseOrValue<BytesLike>,
-      _config: IRiskTierManager.PlatformRiskConfigStruct,
+      _config: IRiskManager.PlatformRiskConfigStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    setTierThresholds(
-      _thresholds: [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ],
+    setRiskTakingPaused(
+      _paused: PromiseOrValue<boolean>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    setTimingConfig(
-      _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-      _settlementBuffer: PromiseOrValue<BigNumberish>,
+    settleIntent(
+      _context: IIntentRiskHook.RiskSettlementContextStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
+    stakeVault(overrides?: CallOverrides): Promise<BigNumber>;
+
     submitChargeback(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
-      _signatures: PromiseOrValue<BytesLike>[],
-      _verificationData: PromiseOrValue<BytesLike>,
+      _attestation: IRiskManager.ChargebackAttestationStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
+
+    usedChargebackNullifiers(
+      _nullifier: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
@@ -1560,82 +1453,86 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    activeIntentCount(
-      _stakeOwner: PromiseOrValue<string>,
+    attestationVerifier(
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getPlatformRiskConfig(
-      _paymentMethod: PromiseOrValue<BytesLike>,
+    calculateIntentExtensionCost(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _extensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getRiskPosition(
-      _intentHash: PromiseOrValue<BytesLike>,
+    calculateIntentExtensionPenalty(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _baseIntentExpiry: PromiseOrValue<BigNumberish>,
+      _terminalAt: PromiseOrValue<BigNumberish>,
+      _totalExtensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getTakerState(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    extendIntent(
+      _intentHash: PromiseOrValue<BytesLike>,
+      _additionalTime: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    getTier(
-      _taker: PromiseOrValue<string>,
+    extensionLockId(
+      _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getTierForStake(
-      _stake: PromiseOrValue<BigNumberish>,
+    getDeferredFeeAllocations(
+      _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    hashChargebackAttestation(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
+    getPlatformRiskConfig(
+      _paymentMethod: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    onIntentCancelled(
+    getRiskPosition(
       _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    onIntentCreated(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    getTakerState(
+      _taker: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    hashChargebackAttestation(
+      _attestation: IRiskManager.ChargebackAttestationStruct,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    onIntentFulfilled(
+    nullifierRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    onIntentCancelled(
       _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    onIntentReleased(
+    onIntentCreated(
       _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
     orchestrator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    reconcileSettlement(
+    reconcileCancellation(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    reconcileSettlements(
+    reconcileCancellations(
       _intentHashes: PromiseOrValue<BytesLike>[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    registerDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
     releaseMaturedPosition(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
@@ -1646,59 +1543,39 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    setAdmissionPaused(
-      _paused: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
+    riskTakingPaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     setAttestationVerifier(
       _verifier: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    setConcurrencyLimits(
-      _limits: [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ],
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    setDeferredPayoutHook(
-      _hook: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
     setPlatformRiskConfig(
       _paymentMethod: PromiseOrValue<BytesLike>,
-      _config: IRiskTierManager.PlatformRiskConfigStruct,
+      _config: IRiskManager.PlatformRiskConfigStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    setTierThresholds(
-      _thresholds: [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ],
+    setRiskTakingPaused(
+      _paused: PromiseOrValue<boolean>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    setTimingConfig(
-      _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-      _settlementBuffer: PromiseOrValue<BigNumberish>,
+    settleIntent(
+      _context: IIntentRiskHook.RiskSettlementContextStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
+    stakeVault(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     submitChargeback(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
-      _signatures: PromiseOrValue<BytesLike>[],
-      _verificationData: PromiseOrValue<BytesLike>,
+      _attestation: IRiskManager.ChargebackAttestationStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
+
+    usedChargebackNullifiers(
+      _nullifier: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
   };
 }