@bosonprotocol/core-sdk 1.48.0-alpha.4 → 1.48.0-alpha.5

package/src/erc20/handler.ts

@@ -31,6 +31,10 @@ export type UnsignedTransferAuthorization =
   | {
       strategy: "Permit2";
       data: { nonce: BigNumberish; deadline: BigNumberish };
+    }
+  | {
+      strategy: "DAIPermit";
+      data: { nonce: BigNumberish; expiry: BigNumberish };
     };
 
 export type TransferAuthorization = UnsignedTransferAuthorization & {
@@ -43,10 +47,13 @@ export type TransferAuthorization = UnsignedTransferAuthorization & {
 const TRANSFER_STRATEGY_ID = {
   ERC3009: 1,
   EIP2612: 2,
-  Permit2: 3
+  Permit2: 3,
+  DAIPermit: 4
 } as const;
 
-function encodeTransferAuthorizationEntry(auth: TransferAuthorization): string {
+export function encodeTransferAuthorizationEntry(
+  auth: TransferAuthorization
+): string {
   let innerData: string;
   switch (auth.strategy) {
     case "ERC3009":
@@ -74,6 +81,12 @@ function encodeTransferAuthorizationEntry(auth: TransferAuthorization): string {
         [auth.data.nonce, auth.data.deadline, auth.signature]
       );
       break;
+    case "DAIPermit":
+      innerData = defaultAbiCoder.encode(
+        ["uint256", "uint256", "uint8", "bytes32", "bytes32"],
+        [auth.data.nonce, auth.data.expiry, auth.v, auth.r, auth.s]
+      );
+      break;
   }
   return defaultAbiCoder.encode(
     ["uint8", "bytes"],
@@ -81,15 +94,6 @@ function encodeTransferAuthorizationEntry(auth: TransferAuthorization): string {
   );
 }
 
-export function encodeTransferAuthorizationQueue(
-  auths: TransferAuthorization[]
-): string {
-  return defaultAbiCoder.encode(
-    ["bytes[]"],
-    [auths.map(encodeTransferAuthorizationEntry)]
-  );
-}
-
 // Overload: returnTxInfo is true -> returns TransactionRequest
 export async function approve(args: {
   contractAddress: string;
@@ -484,3 +488,93 @@ export async function signReceiveWithPermit2(
     data: { nonce: permit2Nonce, deadline: args.deadline }
   };
 }
+
+type SignReceiveWithDaiPermitArgs = ApproveExchangeTokenBaseArgs & {
+  tokenDomain: { name: string };
+  expiry: BigNumberish;
+};
+
+// Overload: returnTypedDataToSign is true → returns StructuredData
+export async function signReceiveWithDaiPermit(
+  args: SignReceiveWithDaiPermitArgs & { returnTypedDataToSign: true }
+): Promise<StructuredData>;
+// Overload: returnTypedDataToSign is false or undefined → returns TransferAuthorization (DAIPermit)
+export async function signReceiveWithDaiPermit(
+  args: SignReceiveWithDaiPermitArgs & {
+    returnTypedDataToSign?: false | undefined;
+  }
+): Promise<TransferAuthorization & { strategy: "DAIPermit" }>;
+// Implementation
+export async function signReceiveWithDaiPermit(
+  args: SignReceiveWithDaiPermitArgs & { returnTypedDataToSign?: boolean }
+): Promise<
+  (TransferAuthorization & { strategy: "DAIPermit" }) | 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: "holder", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "nonce", type: "uint256" },
+      { name: "expiry", type: "uint256" },
+      { name: "allowed", type: "bool" }
+    ]
+  };
+
+  const customDomainData = {
+    name: args.tokenDomain.name,
+    version: "1",
+    chainId: args.chainId,
+    salt: undefined
+  };
+
+  const message = {
+    holder: args.user,
+    spender: args.spender,
+    nonce: nonce.toString(),
+    expiry: args.expiry.toString(),
+    allowed: true
+  };
+
+  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: "DAIPermit",
+    data: { nonce: nonce.toString(), expiry: args.expiry }
+  };
+}

package/src/erc20/mixin.ts

@@ -16,6 +16,7 @@ import {
   signReceiveWithErc3009Authorization,
   signReceiveWithErc2612Permit,
   signReceiveWithPermit2,
+  signReceiveWithDaiPermit,
   TransferAuthorization
 } from "./handler";
 import { StructuredData } from "../utils/signature";
@@ -326,4 +327,62 @@ export class ERC20Mixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
       returnTypedDataToSign: false
     });
   }
+
+  /**
+   * Signs a DAI-style `Permit` payload authorizing the spender (default:
+   * protocol diamond) to pull `exchangeToken` from the signer up to `expiry`.
+   * Returns a `TransferAuthorization` tagged with strategy `"DAIPermit"`,
+   * ready to feed into `relayMetaTransaction` via `transferAuthorizations`.
+   */
+  // Overload: returnTypedDataToSign is true → returns StructuredData
+  public async signReceiveWithDaiPermit(
+    exchangeToken: string,
+    tokenDomain: { name: string },
+    value: BigNumberish,
+    expiry: BigNumberish,
+    overrides: Partial<{ spender: string }> & { returnTypedDataToSign: true }
+  ): Promise<StructuredData>;
+  // Overload: returnTypedDataToSign is false or undefined → returns TransferAuthorization (DAIPermit)
+  public async signReceiveWithDaiPermit(
+    exchangeToken: string,
+    tokenDomain: { name: string },
+    value: BigNumberish,
+    expiry: BigNumberish,
+    overrides?: Partial<{ spender: string; returnTypedDataToSign?: false }>
+  ): Promise<TransferAuthorization & { strategy: "DAIPermit" }>;
+  // Implementation
+  public async signReceiveWithDaiPermit(
+    exchangeToken: string,
+    tokenDomain: { name: string },
+    value: BigNumberish,
+    expiry: BigNumberish,
+    overrides: Partial<{
+      spender: string;
+      returnTypedDataToSign: boolean;
+    }> = {}
+  ): Promise<
+    (TransferAuthorization & { strategy: "DAIPermit" }) | StructuredData
+  > {
+    const user = await this._web3Lib.getSignerAddress();
+    const baseArgs = {
+      web3Lib: this._web3Lib,
+      chainId: this._chainId,
+      user,
+      exchangeToken,
+      spender: overrides.spender || this._protocolDiamond,
+      value,
+      tokenDomain,
+      expiry
+    };
+    if (overrides.returnTypedDataToSign) {
+      return signReceiveWithDaiPermit({
+        ...baseArgs,
+        returnTypedDataToSign: true
+      });
+    }
+    return signReceiveWithDaiPermit({
+      ...baseArgs,
+      returnTypedDataToSign: false
+    });
+  }
 }

package/src/meta-tx/handler.ts

@@ -70,7 +70,7 @@ import { id } from "@ethersproject/hash";
 import { defaultAbiCoder } from "@ethersproject/abi";
 import {
   TransferAuthorization,
-  encodeTransferAuthorizationQueue
+  encodeTransferAuthorizationEntry
 } from "../erc20/handler";
 import { ERC20ForwardRequest } from "../forwarder/biconomy-interface";
 import { getNonce, verifyEIP712 } from "../forwarder/handler";
@@ -2182,7 +2182,9 @@ export async function relayMetaTransaction(args: {
   const params = metaTx.params.transferAuthorizations?.length
     ? [
         ...baseParams,
-        encodeTransferAuthorizationQueue(metaTx.params.transferAuthorizations)
+        metaTx.params.transferAuthorizations.map(
+          encodeTransferAuthorizationEntry
+        )
       ]
     : baseParams;
 
@@ -2285,7 +2287,7 @@ export async function executeMetaTransactionWithTokenTransferAuthorization(
         s: hexlify(args.sigS),
         v: Number(args.sigV)
       }),
-      encodeTransferAuthorizationQueue(args.transferAuthorizations)
+      args.transferAuthorizations.map(encodeTransferAuthorizationEntry)
     ]
   );
   const tx: TransactionRequest = { to: args.contractAddress, data };