@oddmaki-protocol/sdk 1.4.1 → 1.5.0

package/dist/index.d.mts

@@ -9264,6 +9264,27 @@ declare class UmaModule extends BaseModule {
      * Settle an assertion after the liveness period
      */
     settleAssertion(assertionId: `0x${string}`): Promise<`0x${string}`>;
+    /**
+     * Get the UMA Optimistic Oracle V3 address for the active Diamond.
+     */
+    getUmaOracleAddress(): Promise<Address>;
+    /**
+     * Dispute an active assertion directly on the UMA Optimistic Oracle V3.
+     *
+     * The dispute escalates the assertion to UMA's DVM, which arbitrates the
+     * outcome via tokenholder vote. The disputer must post a bond equal to the
+     * asserter's bond — the winner is reimbursed and receives a share of the
+     * loser's bond.
+     *
+     * @param params.assertionId - The active assertionId to dispute
+     * @param params.autoApprove - Approve the bond currency to the oracle if needed (default: true)
+     *
+     * @returns Transaction hash
+     */
+    disputeAssertion(params: {
+        assertionId: `0x${string}`;
+        autoApprove?: boolean;
+    }): Promise<`0x${string}`>;
     /**
      * Report resolution after UMA settlement
      */
@@ -9328,6 +9349,8 @@ declare class UmaModule extends BaseModule {
         canSettle: boolean;
         disputer: `0x${string}`;
         isDisputed: boolean;
+        currency: Address;
+        bond: bigint;
     }>;
     /**
      * Get comprehensive market status for UMA resolution
@@ -17250,6 +17273,25 @@ var UmaOracle = [
 		outputs: [
 		],
 		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "disputeAssertion",
+		inputs: [
+			{
+				name: "assertionId",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "disputer",
+				type: "address",
+				internalType: "address"
+			}
+		],
+		outputs: [
+		],
+		stateMutability: "nonpayable"
 	}
 ];
 

package/dist/index.d.ts

@@ -9264,6 +9264,27 @@ declare class UmaModule extends BaseModule {
      * Settle an assertion after the liveness period
      */
     settleAssertion(assertionId: `0x${string}`): Promise<`0x${string}`>;
+    /**
+     * Get the UMA Optimistic Oracle V3 address for the active Diamond.
+     */
+    getUmaOracleAddress(): Promise<Address>;
+    /**
+     * Dispute an active assertion directly on the UMA Optimistic Oracle V3.
+     *
+     * The dispute escalates the assertion to UMA's DVM, which arbitrates the
+     * outcome via tokenholder vote. The disputer must post a bond equal to the
+     * asserter's bond — the winner is reimbursed and receives a share of the
+     * loser's bond.
+     *
+     * @param params.assertionId - The active assertionId to dispute
+     * @param params.autoApprove - Approve the bond currency to the oracle if needed (default: true)
+     *
+     * @returns Transaction hash
+     */
+    disputeAssertion(params: {
+        assertionId: `0x${string}`;
+        autoApprove?: boolean;
+    }): Promise<`0x${string}`>;
     /**
      * Report resolution after UMA settlement
      */
@@ -9328,6 +9349,8 @@ declare class UmaModule extends BaseModule {
         canSettle: boolean;
         disputer: `0x${string}`;
         isDisputed: boolean;
+        currency: Address;
+        bond: bigint;
     }>;
     /**
      * Get comprehensive market status for UMA resolution
@@ -17250,6 +17273,25 @@ var UmaOracle = [
 		outputs: [
 		],
 		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "disputeAssertion",
+		inputs: [
+			{
+				name: "assertionId",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "disputer",
+				type: "address",
+				internalType: "address"
+			}
+		],
+		outputs: [
+		],
+		stateMutability: "nonpayable"
 	}
 ];
 

package/dist/index.js

@@ -7121,6 +7121,24 @@ var UmaOracle_default = [
     ],
     outputs: [],
     stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "disputeAssertion",
+    inputs: [
+      {
+        name: "assertionId",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "disputer",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
   }
 ];
 
@@ -10499,6 +10517,97 @@ var UmaModule = class extends BaseModule {
     });
     return wallet.writeContract(request);
   }
+  /**
+   * Get the UMA Optimistic Oracle V3 address for the active Diamond.
+   */
+  async getUmaOracleAddress() {
+    return await this.publicClient.readContract({
+      address: this.config.diamondAddress,
+      abi: ProtocolFacet_default,
+      functionName: "getUmaOracle"
+    });
+  }
+  /**
+   * Dispute an active assertion directly on the UMA Optimistic Oracle V3.
+   *
+   * The dispute escalates the assertion to UMA's DVM, which arbitrates the
+   * outcome via tokenholder vote. The disputer must post a bond equal to the
+   * asserter's bond — the winner is reimbursed and receives a share of the
+   * loser's bond.
+   *
+   * @param params.assertionId - The active assertionId to dispute
+   * @param params.autoApprove - Approve the bond currency to the oracle if needed (default: true)
+   *
+   * @returns Transaction hash
+   */
+  async disputeAssertion(params) {
+    const wallet = this.walletClient;
+    const account = await this.getSignerAccount();
+    const accountAddress = await this.getSignerAddress();
+    const autoApprove = params.autoApprove ?? true;
+    const oracleAddress = await this.getUmaOracleAddress();
+    const assertion = await this.publicClient.readContract({
+      address: oracleAddress,
+      abi: UmaOracle_default,
+      functionName: "getAssertion",
+      args: [params.assertionId]
+    });
+    const currency = assertion.currency;
+    const bondAmount = BigInt(assertion.bond);
+    if (assertion.disputer !== "0x0000000000000000000000000000000000000000") {
+      throw new Error("Assertion has already been disputed");
+    }
+    if (assertion.settled) {
+      throw new Error("Assertion is already settled");
+    }
+    const currentTime = Math.floor(Date.now() / 1e3);
+    if (currentTime >= Number(assertion.expirationTime)) {
+      throw new Error("Liveness period has expired \u2014 assertion can no longer be disputed");
+    }
+    const currentAllowance = await this.publicClient.readContract({
+      address: currency,
+      abi: viem.erc20Abi,
+      functionName: "allowance",
+      args: [accountAddress, oracleAddress]
+    });
+    if (currentAllowance < bondAmount && autoApprove) {
+      const approveHash = await wallet.writeContract({
+        address: currency,
+        abi: viem.erc20Abi,
+        functionName: "approve",
+        args: [oracleAddress, bondAmount],
+        account,
+        chain: this.config.chain
+      });
+      await this.publicClient.waitForTransactionReceipt({
+        hash: approveHash,
+        confirmations: 2
+      });
+    } else if (currentAllowance < bondAmount) {
+      throw new Error(
+        `Insufficient bond currency allowance for oracle. Required: ${bondAmount.toString()}, Current: ${currentAllowance.toString()}.`
+      );
+    }
+    const balance = await this.publicClient.readContract({
+      address: currency,
+      abi: viem.erc20Abi,
+      functionName: "balanceOf",
+      args: [accountAddress]
+    });
+    if (balance < bondAmount) {
+      throw new Error(
+        `Insufficient bond currency balance. Required: ${bondAmount.toString()}, Have: ${balance.toString()}`
+      );
+    }
+    const { request } = await this.publicClient.simulateContract({
+      address: oracleAddress,
+      abi: UmaOracle_default,
+      functionName: "disputeAssertion",
+      args: [params.assertionId, accountAddress],
+      account
+    });
+    return wallet.writeContract(request);
+  }
   /**
    * Report resolution after UMA settlement
    */
@@ -10714,7 +10823,9 @@ var UmaModule = class extends BaseModule {
       expirationTime,
       canSettle: currentTime >= expirationTime,
       disputer: assertion.disputer,
-      isDisputed: assertion.disputer !== "0x0000000000000000000000000000000000000000"
+      isDisputed: assertion.disputer !== "0x0000000000000000000000000000000000000000",
+      currency: assertion.currency,
+      bond: BigInt(assertion.bond)
     };
   }
   /**