@bosonprotocol/core-sdk 1.47.0-alpha.3 → 1.47.0-alpha.5

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

@@ -7,7 +7,11 @@ import {
 import { BigNumberish, BigNumber } from "@ethersproject/bignumber";
 import { BytesLike } from "@ethersproject/bytes";
 import { Biconomy } from "../meta-tx/biconomy";
-import { BaseMetaTxArgs, SignedMetaTx } from "../meta-tx/handler";
+import {
+  BaseMetaTxArgs,
+  SignedMetaTx,
+  UnsignedMetaTx
+} from "../meta-tx/handler";
 import { prepareDataSignatureParameters } from "../utils/signature";
 import {
   nativeMetaTransactionsIface,
@@ -52,16 +56,27 @@ export async function getNonce(args: {
   }
 }
 
+type NativeMetaTxArgs = BaseMetaTxArgs & {
+  functionName: string;
+  functionSignature: string;
+  domain: {
+    name: string;
+    version: string;
+  };
+};
+
+// Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
 export async function signNativeMetaTx(
-  args: BaseMetaTxArgs & {
-    functionName: string;
-    functionSignature: string;
-    domain: {
-      name: string;
-      version: string;
-    };
-  }
-): Promise<SignedMetaTx> {
+  args: NativeMetaTxArgs & { returnTypedDataToSign: true }
+): Promise<UnsignedMetaTx>;
+// Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
+export async function signNativeMetaTx(
+  args: NativeMetaTxArgs & { returnTypedDataToSign?: false | undefined }
+): Promise<SignedMetaTx>;
+// Implementation
+export async function signNativeMetaTx(
+  args: NativeMetaTxArgs & { returnTypedDataToSign?: boolean }
+): Promise<SignedMetaTx | UnsignedMetaTx> {
   const metaTransactionType = [
     { name: "nonce", type: "uint256" },
     { name: "from", type: "address" },
@@ -75,18 +90,34 @@ export async function signNativeMetaTx(
   const signerAddress = await args.web3Lib.getSignerAddress();
 
   const message = {
-    nonce: args.nonce,
+    nonce: args.nonce.toString(),
     from: signerAddress,
     functionSignature: args.functionSignature
   };
 
-  const signature = await prepareDataSignatureParameters({
+  const baseParams = {
     ...args,
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     customDomainData: args.domain,
     primaryType: "MetaTransaction",
-    message,
+    message
+  };
+
+  if (args.returnTypedDataToSign) {
+    const structuredData = await prepareDataSignatureParameters({
+      ...baseParams,
+      returnTypedDataToSign: true
+    });
+    return {
+      ...structuredData,
+      functionName: args.functionName,
+      functionSignature: args.functionSignature
+    };
+  }
+
+  const signature = await prepareDataSignatureParameters({
+    ...baseParams,
     returnTypedDataToSign: false
   });
 
@@ -97,14 +128,29 @@ export async function signNativeMetaTx(
   };
 }
 
-export async function signNativeMetaTxApproveExchangeToken(args: {
+type ApproveExchangeTokenBaseArgs = {
   web3Lib: Web3LibAdapter;
   chainId: number;
   user: string;
   exchangeToken: string;
   spender: string;
   value: BigNumberish;
-}) {
+};
+
+// Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
+export async function signNativeMetaTxApproveExchangeToken(
+  args: ApproveExchangeTokenBaseArgs & { returnTypedDataToSign: true }
+): Promise<UnsignedMetaTx>;
+// Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
+export async function signNativeMetaTxApproveExchangeToken(
+  args: ApproveExchangeTokenBaseArgs & {
+    returnTypedDataToSign?: false | undefined;
+  }
+): Promise<SignedMetaTx>;
+// Implementation
+export async function signNativeMetaTxApproveExchangeToken(
+  args: ApproveExchangeTokenBaseArgs & { returnTypedDataToSign?: boolean }
+): Promise<SignedMetaTx | UnsignedMetaTx> {
   const domain = {
     name: await getERC20Name({
       contractAddress: args.exchangeToken,
@@ -124,15 +170,19 @@ export async function signNativeMetaTxApproveExchangeToken(args: {
     args.spender,
     args.value
   ]);
-  return signNativeMetaTx({
+  const baseArgs = {
     web3Lib: args.web3Lib,
     metaTxHandlerAddress: args.exchangeToken,
     chainId: args.chainId,
-    nonce: nonce,
+    nonce,
     functionName,
     functionSignature,
     domain
-  });
+  };
+  if (args.returnTypedDataToSign) {
+    return signNativeMetaTx({ ...baseArgs, returnTypedDataToSign: true });
+  }
+  return signNativeMetaTx({ ...baseArgs, returnTypedDataToSign: false });
 }
 
 export async function relayNativeMetaTransaction(args: {

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

@@ -6,6 +6,7 @@ import {
 import { BigNumberish } from "@ethersproject/bignumber";
 import { BytesLike } from "@ethersproject/bytes";
 import { handler } from ".";
+import { SignedMetaTx, UnsignedMetaTx } from "../meta-tx/handler";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 
 export class NativeMetaTxMixin<
@@ -15,24 +16,49 @@ export class NativeMetaTxMixin<
    * Encodes and signs a native "token.approve()" meta transaction that can be relayed.
    * @param exchangeToken - The address of the token contract.
    * @param value - The value to be approved.
-   * @param overrides - Optionally specify a spender address (default is the protocol contract address).
-   * @returns Signature.
+   * @param overrides - Optionally specify a spender address (default is the protocol contract address)
+   *                    and/or set returnTypedDataToSign to control the return type.
+   * @returns Signature or structured typed data.
    */
+  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
+  public async signNativeMetaTxApproveExchangeToken(
+    exchangeToken: string,
+    value: BigNumberish,
+    overrides: Partial<{ spender: string }> & { returnTypedDataToSign: true }
+  ): Promise<UnsignedMetaTx>;
+  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
+  public async signNativeMetaTxApproveExchangeToken(
+    exchangeToken: string,
+    value: BigNumberish,
+    overrides?: Partial<{ spender: string; returnTypedDataToSign?: false }>
+  ): Promise<SignedMetaTx>;
+  // Implementation
   public async signNativeMetaTxApproveExchangeToken(
     exchangeToken: string,
     value: BigNumberish,
     overrides: Partial<{
       spender: string;
+      returnTypedDataToSign: boolean;
     }> = {}
-  ) {
+  ): Promise<SignedMetaTx | UnsignedMetaTx> {
     const user = await this._web3Lib.getSignerAddress();
-    return handler.signNativeMetaTxApproveExchangeToken({
+    const baseArgs = {
       web3Lib: this._web3Lib,
       chainId: this._chainId,
       user,
       exchangeToken,
       spender: overrides.spender || this._protocolDiamond,
       value
+    };
+    if (overrides.returnTypedDataToSign) {
+      return handler.signNativeMetaTxApproveExchangeToken({
+        ...baseArgs,
+        returnTypedDataToSign: true
+      });
+    }
+    return handler.signNativeMetaTxApproveExchangeToken({
+      ...baseArgs,
+      returnTypedDataToSign: false
     });
   }