@bosonprotocol/core-sdk 1.47.1-alpha.0 → 1.48.0-alpha.0

package/src/erc20/handler.ts

@@ -3,8 +3,92 @@ import {
   TransactionRequest,
   TransactionResponse
 } from "@bosonprotocol/common";
+import { defaultAbiCoder } from "@ethersproject/abi";
 import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
+import { hexlify } from "@ethersproject/bytes";
+import { randomBytes } from "@ethersproject/random";
 import { erc20Iface } from "./interface";
+import type { ApproveExchangeTokenBaseArgs } from "../native-meta-tx/handler";
+import { alternativeNonceIface } from "../native-meta-tx/interface";
+import {
+  prepareDataSignatureParameters,
+  StructuredData
+} from "../utils/signature";
+
+export type UnsignedTransferAuthorization =
+  | {
+      strategy: "ERC3009";
+      data: {
+        validAfter: BigNumberish;
+        validBefore: BigNumberish;
+        nonce: string;
+      };
+    }
+  | {
+      strategy: "EIP2612";
+      data: { deadline: BigNumberish };
+    }
+  | {
+      strategy: "Permit2";
+      data: { nonce: BigNumberish; deadline: BigNumberish };
+    };
+
+export type TransferAuthorization = UnsignedTransferAuthorization & {
+  r: string;
+  s: string;
+  v: number;
+  signature: string;
+};
+
+const TRANSFER_STRATEGY_ID = {
+  ERC3009: 1,
+  EIP2612: 2,
+  Permit2: 3
+} as const;
+
+function encodeTransferAuthorizationEntry(auth: TransferAuthorization): string {
+  let innerData: string;
+  switch (auth.strategy) {
+    case "ERC3009":
+      innerData = defaultAbiCoder.encode(
+        ["uint256", "uint256", "bytes32", "uint8", "bytes32", "bytes32"],
+        [
+          auth.data.validAfter,
+          auth.data.validBefore,
+          auth.data.nonce,
+          auth.v,
+          auth.r,
+          auth.s
+        ]
+      );
+      break;
+    case "EIP2612":
+      innerData = defaultAbiCoder.encode(
+        ["uint256", "uint8", "bytes32", "bytes32"],
+        [auth.data.deadline, auth.v, auth.r, auth.s]
+      );
+      break;
+    case "Permit2":
+      innerData = defaultAbiCoder.encode(
+        ["uint256", "uint256", "bytes"],
+        [auth.data.nonce, auth.data.deadline, auth.signature]
+      );
+      break;
+  }
+  return defaultAbiCoder.encode(
+    ["uint8", "bytes"],
+    [TRANSFER_STRATEGY_ID[auth.strategy], innerData]
+  );
+}
+
+export function encodeTransferAuthorizationQueue(
+  auths: TransferAuthorization[]
+): string {
+  return defaultAbiCoder.encode(
+    ["bytes[]"],
+    [auths.map(encodeTransferAuthorizationEntry)]
+  );
+}
 
 // Overload: returnTxInfo is true -> returns TransactionRequest
 export async function approve(args: {
@@ -130,3 +214,273 @@ export async function balanceOf(args: {
   const [balance] = erc20Iface.decodeFunctionResult("balanceOf", result);
   return String(balance);
 }
+
+type SignReceiveWithErc3009AuthorizationArgs = ApproveExchangeTokenBaseArgs & {
+  tokenDomain: { name: string; version: string };
+  validAfter: BigNumberish;
+  validBefore: BigNumberish;
+};
+
+// Overload: returnTypedDataToSign is true → returns StructuredData
+export async function signReceiveWithErc3009Authorization(
+  args: SignReceiveWithErc3009AuthorizationArgs & {
+    returnTypedDataToSign: true;
+  }
+): Promise<StructuredData>;
+// Overload: returnTypedDataToSign is false or undefined → returns TransferAuthorization (ERC3009)
+export async function signReceiveWithErc3009Authorization(
+  args: SignReceiveWithErc3009AuthorizationArgs & {
+    returnTypedDataToSign?: false | undefined;
+  }
+): Promise<TransferAuthorization & { strategy: "ERC3009" }>;
+// Implementation
+export async function signReceiveWithErc3009Authorization(
+  args: SignReceiveWithErc3009AuthorizationArgs & {
+    returnTypedDataToSign?: boolean;
+  }
+): Promise<(TransferAuthorization & { strategy: "ERC3009" }) | StructuredData> {
+  const nonce = hexlify(randomBytes(32));
+
+  const customSignatureType = {
+    EIP712Domain: [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ],
+    ReceiveWithAuthorization: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" }
+    ]
+  };
+
+  const customDomainData = {
+    name: args.tokenDomain.name,
+    version: args.tokenDomain.version,
+    chainId: args.chainId,
+    salt: undefined
+  };
+
+  const message = {
+    from: args.user,
+    to: args.spender,
+    value: args.value.toString(),
+    validAfter: args.validAfter.toString(),
+    validBefore: args.validBefore.toString(),
+    nonce
+  };
+
+  const baseParams = {
+    web3Lib: args.web3Lib,
+    chainId: args.chainId,
+    verifyingContractAddress: args.exchangeToken,
+    customSignatureType,
+    customDomainData,
+    primaryType: "ReceiveWithAuthorization",
+    message
+  };
+
+  if (args.returnTypedDataToSign) {
+    return prepareDataSignatureParameters({
+      ...baseParams,
+      returnTypedDataToSign: true
+    });
+  }
+
+  const sig = await prepareDataSignatureParameters({
+    ...baseParams,
+    returnTypedDataToSign: false
+  });
+
+  return {
+    ...sig,
+    strategy: "ERC3009",
+    data: {
+      validAfter: args.validAfter,
+      validBefore: args.validBefore,
+      nonce
+    }
+  };
+}
+
+type SignReceiveWithErc2612PermitArgs = ApproveExchangeTokenBaseArgs & {
+  tokenDomain: { name: string; version: string };
+  deadline: BigNumberish;
+};
+
+// Overload: returnTypedDataToSign is true → returns StructuredData
+export async function signReceiveWithErc2612Permit(
+  args: SignReceiveWithErc2612PermitArgs & {
+    returnTypedDataToSign: true;
+  }
+): Promise<StructuredData>;
+// Overload: returnTypedDataToSign is false or undefined → returns TransferAuthorization (EIP2612)
+export async function signReceiveWithErc2612Permit(
+  args: SignReceiveWithErc2612PermitArgs & {
+    returnTypedDataToSign?: false | undefined;
+  }
+): Promise<TransferAuthorization & { strategy: "EIP2612" }>;
+// Implementation
+export async function signReceiveWithErc2612Permit(
+  args: SignReceiveWithErc2612PermitArgs & {
+    returnTypedDataToSign?: boolean;
+  }
+): Promise<(TransferAuthorization & { strategy: "EIP2612" }) | StructuredData> {
+  const nonceResult = await args.web3Lib.call({
+    to: args.exchangeToken,
+    data: alternativeNonceIface.encodeFunctionData("nonces", [args.user])
+  });
+  const [nonce] = alternativeNonceIface.decodeFunctionResult(
+    "nonces",
+    nonceResult
+  );
+
+  const customSignatureType = {
+    EIP712Domain: [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ],
+    Permit: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "nonce", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ]
+  };
+
+  const customDomainData = {
+    name: args.tokenDomain.name,
+    version: args.tokenDomain.version,
+    chainId: args.chainId,
+    salt: undefined
+  };
+
+  const message = {
+    owner: args.user,
+    spender: args.spender,
+    value: args.value.toString(),
+    nonce: nonce.toString(),
+    deadline: args.deadline.toString()
+  };
+
+  const baseParams = {
+    web3Lib: args.web3Lib,
+    chainId: args.chainId,
+    verifyingContractAddress: args.exchangeToken,
+    customSignatureType,
+    customDomainData,
+    primaryType: "Permit",
+    message
+  };
+
+  if (args.returnTypedDataToSign) {
+    return prepareDataSignatureParameters({
+      ...baseParams,
+      returnTypedDataToSign: true
+    });
+  }
+
+  const sig = await prepareDataSignatureParameters({
+    ...baseParams,
+    returnTypedDataToSign: false
+  });
+
+  return {
+    ...sig,
+    strategy: "EIP2612",
+    data: { deadline: args.deadline }
+  };
+}
+
+type SignReceiveWithPermit2Args = ApproveExchangeTokenBaseArgs & {
+  permit2Address: string;
+  deadline: BigNumberish;
+  permit2Nonce?: BigNumberish;
+};
+
+// Overload: returnTypedDataToSign is true → returns StructuredData
+export async function signReceiveWithPermit2(
+  args: SignReceiveWithPermit2Args & { returnTypedDataToSign: true }
+): Promise<StructuredData>;
+// Overload: returnTypedDataToSign is false or undefined → returns TransferAuthorization (Permit2)
+export async function signReceiveWithPermit2(
+  args: SignReceiveWithPermit2Args & {
+    returnTypedDataToSign?: false | undefined;
+  }
+): Promise<TransferAuthorization & { strategy: "Permit2" }>;
+// Implementation
+export async function signReceiveWithPermit2(
+  args: SignReceiveWithPermit2Args & { returnTypedDataToSign?: boolean }
+): Promise<(TransferAuthorization & { strategy: "Permit2" }) | StructuredData> {
+  const permit2Nonce = args.permit2Nonce ?? BigNumber.from(randomBytes(32));
+
+  const customSignatureType = {
+    EIP712Domain: [
+      { name: "name", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ],
+    PermitTransferFrom: [
+      { name: "permitted", type: "TokenPermissions" },
+      { name: "spender", type: "address" },
+      { name: "nonce", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ],
+    TokenPermissions: [
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" }
+    ]
+  };
+
+  const customDomainData = {
+    name: "Permit2",
+    chainId: args.chainId,
+    version: undefined,
+    salt: undefined
+  };
+
+  const message = {
+    permitted: {
+      token: args.exchangeToken,
+      amount: args.value.toString()
+    },
+    spender: args.spender,
+    nonce: permit2Nonce.toString(),
+    deadline: args.deadline.toString()
+  };
+
+  const baseParams = {
+    web3Lib: args.web3Lib,
+    chainId: args.chainId,
+    verifyingContractAddress: args.permit2Address,
+    customSignatureType,
+    customDomainData,
+    primaryType: "PermitTransferFrom",
+    message
+  };
+
+  if (args.returnTypedDataToSign) {
+    return prepareDataSignatureParameters({
+      ...baseParams,
+      returnTypedDataToSign: true
+    });
+  }
+
+  const sig = await prepareDataSignatureParameters({
+    ...baseParams,
+    returnTypedDataToSign: false
+  });
+
+  return {
+    ...sig,
+    strategy: "Permit2",
+    data: { nonce: permit2Nonce, deadline: args.deadline }
+  };
+}

package/src/erc20/mixin.ts

@@ -3,6 +3,7 @@ import {
   TransactionResponse,
   TransactionRequest
 } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import {
   approve,
@@ -11,8 +12,13 @@ import {
   getSymbol,
   getName,
   ensureAllowance,
-  balanceOf
+  balanceOf,
+  signReceiveWithErc3009Authorization,
+  signReceiveWithErc2612Permit,
+  signReceiveWithPermit2,
+  TransferAuthorization
 } from "./handler";
+import { StructuredData } from "../utils/signature";
 
 export class ERC20Mixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
@@ -121,4 +127,203 @@ export class ERC20Mixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   ): Promise<ReturnType<typeof balanceOf>> {
     return balanceOf({ web3Lib: this._web3Lib, ...args });
   }
+
+  /**
+   * Signs an ERC-3009 `ReceiveWithAuthorization` payload that authorizes the
+   * spender (default: protocol diamond) to pull `value` units of `exchangeToken`
+   * from the signer. Returns a `TransferAuthorization` tagged with strategy
+   * `"ERC3009"`, ready to feed into `relayMetaTransaction` via
+   * `transferAuthorizations`.
+   */
+  // Overload: returnTypedDataToSign is true → returns StructuredData
+  public async signReceiveWithErc3009Authorization(
+    exchangeToken: string,
+    tokenDomain: { name: string; version: string },
+    value: BigNumberish,
+    validAfter: BigNumberish,
+    validBefore: BigNumberish,
+    overrides: Partial<{ spender: string }> & { returnTypedDataToSign: true }
+  ): Promise<StructuredData>;
+  // Overload: returnTypedDataToSign is false or undefined → returns TransferAuthorization (ERC3009)
+  public async signReceiveWithErc3009Authorization(
+    exchangeToken: string,
+    tokenDomain: { name: string; version: string },
+    value: BigNumberish,
+    validAfter: BigNumberish,
+    validBefore: BigNumberish,
+    overrides?: Partial<{ spender: string; returnTypedDataToSign?: false }>
+  ): Promise<TransferAuthorization & { strategy: "ERC3009" }>;
+  // Implementation
+  public async signReceiveWithErc3009Authorization(
+    exchangeToken: string,
+    tokenDomain: { name: string; version: string },
+    value: BigNumberish,
+    validAfter: BigNumberish,
+    validBefore: BigNumberish,
+    overrides: Partial<{
+      spender: string;
+      returnTypedDataToSign: boolean;
+    }> = {}
+  ): Promise<
+    (TransferAuthorization & { strategy: "ERC3009" }) | StructuredData
+  > {
+    const user = await this._web3Lib.getSignerAddress();
+    const baseArgs = {
+      web3Lib: this._web3Lib,
+      chainId: this._chainId,
+      user,
+      exchangeToken,
+      spender: overrides.spender || this._protocolDiamond,
+      value,
+      tokenDomain,
+      validAfter,
+      validBefore
+    };
+    if (overrides.returnTypedDataToSign) {
+      return signReceiveWithErc3009Authorization({
+        ...baseArgs,
+        returnTypedDataToSign: true
+      });
+    }
+    return signReceiveWithErc3009Authorization({
+      ...baseArgs,
+      returnTypedDataToSign: false
+    });
+  }
+
+  /**
+   * Signs an EIP-2612 `Permit` payload that authorizes the spender (default:
+   * protocol diamond) to pull `value` units of `exchangeToken` from the signer
+   * up to `deadline`. Returns a `TransferAuthorization` tagged with strategy
+   * `"EIP2612"`, ready to feed into `relayMetaTransaction` via
+   * `transferAuthorizations`.
+   */
+  // Overload: returnTypedDataToSign is true → returns StructuredData
+  public async signReceiveWithErc2612Permit(
+    exchangeToken: string,
+    tokenDomain: { name: string; version: string },
+    value: BigNumberish,
+    deadline: BigNumberish,
+    overrides: Partial<{ spender: string }> & { returnTypedDataToSign: true }
+  ): Promise<StructuredData>;
+  // Overload: returnTypedDataToSign is false or undefined → returns TransferAuthorization (EIP2612)
+  public async signReceiveWithErc2612Permit(
+    exchangeToken: string,
+    tokenDomain: { name: string; version: string },
+    value: BigNumberish,
+    deadline: BigNumberish,
+    overrides?: Partial<{ spender: string; returnTypedDataToSign?: false }>
+  ): Promise<TransferAuthorization & { strategy: "EIP2612" }>;
+  // Implementation
+  public async signReceiveWithErc2612Permit(
+    exchangeToken: string,
+    tokenDomain: { name: string; version: string },
+    value: BigNumberish,
+    deadline: BigNumberish,
+    overrides: Partial<{
+      spender: string;
+      returnTypedDataToSign: boolean;
+    }> = {}
+  ): Promise<
+    (TransferAuthorization & { strategy: "EIP2612" }) | StructuredData
+  > {
+    const user = await this._web3Lib.getSignerAddress();
+    const baseArgs = {
+      web3Lib: this._web3Lib,
+      chainId: this._chainId,
+      user,
+      exchangeToken,
+      spender: overrides.spender || this._protocolDiamond,
+      value,
+      tokenDomain,
+      deadline
+    };
+    if (overrides.returnTypedDataToSign) {
+      return signReceiveWithErc2612Permit({
+        ...baseArgs,
+        returnTypedDataToSign: true
+      });
+    }
+    return signReceiveWithErc2612Permit({
+      ...baseArgs,
+      returnTypedDataToSign: false
+    });
+  }
+
+  /**
+   * Signs a Uniswap Permit2 `PermitTransferFrom` payload authorizing the
+   * spender (default: protocol diamond) to pull `value` units of
+   * `exchangeToken` from the signer up to `deadline`. The Permit2 contract
+   * address defaults to `contracts.permit2` from SDK config and can be
+   * overridden via `overrides.permit2Address`. If `overrides.permit2Nonce`
+   * is omitted, a random uint256 is generated. Returns a `TransferAuthorization`
+   * tagged with strategy `"Permit2"`, ready to feed into `relayMetaTransaction`
+   * via `transferAuthorizations`.
+   */
+  // Overload: returnTypedDataToSign is true → returns StructuredData
+  public async signReceiveWithPermit2(
+    exchangeToken: string,
+    value: BigNumberish,
+    deadline: BigNumberish,
+    overrides: Partial<{
+      spender: string;
+      permit2Address: string;
+      permit2Nonce: BigNumberish;
+    }> & { returnTypedDataToSign: true }
+  ): Promise<StructuredData>;
+  // Overload: returnTypedDataToSign is false or undefined → returns TransferAuthorization (Permit2)
+  public async signReceiveWithPermit2(
+    exchangeToken: string,
+    value: BigNumberish,
+    deadline: BigNumberish,
+    overrides?: Partial<{
+      spender: string;
+      permit2Address: string;
+      permit2Nonce: BigNumberish;
+      returnTypedDataToSign?: false;
+    }>
+  ): Promise<TransferAuthorization & { strategy: "Permit2" }>;
+  // Implementation
+  public async signReceiveWithPermit2(
+    exchangeToken: string,
+    value: BigNumberish,
+    deadline: BigNumberish,
+    overrides: Partial<{
+      spender: string;
+      permit2Address: string;
+      permit2Nonce: BigNumberish;
+      returnTypedDataToSign: boolean;
+    }> = {}
+  ): Promise<
+    (TransferAuthorization & { strategy: "Permit2" }) | StructuredData
+  > {
+    const user = await this._web3Lib.getSignerAddress();
+    const permit2Address = overrides.permit2Address || this._contracts?.permit2;
+    if (!permit2Address) {
+      throw new Error(
+        "Permit2 contract address not configured. Provide overrides.permit2Address or initialize CoreSDK with contracts.permit2."
+      );
+    }
+    const baseArgs = {
+      web3Lib: this._web3Lib,
+      chainId: this._chainId,
+      user,
+      exchangeToken,
+      spender: overrides.spender || this._protocolDiamond,
+      value,
+      permit2Address,
+      deadline,
+      permit2Nonce: overrides.permit2Nonce
+    };
+    if (overrides.returnTypedDataToSign) {
+      return signReceiveWithPermit2({
+        ...baseArgs,
+        returnTypedDataToSign: true
+      });
+    }
+    return signReceiveWithPermit2({
+      ...baseArgs,
+      returnTypedDataToSign: false
+    });
+  }
 }

package/src/meta-tx/handler.ts

@@ -61,6 +61,10 @@ import {
 import { keccak256 } from "@ethersproject/keccak256";
 import { id } from "@ethersproject/hash";
 import { defaultAbiCoder } from "@ethersproject/abi";
+import {
+  TransferAuthorization,
+  encodeTransferAuthorizationQueue
+} from "../erc20/handler";
 import { ERC20ForwardRequest } from "../forwarder/biconomy-interface";
 import { getNonce, verifyEIP712 } from "../forwarder/handler";
 import { MockForwardRequest } from "../forwarder/mock-interface";
@@ -2018,6 +2022,7 @@ export async function relayMetaTransaction(args: {
       sigR: BytesLike;
       sigS: BytesLike;
       sigV: BigNumberish;
+      transferAuthorizations?: TransferAuthorization[];
     };
   };
 }): Promise<TransactionResponse> {
@@ -2029,19 +2034,27 @@ export async function relayMetaTransaction(args: {
     metaTx.config.apiId
   );
 
+  const baseParams: unknown[] = [
+    metaTx.params.userAddress,
+    metaTx.params.functionName,
+    metaTx.params.functionSignature,
+    metaTx.params.nonce,
+    rebuildSignature({
+      r: metaTx.params.sigR.toString(),
+      s: metaTx.params.sigS.toString(),
+      v: Number(metaTx.params.sigV)
+    })
+  ];
+  const params = metaTx.params.transferAuthorizations?.length
+    ? [
+        ...baseParams,
+        encodeTransferAuthorizationQueue(metaTx.params.transferAuthorizations)
+      ]
+    : baseParams;
+
   const relayTxResponse = await biconomy.relayTransaction({
     to: contractAddress,
-    params: [
-      metaTx.params.userAddress,
-      metaTx.params.functionName,
-      metaTx.params.functionSignature,
-      metaTx.params.nonce,
-      rebuildSignature({
-        r: metaTx.params.sigR.toString(),
-        s: metaTx.params.sigS.toString(),
-        v: Number(metaTx.params.sigV)
-      })
-    ],
+    params,
     from: metaTx.params.userAddress
   });
 

package/src/meta-tx/mixin.ts

@@ -14,6 +14,7 @@ import { accounts } from "..";
 import { AccountsMixin } from "../accounts/mixin";
 import { SellerFieldsFragment } from "../subgraph";
 import { SignedMetaTx, UnsignedMetaTx } from "./handler";
+import { TransferAuthorization } from "../erc20/handler";
 export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                           Meta Tx related methods                          */
@@ -1672,6 +1673,7 @@ export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
       sigR: BytesLike;
       sigS: BytesLike;
       sigV: BigNumberish;
+      transferAuthorizations?: TransferAuthorization[];
     },
     overrides: Partial<{
       userAddress: string;
@@ -1701,7 +1703,8 @@ export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
           nonce: metaTxParams.nonce,
           sigR: metaTxParams.sigR,
           sigS: metaTxParams.sigS,
-          sigV: metaTxParams.sigV
+          sigV: metaTxParams.sigV,
+          transferAuthorizations: metaTxParams.transferAuthorizations
         }
       }
     });

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

@@ -128,7 +128,7 @@ export async function signNativeMetaTx(
   };
 }
 
-type ApproveExchangeTokenBaseArgs = {
+export type ApproveExchangeTokenBaseArgs = {
   web3Lib: Web3LibAdapter;
   chainId: number;
   user: string;