@bosonprotocol/core-sdk 1.44.0-alpha.6 → 1.44.0-alpha.8

package/src/disputes/handler.ts

@@ -18,7 +18,11 @@ import {
   encodeResolveDispute,
   encodeRetractDispute
 } from "./interface";
-import { prepareDataSignatureParameters } from "../utils/signature";
+import {
+  getSignatureParameters,
+  prepareDataSignatureParameters,
+  StructuredData
+} from "../utils/signature";
 
 // Overload: returnTxInfo is true → returns TransactionRequest
 export async function raiseDispute(args: {
@@ -364,7 +368,24 @@ export async function signResolutionProposal(args: {
   contractAddress: string;
   web3Lib: Web3LibAdapter;
   chainId: number;
-}) {
+  returnTypedDataToSign: true;
+}): Promise<StructuredData>;
+export async function signResolutionProposal(args: {
+  exchangeId: BigNumberish;
+  buyerPercentBasisPoints: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  chainId: number;
+  returnTypedDataToSign?: false;
+}): Promise<ReturnType<typeof getSignatureParameters>>;
+export async function signResolutionProposal(args: {
+  exchangeId: BigNumberish;
+  buyerPercentBasisPoints: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  chainId: number;
+  returnTypedDataToSign?: boolean;
+}): Promise<StructuredData | ReturnType<typeof getSignatureParameters>> {
   const customSignatureType = {
     Resolution: [
       { name: "exchangeId", type: "uint256" },
@@ -377,12 +398,24 @@ export async function signResolutionProposal(args: {
     buyerPercentBasisPoints: args.buyerPercentBasisPoints.toString()
   };
 
-  return prepareDataSignatureParameters({
+  const signatureArgs = {
     message,
     customSignatureType,
     web3Lib: args.web3Lib,
     verifyingContractAddress: args.contractAddress,
     chainId: args.chainId,
     primaryType: "Resolution"
-  });
+  } as const;
+
+  if (args.returnTypedDataToSign) {
+    return prepareDataSignatureParameters({
+      ...signatureArgs,
+      returnTypedDataToSign: true
+    });
+  } else {
+    return prepareDataSignatureParameters({
+      ...signatureArgs,
+      returnTypedDataToSign: false
+    });
+  }
 }

package/src/disputes/mixin.ts

@@ -25,6 +25,7 @@ import {
   getDisputeById,
   getDisputes
 } from "./subgraph";
+import { getSignatureParameters, StructuredData } from "../utils/signature";
 
 export class DisputesMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
@@ -460,12 +461,35 @@ export class DisputesMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   public async signDisputeResolutionProposal(args: {
     exchangeId: BigNumberish;
     buyerPercentBasisPoints: BigNumberish;
-  }) {
-    return signResolutionProposal({
-      ...args,
+    returnTypedDataToSign: true;
+  }): Promise<StructuredData>;
+  public async signDisputeResolutionProposal(args: {
+    exchangeId: BigNumberish;
+    buyerPercentBasisPoints: BigNumberish;
+    returnTypedDataToSign?: false;
+  }): Promise<ReturnType<typeof getSignatureParameters>>;
+  public async signDisputeResolutionProposal(args: {
+    exchangeId: BigNumberish;
+    buyerPercentBasisPoints: BigNumberish;
+    returnTypedDataToSign?: boolean;
+  }): Promise<StructuredData | ReturnType<typeof getSignatureParameters>> {
+    const { returnTypedDataToSign, ...argsWithoutReturnTypedDataToSign } = args;
+    const params = {
+      ...argsWithoutReturnTypedDataToSign,
       web3Lib: this._web3Lib,
       contractAddress: this._protocolDiamond,
       chainId: this._chainId
-    });
+    };
+    if (returnTypedDataToSign === true) {
+      return signResolutionProposal({
+        ...params,
+        returnTypedDataToSign: true
+      });
+    } else {
+      return signResolutionProposal({
+        ...params,
+        returnTypedDataToSign: false
+      });
+    }
   }
 }

package/src/meta-tx/handler.ts

@@ -118,7 +118,8 @@ export async function signMetaTx(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTransaction",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -179,7 +180,8 @@ export async function signVoucherMetaTx(
       version: "0.0.1",
       chainId,
       salt: undefined
-    }
+    },
+    returnTypedDataToSign: false
   });
 
   return {
@@ -286,7 +288,8 @@ export async function signBiconomyVoucherMetaTx(
       ...biconomyForwarderDomainData
       // chainId
       // salt: undefined
-    }
+    },
+    returnTypedDataToSign: false
   });
   const signature = signatureParams.signature;
   const getDomainSeparator = async () => {
@@ -861,7 +864,8 @@ export async function signMetaTxCommitToOffer(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTxCommitToOffer",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -920,7 +924,8 @@ export async function signMetaTxCommitToConditionalOffer(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTxCommitToConditionalOffer",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -1043,7 +1048,8 @@ export async function signMetaTxResolveDispute(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTxDisputeResolution",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -1124,7 +1130,8 @@ export async function signMetaTxWithdrawFunds(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTxFund",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -1213,7 +1220,8 @@ function makeExchangeMetaTxSigner(
       verifyingContractAddress: args.metaTxHandlerAddress,
       customSignatureType,
       primaryType: "MetaTxExchange",
-      message
+      message,
+      returnTypedDataToSign: false
     });
 
     return {

package/src/native-meta-tx/handler.ts

@@ -86,7 +86,8 @@ export async function signNativeMetaTx(
     customSignatureType,
     customDomainData: args.domain,
     primaryType: "MetaTransaction",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {

package/src/utils/signature.ts

@@ -2,7 +2,7 @@ import { Web3LibAdapter } from "@bosonprotocol/common";
 import { isHexString, hexZeroPad } from "@ethersproject/bytes";
 import { BigNumber } from "@ethersproject/bignumber";
 
-type SignatureArgs = {
+type SignatureArgs<T extends boolean> = {
   web3Lib: Web3LibAdapter;
   verifyingContractAddress: string;
   chainId: number;
@@ -10,9 +10,35 @@ type SignatureArgs = {
   customDomainData?: Record<string, unknown>;
   primaryType: string;
   message: Record<string, unknown>;
+  returnTypedDataToSign: T;
 };
 
-export async function prepareDataSignatureParameters(args: SignatureArgs) {
+export type StructuredData = {
+  types: {
+    EIP712Domain: {
+      name: string;
+      type: string;
+    }[];
+  };
+  domain: {
+    name: string;
+    version: string;
+    verifyingContract: string;
+    salt: string;
+  };
+  primaryType: string;
+  message: Record<string, unknown>;
+};
+
+export async function prepareDataSignatureParameters(
+  args: SignatureArgs<true>
+): Promise<StructuredData>;
+export async function prepareDataSignatureParameters(
+  args: SignatureArgs<false>
+): Promise<ReturnType<typeof getSignatureParameters>>;
+export async function prepareDataSignatureParameters(
+  args: SignatureArgs<boolean>
+): Promise<StructuredData | ReturnType<typeof getSignatureParameters>> {
   const domainType = [
     { name: "name", type: "string" },
     { name: "version", type: "string" },
@@ -36,15 +62,25 @@ export async function prepareDataSignatureParameters(args: SignatureArgs) {
   const signatureTypes = {
     EIP712Domain: domainType,
     ...args.customSignatureType
+  } satisfies {
+    EIP712Domain: {
+      name: string;
+      type: string;
+    }[];
   };
 
-  const dataToSign = JSON.stringify({
+  const structuredDataToSign = {
     types: signatureTypes,
     domain: domainData,
     primaryType: args.primaryType,
     message: args.message
-  });
+  } satisfies StructuredData;
+
+  if (args.returnTypedDataToSign) {
+    return structuredDataToSign; // Return the raw EIP-712 data
+  }
 
+  const dataToSign = JSON.stringify(structuredDataToSign);
   const signerAddress = await args.web3Lib.getSignerAddress();
   const signature = await args.web3Lib.send("eth_signTypedData_v4", [
     signerAddress,
@@ -54,7 +90,12 @@ export async function prepareDataSignatureParameters(args: SignatureArgs) {
   return getSignatureParameters(signature);
 }
 
-export function getSignatureParameters(signature: string) {
+export function getSignatureParameters(signature: string): {
+  r: string;
+  s: string;
+  v: number;
+  signature: string;
+} {
   if (!isHexString(signature)) {
     throw new Error(`Value "${signature}" is not a valid hex string`);
   }