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

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

@@ -27,56 +27,76 @@ import type {
   PromiseOrValue,
 } from "../../common";
 
-export declare namespace IRiskTierManager {
-  export type PlatformRiskConfigStruct = {
-    enabled: PromiseOrValue<boolean>;
+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 PlatformRiskConfigStructOutput = [
-    boolean,
+  export type ChargebackConfigStructOutput = [
     boolean,
     boolean,
     number,
-    BigNumber,
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]
+    BigNumber
   ] & {
-    enabled: boolean;
     chargebackable: boolean;
     deferredPayoutEnabled: boolean;
     reserveBps: number;
     riskWindow: BigNumber;
-    tierCaps: [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber];
+  };
+
+  export type IntentExtensionConfigStruct = {
+    extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>;
+  };
+
+  export type IntentExtensionConfigStructOutput = [number] & {
+    extensionPenaltyBpsPerHour: number;
+  };
+
+  export type PlatformRiskConfigStruct = {
+    enabled: PromiseOrValue<boolean>;
+    chargeback: IRiskManager.ChargebackConfigStruct;
+    intentExtension: IRiskManager.IntentExtensionConfigStruct;
+  };
+
+  export type PlatformRiskConfigStructOutput = [
+    boolean,
+    IRiskManager.ChargebackConfigStructOutput,
+    IRiskManager.IntentExtensionConfigStructOutput
+  ] & {
+    enabled: boolean;
+    chargeback: IRiskManager.ChargebackConfigStructOutput;
+    intentExtension: IRiskManager.IntentExtensionConfigStructOutput;
   };
 
   export type RiskPositionStruct = {
     taker: PromiseOrValue<string>;
     stakeOwner: PromiseOrValue<string>;
-    maker: PromiseOrValue<string>;
+    lp: PromiseOrValue<string>;
     paymentMethod: PromiseOrValue<BytesLike>;
     mode: PromiseOrValue<BigNumberish>;
     status: PromiseOrValue<BigNumberish>;
-    countsTowardConcurrency: PromiseOrValue<boolean>;
-    deferredPayoutHook: PromiseOrValue<string>;
     payoutRecipient: PromiseOrValue<string>;
-    reserveBps: PromiseOrValue<BigNumberish>;
+    chargebackReserveBps: PromiseOrValue<BigNumberish>;
+    extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>;
     riskWindow: PromiseOrValue<BigNumberish>;
-    settlementBuffer: PromiseOrValue<BigNumberish>;
+    createdAt: PromiseOrValue<BigNumberish>;
+    baseIntentExpiry: PromiseOrValue<BigNumberish>;
+    totalExtensionTime: PromiseOrValue<BigNumberish>;
+    cancelledAt: PromiseOrValue<BigNumberish>;
     settledAt: PromiseOrValue<BigNumberish>;
-    slashDeadline: PromiseOrValue<BigNumberish>;
-    releaseTime: PromiseOrValue<BigNumberish>;
+    coverageDeadline: PromiseOrValue<BigNumberish>;
+    isManualRelease: PromiseOrValue<boolean>;
+    intentAmount: PromiseOrValue<BigNumberish>;
+    extensionStakeOwner: PromiseOrValue<string>;
+    extensionReservation: PromiseOrValue<BigNumberish>;
+    extensionPenalty: PromiseOrValue<BigNumberish>;
+    initialReservation: PromiseOrValue<BigNumberish>;
     reservedAmount: PromiseOrValue<BigNumberish>;
-    releasedAmount: PromiseOrValue<BigNumberish>;
+    grossReleasedAmount: PromiseOrValue<BigNumberish>;
+    executableAmount: PromiseOrValue<BigNumberish>;
     slashedAmount: PromiseOrValue<BigNumberish>;
   };
 
@@ -87,10 +107,9 @@ export declare namespace IRiskTierManager {
     string,
     number,
     number,
-    boolean,
-    string,
     string,
     number,
+    number,
     BigNumber,
     BigNumber,
     BigNumber,
@@ -98,123 +117,163 @@ export declare namespace IRiskTierManager {
     BigNumber,
     BigNumber,
     BigNumber,
+    boolean,
+    BigNumber,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
     BigNumber
   ] & {
     taker: string;
     stakeOwner: string;
-    maker: string;
+    lp: string;
     paymentMethod: string;
     mode: number;
     status: number;
-    countsTowardConcurrency: boolean;
-    deferredPayoutHook: string;
     payoutRecipient: string;
-    reserveBps: number;
+    chargebackReserveBps: number;
+    extensionPenaltyBpsPerHour: number;
     riskWindow: BigNumber;
-    settlementBuffer: BigNumber;
+    createdAt: BigNumber;
+    baseIntentExpiry: BigNumber;
+    totalExtensionTime: BigNumber;
+    cancelledAt: BigNumber;
     settledAt: BigNumber;
-    slashDeadline: BigNumber;
-    releaseTime: BigNumber;
+    coverageDeadline: BigNumber;
+    isManualRelease: boolean;
+    intentAmount: BigNumber;
+    extensionStakeOwner: string;
+    extensionReservation: BigNumber;
+    extensionPenalty: BigNumber;
+    initialReservation: BigNumber;
     reservedAmount: BigNumber;
-    releasedAmount: BigNumber;
+    grossReleasedAmount: BigNumber;
+    executableAmount: BigNumber;
     slashedAmount: 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>;
+    metadata: PromiseOrValue<BytesLike>;
   };
 
   export type ChargebackAttestationStructOutput = [
-    BigNumber,
     string,
     string,
+    string[],
+    string,
+    string
+  ] & {
+    intentHash: string;
+    dataHash: string;
+    signatures: string[];
+    data: string;
+    metadata: string;
+  };
+}
+
+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,
-    BigNumber,
     string,
     BigNumber,
     BigNumber,
-    BigNumber
+    boolean,
+    IIntentRiskHook.FeeAllocationStructOutput[]
   ] & {
-    chainId: BigNumber;
-    riskTierManager: string;
-    orchestrator: string;
     intentHash: string;
-    paymentMethod: string;
-    chargebackAmount: BigNumber;
-    evidenceId: string;
-    nonce: BigNumber;
-    validAfter: BigNumber;
-    validUntil: BigNumber;
+    token: string;
+    recipient: string;
+    grossAmount: BigNumber;
+    executableAmount: BigNumber;
+    isManualRelease: boolean;
+    feeAllocations: IIntentRiskHook.FeeAllocationStructOutput[];
   };
 }
 
-export interface IRiskTierManagerInterface extends utils.Interface {
+export interface IRiskManagerInterface extends utils.Interface {
   functions: {
     "acceptVaultController()": FunctionFragment;
-    "activeIntentCount(address)": FunctionFragment;
+    "calculateChargebackReserve(uint256,uint16)": FunctionFragment;
+    "calculateIntentExtensionCost(uint256,uint64,uint32)": FunctionFragment;
+    "calculateIntentExtensionPenalty(uint256,uint64,uint64,uint64,uint32)": FunctionFragment;
+    "extendIntent(bytes32,uint64)": FunctionFragment;
+    "extensionReservationId(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,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;
     "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,uint16,uint64),(uint32)))": FunctionFragment;
+    "settleIntent((bytes32,address,address,uint256,uint256,bool,(uint8,address,uint256)[]))": FunctionFragment;
+    "stakeVault()": FunctionFragment;
+    "submitChargeback((bytes32,bytes32,bytes[],bytes,bytes))": FunctionFragment;
   };
 
   getFunction(
     nameOrSignatureOrTopic:
       | "acceptVaultController"
-      | "activeIntentCount"
+      | "calculateChargebackReserve"
+      | "calculateIntentExtensionCost"
+      | "calculateIntentExtensionPenalty"
+      | "extendIntent"
+      | "extensionReservationId"
       | "getPlatformRiskConfig"
       | "getRiskPosition"
       | "getTakerState"
-      | "getTier"
-      | "getTierForStake"
       | "hashChargebackAttestation"
+      | "nullifierRegistry"
       | "onIntentCancelled"
       | "onIntentCreated"
-      | "onIntentFulfilled"
-      | "onIntentReleased"
       | "orchestrator"
-      | "reconcileSettlement"
-      | "reconcileSettlements"
-      | "registerDeferredPayout"
+      | "reconcileCancellation"
+      | "reconcileCancellations"
       | "releaseMaturedPosition"
       | "releaseMaturedPositions"
       | "setAdmissionPaused"
       | "setAttestationVerifier"
-      | "setConcurrencyLimits"
-      | "setDeferredPayoutHook"
       | "setPlatformRiskConfig"
-      | "setTierThresholds"
-      | "setTimingConfig"
+      | "settleIntent"
+      | "stakeVault"
       | "submitChargeback"
   ): FunctionFragment;
 
@@ -223,8 +282,34 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "activeIntentCount",
-    values: [PromiseOrValue<string>]
+    functionFragment: "calculateChargebackReserve",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+  ): 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: "extensionReservationId",
+    values: [PromiseOrValue<BytesLike>]
   ): string;
   encodeFunctionData(
     functionFragment: "getPlatformRiskConfig",
@@ -239,16 +324,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 +339,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>]
@@ -302,51 +367,21 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     functionFragment: "setAttestationVerifier",
     values: [PromiseOrValue<string>]
   ): string;
-  encodeFunctionData(
-    functionFragment: "setConcurrencyLimits",
-    values: [
-      [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ]
-    ]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "setDeferredPayoutHook",
-    values: [PromiseOrValue<string>]
-  ): string;
   encodeFunctionData(
     functionFragment: "setPlatformRiskConfig",
-    values: [
-      PromiseOrValue<BytesLike>,
-      IRiskTierManager.PlatformRiskConfigStruct
-    ]
+    values: [PromiseOrValue<BytesLike>, IRiskManager.PlatformRiskConfigStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "setTierThresholds",
-    values: [
-      [
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-      ]
-    ]
+    functionFragment: "settleIntent",
+    values: [IIntentRiskHook.RiskSettlementContextStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "setTimingConfig",
-    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+    functionFragment: "stakeVault",
+    values?: undefined
   ): string;
   encodeFunctionData(
     functionFragment: "submitChargeback",
-    values: [
-      IRiskTierManager.ChargebackAttestationStruct,
-      PromiseOrValue<BytesLike>[],
-      PromiseOrValue<BytesLike>
-    ]
+    values: [IRiskManager.ChargebackAttestationStruct]
   ): string;
 
   decodeFunctionResult(
@@ -354,60 +389,63 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "activeIntentCount",
+    functionFragment: "calculateChargebackReserve",
     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: "extensionReservationId",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "hashChargebackAttestation",
+    functionFragment: "getPlatformRiskConfig",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "onIntentCancelled",
+    functionFragment: "getRiskPosition",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "onIntentCreated",
+    functionFragment: "getTakerState",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "onIntentFulfilled",
+    functionFragment: "hashChargebackAttestation",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "onIntentReleased",
+    functionFragment: "nullifierRegistry",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "orchestrator",
+    functionFragment: "onIntentCancelled",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "reconcileSettlement",
+    functionFragment: "onIntentCreated",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "reconcileSettlements",
+    functionFragment: "orchestrator",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "reconcileCancellation",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "registerDeferredPayout",
+    functionFragment: "reconcileCancellations",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -426,26 +464,15 @@ export interface IRiskTierManagerInterface extends utils.Interface {
     functionFragment: "setAttestationVerifier",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(
-    functionFragment: "setConcurrencyLimits",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "setDeferredPayoutHook",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(
     functionFragment: "setPlatformRiskConfig",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setTierThresholds",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "setTimingConfig",
+    functionFragment: "settleIntent",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "stakeVault", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "submitChargeback",
     data: BytesLike
@@ -454,32 +481,28 @@ export interface IRiskTierManagerInterface extends utils.Interface {
   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,uint256,bytes32)": EventFragment;
+    "DeferredSettlementFunded(bytes32,address,uint256,uint256,uint256,uint256,uint64)": EventFragment;
+    "IntentExtended(bytes32,address,address,address,uint64,uint64,uint256,uint256)": EventFragment;
+    "IntentExtensionCharged(bytes32,address,address,address,uint64,uint64,uint256,uint256)": EventFragment;
+    "PlatformRiskConfigUpdated(bytes32,bool,bool,bool,uint16,uint64,uint32)": EventFragment;
+    "RiskPositionCancelled(bytes32,address,address,uint64,uint256,uint256)": EventFragment;
+    "RiskPositionCreated(bytes32,address,address,address,bytes32,uint8,uint256,uint64,uint64,uint32,uint16,uint64,uint256,uint256)": 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,uint256,uint64,uint64,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: "IntentExtensionCharged"): 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;
 }
 
 export interface AdmissionPausedUpdatedEventObject {
@@ -507,73 +530,72 @@ 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;
+  grossReleasedAmount: BigNumber;
+  compensatedAmount: BigNumber;
+  disputeId: string;
 }
 export type ChargebackSettledEvent = TypedEvent<
-  [
-    string,
-    string,
-    string,
-    number,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    string
-  ],
+  [string, string, string, number, BigNumber, 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;
+  staker: string;
+  grossAmount: BigNumber;
+  executableAmount: BigNumber;
+  feeAmount: BigNumber;
+  chargebackCoverage: BigNumber;
+  coverageDeadline: BigNumber;
 }
-export type ConcurrencyLimitsUpdatedEvent = TypedEvent<
-  [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
-  ConcurrencyLimitsUpdatedEventObject
+export type DeferredSettlementFundedEvent = TypedEvent<
+  [string, string, BigNumber, 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;
+  newExpiryTime: BigNumber;
+  additionalReservation: BigNumber;
+  totalReservation: 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 IntentExtensionChargedEventObject {
   intentHash: string;
-  beneficiary: string;
-  amount: BigNumber;
-  releaseTime: BigNumber;
+  extensionStakeOwner: string;
+  lp: string;
+  taker: string;
+  terminalAt: BigNumber;
+  chargeableTime: BigNumber;
+  penalty: BigNumber;
+  releasedReservation: BigNumber;
 }
-export type DeferredPayoutRegisteredEvent = TypedEvent<
-  [string, string, BigNumber, BigNumber],
-  DeferredPayoutRegisteredEventObject
+export type IntentExtensionChargedEvent = TypedEvent<
+  [string, string, string, string, BigNumber, BigNumber, BigNumber, BigNumber],
+  IntentExtensionChargedEventObject
 >;
 
-export type DeferredPayoutRegisteredEventFilter =
-  TypedEventFilter<DeferredPayoutRegisteredEvent>;
+export type IntentExtensionChargedEventFilter =
+  TypedEventFilter<IntentExtensionChargedEvent>;
 
 export interface PlatformRiskConfigUpdatedEventObject {
   paymentMethod: string;
@@ -582,26 +604,10 @@ export interface PlatformRiskConfigUpdatedEventObject {
   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, number, BigNumber, number],
   PlatformRiskConfigUpdatedEventObject
 >;
 
@@ -610,11 +616,14 @@ export type PlatformRiskConfigUpdatedEventFilter =
 
 export interface RiskPositionCancelledEventObject {
   intentHash: string;
-  taker: string;
+  stakeOwner: string;
+  lp: string;
+  cancelledAt: BigNumber;
+  extensionPenalty: BigNumber;
   releasedReservation: BigNumber;
 }
 export type RiskPositionCancelledEvent = TypedEvent<
-  [string, string, BigNumber],
+  [string, string, string, BigNumber, BigNumber, BigNumber],
   RiskPositionCancelledEventObject
 >;
 
@@ -623,16 +632,19 @@ 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;
+  createdAt: BigNumber;
+  baseIntentExpiry: BigNumber;
+  extensionPenaltyBpsPerHour: number;
+  chargebackReserveBps: number;
+  riskWindow: BigNumber;
+  chargebackReserve: BigNumber;
+  initialReservation: BigNumber;
 }
 export type RiskPositionCreatedEvent = TypedEvent<
   [
@@ -642,50 +654,26 @@ export type RiskPositionCreatedEvent = TypedEvent<
     string,
     string,
     number,
-    string,
-    string,
     BigNumber,
     BigNumber,
-    BigNumber
-  ],
-  RiskPositionCreatedEventObject
->;
-
-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,
+    number,
+    number,
     BigNumber,
     BigNumber,
     BigNumber
   ],
-  RiskPositionFulfilledEventObject
+  RiskPositionCreatedEventObject
 >;
 
-export type RiskPositionFulfilledEventFilter =
-  TypedEventFilter<RiskPositionFulfilledEvent>;
+export type RiskPositionCreatedEventFilter =
+  TypedEventFilter<RiskPositionCreatedEvent>;
 
 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 +683,45 @@ export type RiskPositionReleasedEvent = TypedEvent<
 export type RiskPositionReleasedEventFilter =
   TypedEventFilter<RiskPositionReleasedEvent>;
 
-export interface TierThresholdsUpdatedEventObject {
-  peer: BigNumber;
-  plus: BigNumber;
-  pro: BigNumber;
-  platinum: BigNumber;
-}
-export type TierThresholdsUpdatedEvent = TypedEvent<
-  [BigNumber, BigNumber, BigNumber, BigNumber],
-  TierThresholdsUpdatedEventObject
->;
-
-export type TierThresholdsUpdatedEventFilter =
-  TypedEventFilter<TierThresholdsUpdatedEvent>;
-
-export interface TimingConfigUpdatedEventObject {
-  maxIntentLifetime: BigNumber;
-  settlementBuffer: BigNumber;
+export interface RiskPositionSettledEventObject {
+  intentHash: string;
+  stakeOwner: string;
+  lp: string;
+  mode: number;
+  grossReleasedAmount: BigNumber;
+  executableAmount: BigNumber;
+  chargebackCoverage: BigNumber;
+  releasedReservation: BigNumber;
+  settledAt: BigNumber;
+  coverageDeadline: BigNumber;
+  isManualRelease: boolean;
 }
-export type TimingConfigUpdatedEvent = TypedEvent<
-  [BigNumber, BigNumber],
-  TimingConfigUpdatedEventObject
+export type RiskPositionSettledEvent = TypedEvent<
+  [
+    string,
+    string,
+    string,
+    number,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    boolean
+  ],
+  RiskPositionSettledEventObject
 >;
 
-export type TimingConfigUpdatedEventFilter =
-  TypedEventFilter<TimingConfigUpdatedEvent>;
+export type RiskPositionSettledEventFilter =
+  TypedEventFilter<RiskPositionSettledEvent>;
 
-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,50 +747,71 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    activeIntentCount(
-      _stakeOwner: PromiseOrValue<string>,
+    calculateChargebackReserve(
+      _amount: PromiseOrValue<BigNumberish>,
+      _reserveBps: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    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>;
+
+    extensionReservationId(
+      _intentHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
     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, boolean] & {
+        stakeOwner: string;
         totalStake: BigNumber;
         reserved: BigNumber;
         free: BigNumber;
         exiting: boolean;
-        activeIntents: 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> }
@@ -806,37 +822,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> }
@@ -857,48 +854,21 @@ export interface IRiskTierManager extends BaseContract {
       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>
-      ],
+    settleIntent(
+      _context: IIntentRiskHook.RiskSettlementContextStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    setTimingConfig(
-      _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-      _settlementBuffer: PromiseOrValue<BigNumberish>,
-      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>;
   };
@@ -907,50 +877,71 @@ export interface IRiskTierManager extends BaseContract {
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  activeIntentCount(
-    _stakeOwner: PromiseOrValue<string>,
+  calculateChargebackReserve(
+    _amount: PromiseOrValue<BigNumberish>,
+    _reserveBps: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  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>;
+
+  extensionReservationId(
+    _intentHash: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   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, boolean] & {
+      stakeOwner: string;
       totalStake: BigNumber;
       reserved: BigNumber;
       free: BigNumber;
       exiting: boolean;
-      activeIntents: 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 +952,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> }
@@ -1012,98 +984,92 @@ export interface IRiskTierManager extends BaseContract {
     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>
-    ],
+  settleIntent(
+    _context: IIntentRiskHook.RiskSettlementContextStruct,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  setTimingConfig(
-    _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-    _settlementBuffer: PromiseOrValue<BigNumberish>,
-    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>;
 
   callStatic: {
     acceptVaultController(overrides?: CallOverrides): Promise<void>;
 
-    activeIntentCount(
-      _stakeOwner: PromiseOrValue<string>,
+    calculateChargebackReserve(
+      _amount: PromiseOrValue<BigNumberish>,
+      _reserveBps: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    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>;
+
+    extensionReservationId(
+      _intentHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     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, boolean] & {
+        stakeOwner: string;
         totalStake: BigNumber;
         reserved: BigNumber;
         free: BigNumber;
         exiting: boolean;
-        activeIntents: 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 +1078,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
@@ -1165,48 +1112,21 @@ export interface IRiskTierManager extends BaseContract {
       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>
-      ],
+    settleIntent(
+      _context: IIntentRiskHook.RiskSettlementContextStruct,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    setTimingConfig(
-      _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-      _settlementBuffer: PromiseOrValue<BigNumberish>,
-      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>;
   };
@@ -1226,78 +1146,94 @@ 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,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
+      grossReleasedAmount?: 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
+      grossReleasedAmount?: 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,uint256,uint64)"(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      staker?: PromiseOrValue<string> | null,
+      grossAmount?: null,
+      executableAmount?: null,
+      feeAmount?: null,
+      chargebackCoverage?: null,
+      coverageDeadline?: null
+    ): DeferredSettlementFundedEventFilter;
+    DeferredSettlementFunded(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      amount?: null,
-      releaseTime?: null
-    ): DeferredPayoutRegisteredEventFilter;
-    DeferredPayoutRegistered(
+      staker?: PromiseOrValue<string> | null,
+      grossAmount?: null,
+      executableAmount?: null,
+      feeAmount?: null,
+      chargebackCoverage?: 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,
+      newExpiryTime?: null,
+      additionalReservation?: null,
+      totalReservation?: null
+    ): IntentExtendedEventFilter;
+    IntentExtended(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      amount?: null,
-      releaseTime?: null
-    ): DeferredPayoutRegisteredEventFilter;
+      taker?: PromiseOrValue<string> | null,
+      extensionStakeOwner?: PromiseOrValue<string> | null,
+      caller?: null,
+      additionalTime?: null,
+      newExpiryTime?: null,
+      additionalReservation?: null,
+      totalReservation?: null
+    ): IntentExtendedEventFilter;
+
+    "IntentExtensionCharged(bytes32,address,address,address,uint64,uint64,uint256,uint256)"(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      extensionStakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      taker?: null,
+      terminalAt?: null,
+      chargeableTime?: null,
+      penalty?: null,
+      releasedReservation?: null
+    ): IntentExtensionChargedEventFilter;
+    IntentExtensionCharged(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      extensionStakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      taker?: null,
+      terminalAt?: null,
+      chargeableTime?: null,
+      penalty?: null,
+      releasedReservation?: null
+    ): IntentExtensionChargedEventFilter;
 
-    "PlatformRiskConfigUpdated(bytes32,bool,bool,bool,uint16,uint64,uint256,uint256,uint256,uint256,uint256)"(
+    "PlatformRiskConfigUpdated(bytes32,bool,bool,bool,uint16,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,
@@ -1306,106 +1242,98 @@ export interface IRiskTierManager extends BaseContract {
       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,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      cancelledAt?: null,
+      extensionPenalty?: null,
       releasedReservation?: null
     ): RiskPositionCancelledEventFilter;
     RiskPositionCancelled(
       intentHash?: PromiseOrValue<BytesLike> | null,
-      taker?: PromiseOrValue<string> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      cancelledAt?: null,
+      extensionPenalty?: null,
       releasedReservation?: null
     ): RiskPositionCancelledEventFilter;
 
-    "RiskPositionCreated(bytes32,address,address,address,bytes32,uint8,address,address,uint256,uint64,uint64)"(
+    "RiskPositionCreated(bytes32,address,address,address,bytes32,uint8,uint256,uint64,uint64,uint32,uint16,uint64,uint256,uint256)"(
       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,
+      createdAt?: null,
+      baseIntentExpiry?: null,
+      extensionPenaltyBpsPerHour?: null,
+      chargebackReserveBps?: null,
+      riskWindow?: null,
+      chargebackReserve?: null,
+      initialReservation?: 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,
+      createdAt?: null,
+      baseIntentExpiry?: null,
+      extensionPenaltyBpsPerHour?: null,
+      chargebackReserveBps?: null,
+      riskWindow?: null,
+      chargebackReserve?: null,
+      initialReservation?: 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,uint256,uint64,uint64,bool)"(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      mode?: null,
+      grossReleasedAmount?: null,
+      executableAmount?: null,
+      chargebackCoverage?: null,
+      releasedReservation?: null,
+      settledAt?: null,
+      coverageDeadline?: null,
+      isManualRelease?: null
+    ): RiskPositionSettledEventFilter;
+    RiskPositionSettled(
+      intentHash?: PromiseOrValue<BytesLike> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
+      lp?: PromiseOrValue<string> | null,
+      mode?: null,
+      grossReleasedAmount?: null,
+      executableAmount?: null,
+      chargebackCoverage?: null,
+      releasedReservation?: null,
+      settledAt?: null,
+      coverageDeadline?: null,
+      isManualRelease?: null
+    ): RiskPositionSettledEventFilter;
   };
 
   estimateGas: {
@@ -1413,41 +1341,61 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    activeIntentCount(
-      _stakeOwner: PromiseOrValue<string>,
+    calculateChargebackReserve(
+      _amount: PromiseOrValue<BigNumberish>,
+      _reserveBps: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getPlatformRiskConfig(
-      _paymentMethod: PromiseOrValue<BytesLike>,
+    calculateIntentExtensionCost(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _extensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getRiskPosition(
+    calculateIntentExtensionPenalty(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _baseIntentExpiry: PromiseOrValue<BigNumberish>,
+      _terminalAt: PromiseOrValue<BigNumberish>,
+      _totalExtensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    extendIntent(
+      _intentHash: PromiseOrValue<BytesLike>,
+      _additionalTime: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    extensionReservationId(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getTakerState(
-      _taker: PromiseOrValue<string>,
+    getPlatformRiskConfig(
+      _paymentMethod: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getTier(
-      _taker: PromiseOrValue<string>,
+    getRiskPosition(
+      _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getTierForStake(
-      _stake: PromiseOrValue<BigNumberish>,
+    getTakerState(
+      _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
     hashChargebackAttestation(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
+      _attestation: IRiskManager.ChargebackAttestationStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    nullifierRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+
     onIntentCancelled(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
@@ -1458,37 +1406,18 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    onIntentFulfilled(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    onIntentReleased(
-      _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> }
@@ -1509,48 +1438,21 @@ export interface IRiskTierManager extends BaseContract {
       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>
-      ],
+    settleIntent(
+      _context: IIntentRiskHook.RiskSettlementContextStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    setTimingConfig(
-      _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-      _settlementBuffer: PromiseOrValue<BigNumberish>,
-      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>;
   };
@@ -1560,41 +1462,61 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    activeIntentCount(
-      _stakeOwner: PromiseOrValue<string>,
+    calculateChargebackReserve(
+      _amount: PromiseOrValue<BigNumberish>,
+      _reserveBps: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getPlatformRiskConfig(
-      _paymentMethod: PromiseOrValue<BytesLike>,
+    calculateIntentExtensionCost(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _extensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getRiskPosition(
+    calculateIntentExtensionPenalty(
+      _intentAmount: PromiseOrValue<BigNumberish>,
+      _baseIntentExpiry: PromiseOrValue<BigNumberish>,
+      _terminalAt: PromiseOrValue<BigNumberish>,
+      _totalExtensionTime: PromiseOrValue<BigNumberish>,
+      _extensionPenaltyBpsPerHour: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    extendIntent(
+      _intentHash: PromiseOrValue<BytesLike>,
+      _additionalTime: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    extensionReservationId(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getTakerState(
-      _taker: PromiseOrValue<string>,
+    getPlatformRiskConfig(
+      _paymentMethod: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getTier(
-      _taker: PromiseOrValue<string>,
+    getRiskPosition(
+      _intentHash: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getTierForStake(
-      _stake: PromiseOrValue<BigNumberish>,
+    getTakerState(
+      _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
     hashChargebackAttestation(
-      _attestation: IRiskTierManager.ChargebackAttestationStruct,
+      _attestation: IRiskManager.ChargebackAttestationStruct,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    nullifierRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     onIntentCancelled(
       _intentHash: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
@@ -1605,37 +1527,18 @@ export interface IRiskTierManager extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    onIntentFulfilled(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _releasedAmount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    onIntentReleased(
-      _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> }
@@ -1656,48 +1559,21 @@ export interface IRiskTierManager extends BaseContract {
       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>
-      ],
+    settleIntent(
+      _context: IIntentRiskHook.RiskSettlementContextStruct,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    setTimingConfig(
-      _maxIntentLifetime: PromiseOrValue<BigNumberish>,
-      _settlementBuffer: PromiseOrValue<BigNumberish>,
-      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>;
   };