@bosonprotocol/core-sdk 1.48.0-alpha.2 → 1.48.0-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bosonprotocol/core-sdk",
-  "version": "1.48.0-alpha.2",
+  "version": "1.48.0-alpha.3",
   "description": "Facilitates interaction with the contracts and subgraphs of the Boson Protocol",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -35,7 +35,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@bosonprotocol/common": "^1.33.0-alpha.3",
+    "@bosonprotocol/common": "^1.33.0-alpha.4",
     "@ethersproject/abi": "^5.5.0",
     "@ethersproject/address": "^5.5.0",
     "@ethersproject/bignumber": "^5.5.0",
@@ -62,5 +62,5 @@
   "overrides": {
     "typescript": "^5.1.6"
   },
-  "gitHead": "9158c653f5c58a7f2a41a6348cafb598d7c2a160"
+  "gitHead": "d707d8613eebf1f21243c2b405ab60f94ebd5103"
 }

package/src/meta-tx/handler.ts

@@ -3,6 +3,7 @@ import {
   CreateSellerArgs,
   MetaTxConfig,
   Web3LibAdapter,
+  TransactionRequest,
   TransactionResponse,
   utils,
   MetadataStorage,
@@ -17,7 +18,7 @@ import {
 } from "@bosonprotocol/common";
 import { storeMetadataOnTheGraph } from "../offers/storage";
 import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
-import { BytesLike } from "@ethersproject/bytes";
+import { BytesLike, hexlify } from "@ethersproject/bytes";
 
 import {
   encodeCreateSeller,
@@ -46,6 +47,7 @@ import {
   ForwarderDomainData,
   GetRetriedHashesData
 } from "./biconomy";
+import { metaTransactionsHandlerIface } from "./interface";
 import { isAddress } from "@ethersproject/address";
 import { AddressZero } from "@ethersproject/constants";
 import { encodeDepositFunds, encodeWithdrawFunds } from "../funds/interface";
@@ -2213,6 +2215,83 @@ export async function relayMetaTransaction(args: {
   };
 }
 
+export type ExecuteMetaTxBaseArgs = {
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  userAddress: string;
+  functionName: string;
+  functionSignature: BytesLike;
+  nonce: BigNumberish;
+  sigR: BytesLike;
+  sigS: BytesLike;
+  sigV: BigNumberish;
+};
+
+// Overload: returnTxInfo is true -> returns TransactionRequest
+export async function executeMetaTransaction(
+  args: ExecuteMetaTxBaseArgs & { returnTxInfo: true }
+): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined -> returns TransactionResponse
+export async function executeMetaTransaction(
+  args: ExecuteMetaTxBaseArgs & { returnTxInfo?: false | undefined }
+): Promise<TransactionResponse>;
+// Implementation
+export async function executeMetaTransaction(
+  args: ExecuteMetaTxBaseArgs & { returnTxInfo?: boolean }
+): Promise<TransactionRequest | TransactionResponse> {
+  const data = metaTransactionsHandlerIface.encodeFunctionData(
+    "executeMetaTransaction",
+    [
+      args.userAddress,
+      args.functionName,
+      args.functionSignature,
+      args.nonce,
+      rebuildSignature({
+        r: hexlify(args.sigR),
+        s: hexlify(args.sigS),
+        v: Number(args.sigV)
+      })
+    ]
+  );
+  const tx: TransactionRequest = { to: args.contractAddress, data };
+  return args.returnTxInfo ? tx : args.web3Lib.sendTransaction(tx);
+}
+
+export type ExecuteMetaTxWithAuthArgs = ExecuteMetaTxBaseArgs & {
+  transferAuthorizations: TransferAuthorization[];
+};
+
+// Overload: returnTxInfo is true -> returns TransactionRequest
+export async function executeMetaTransactionWithTokenTransferAuthorization(
+  args: ExecuteMetaTxWithAuthArgs & { returnTxInfo: true }
+): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined -> returns TransactionResponse
+export async function executeMetaTransactionWithTokenTransferAuthorization(
+  args: ExecuteMetaTxWithAuthArgs & { returnTxInfo?: false | undefined }
+): Promise<TransactionResponse>;
+// Implementation
+export async function executeMetaTransactionWithTokenTransferAuthorization(
+  args: ExecuteMetaTxWithAuthArgs & { returnTxInfo?: boolean }
+): Promise<TransactionRequest | TransactionResponse> {
+  const data = metaTransactionsHandlerIface.encodeFunctionData(
+    "executeMetaTransactionWithTokenTransferAuthorization",
+    [
+      args.userAddress,
+      args.functionName,
+      args.functionSignature,
+      args.nonce,
+      rebuildSignature({
+        r: hexlify(args.sigR),
+        s: hexlify(args.sigS),
+        v: Number(args.sigV)
+      }),
+      encodeTransferAuthorizationQueue(args.transferAuthorizations)
+    ]
+  );
+  const tx: TransactionRequest = { to: args.contractAddress, data };
+  return args.returnTxInfo ? tx : args.web3Lib.sendTransaction(tx);
+}
+
 export async function getResubmitted(args: {
   chainId: number;
   metaTx: {

package/src/meta-tx/mixin.ts

@@ -1855,6 +1855,63 @@ export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
     });
   }
 
+  /**
+   * Execute a signed meta transaction directly on-chain (no Biconomy relayer).
+   * Routes to `executeMetaTransaction` or `executeMetaTransactionWithTokenTransferAuthorization`
+   * depending on whether `transferAuthorizations` is provided and non-empty.
+   * The wallet backing the SDK pays the gas; pass `overrides.userAddress` when
+   * the meta-tx signer differs from that wallet.
+   * @param metaTxParams - Required params for meta transaction.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async executeMetaTransaction(
+    metaTxParams: {
+      functionName: string;
+      functionSignature: BytesLike;
+      nonce: BigNumberish;
+      sigR: BytesLike;
+      sigS: BytesLike;
+      sigV: BigNumberish;
+      transferAuthorizations?: TransferAuthorization[];
+    },
+    overrides: Partial<{
+      userAddress: string;
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    const userAddress =
+      overrides.userAddress || (await this._web3Lib.getSignerAddress());
+    const contractAddress = overrides.contractAddress || this._protocolDiamond;
+
+    if (metaTxParams.transferAuthorizations?.length) {
+      return handler.executeMetaTransactionWithTokenTransferAuthorization({
+        web3Lib: this._web3Lib,
+        contractAddress,
+        userAddress,
+        functionName: metaTxParams.functionName,
+        functionSignature: metaTxParams.functionSignature,
+        nonce: metaTxParams.nonce,
+        sigR: metaTxParams.sigR,
+        sigS: metaTxParams.sigS,
+        sigV: metaTxParams.sigV,
+        transferAuthorizations: metaTxParams.transferAuthorizations
+      });
+    }
+
+    return handler.executeMetaTransaction({
+      web3Lib: this._web3Lib,
+      contractAddress,
+      userAddress,
+      functionName: metaTxParams.functionName,
+      functionSignature: metaTxParams.functionSignature,
+      nonce: metaTxParams.nonce,
+      sigR: metaTxParams.sigR,
+      sigS: metaTxParams.sigS,
+      sigV: metaTxParams.sigV
+    });
+  }
+
   /**
    * Returns information of submitted meta transaction.
    * See https://docs.biconomy.io/api/native-meta-tx/get-retried-hashes.

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

@@ -2,6 +2,7 @@ import { tokenSpecifics } from "./tokenSpecifics";
 import {
   MetaTxConfig,
   Web3LibAdapter,
+  TransactionRequest,
   TransactionResponse
 } from "@bosonprotocol/common";
 import { BigNumberish, BigNumber } from "@ethersproject/bignumber";
@@ -242,3 +243,33 @@ export async function relayNativeMetaTransaction(args: {
     hash: relayTxResponse.txHash
   };
 }
+
+export type ExecuteNativeMetaTxBaseArgs = {
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  userAddress: string;
+  functionSignature: BytesLike;
+  sigR: BytesLike;
+  sigS: BytesLike;
+  sigV: BigNumberish;
+};
+
+// Overload: returnTxInfo is true -> returns TransactionRequest
+export async function executeNativeMetaTransaction(
+  args: ExecuteNativeMetaTxBaseArgs & { returnTxInfo: true }
+): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined -> returns TransactionResponse
+export async function executeNativeMetaTransaction(
+  args: ExecuteNativeMetaTxBaseArgs & { returnTxInfo?: false | undefined }
+): Promise<TransactionResponse>;
+// Implementation
+export async function executeNativeMetaTransaction(
+  args: ExecuteNativeMetaTxBaseArgs & { returnTxInfo?: boolean }
+): Promise<TransactionRequest | TransactionResponse> {
+  const data = nativeMetaTransactionsIface.encodeFunctionData(
+    "executeMetaTransaction",
+    [args.userAddress, args.functionSignature, args.sigR, args.sigS, args.sigV]
+  );
+  const tx: TransactionRequest = { to: args.contractAddress, data };
+  return args.returnTxInfo ? tx : args.web3Lib.sendTransaction(tx);
+}

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

@@ -108,4 +108,39 @@ export class NativeMetaTxMixin<
       }
     });
   }
+
+  /**
+   * Execute a signed native meta transaction directly on-chain (no Biconomy relayer).
+   * The wallet backing the SDK pays the gas; pass `overrides.userAddress` when the
+   * meta-tx signer differs from that wallet.
+   * @param contractAddress - The token contract address.
+   * @param metaTxParams - Required params for the native meta transaction.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async executeNativeMetaTransaction(
+    contractAddress: string,
+    metaTxParams: {
+      functionSignature: BytesLike;
+      sigR: BytesLike;
+      sigS: BytesLike;
+      sigV: BigNumberish;
+    },
+    overrides: Partial<{
+      userAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    const userAddress =
+      overrides.userAddress || (await this._web3Lib.getSignerAddress());
+
+    return handler.executeNativeMetaTransaction({
+      web3Lib: this._web3Lib,
+      contractAddress,
+      userAddress,
+      functionSignature: metaTxParams.functionSignature,
+      sigR: metaTxParams.sigR,
+      sigS: metaTxParams.sigS,
+      sigV: metaTxParams.sigV
+    });
+  }
 }