@bosonprotocol/core-sdk 1.16.0-alpha.8 → 1.16.0

package/src/exchanges/queries.graphql

@@ -24,18 +24,9 @@ query getExchangesQuery(
 
 fragment ExchangeFields on Exchange {
   ...BaseExchangeFields
-  buyer {
-    ...BaseBuyerFields
-  }
-  seller {
-    ...BaseSellerFields
-  }
   offer {
     ...BaseOfferFields
   }
-  dispute {
-    ...BaseDisputeFields
-  }
 }
 
 fragment BaseExchangeFields on Exchange {
@@ -51,4 +42,13 @@ fragment BaseExchangeFields on Exchange {
   completedDate
   disputedDate
   expired
+  dispute {
+    ...BaseDisputeFields
+  }
+  buyer {
+    ...BaseBuyerFields
+  }
+  seller {
+    ...BaseSellerFields
+  }
 }

package/src/index.ts

@@ -12,7 +12,8 @@ export * as subgraph from "./subgraph";
 export {
   defaultConfigs,
   getDefaultConfig,
-  EnvironmentType
+  EnvironmentType,
+  MetaTxConfig
 } from "@bosonprotocol/common";
 
 export { MetadataType, AnyMetadata } from "@bosonprotocol/metadata";

package/src/meta-tx/biconomy.ts

@@ -0,0 +1,129 @@
+import fetch from "cross-fetch";
+
+import { ApiError } from "../utils/errors";
+
+export type RelayTransactionResponse = {
+  txHash: string;
+  log: string;
+  retryDuration: number;
+  flag: number;
+};
+
+export type RelayTransactionArgs = {
+  to: string;
+  params: unknown[];
+  from: string;
+};
+
+export type RelayOverrides = {
+  relayerUrl: string;
+  apiKey: string;
+  apiId: string;
+};
+
+export type GetRetriedHashesResponse = {
+  code: number;
+  message: string;
+  data: {
+    oldHash: string;
+    newHash: string;
+    oldGasPrice: string;
+    newGasPrice: string;
+    timestamp: number;
+    retryCount: number;
+    relayerAddress: string;
+    newStatus: string;
+  };
+  events?: unknown[];
+};
+
+export type GetRetriedHashesArgs = {
+  networkId: number;
+  transactionHash: string;
+};
+
+export class Biconomy {
+  public constructor(
+    private _relayerUrl: string,
+    private _apiKey: string,
+    private _apiId: string
+  ) {}
+
+  public async relayTransaction(
+    args: RelayTransactionArgs,
+    overrides: Partial<RelayOverrides> = {}
+  ): Promise<RelayTransactionResponse> {
+    const url = `${
+      overrides.relayerUrl || this._relayerUrl
+    }/api/v2/meta-tx/native`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "x-api-key": overrides.apiKey || this._apiKey,
+        "content-type": "application/json;charset=UTF-8",
+        "Access-Control-Allow-Origin": "*"
+      },
+      body: JSON.stringify({
+        ...args,
+        apiId: overrides.apiId || this._apiId
+      })
+    });
+
+    if (!response.ok) {
+      throw new ApiError(
+        response.status,
+        `Failed to relay tx: ${response.statusText}`
+      );
+    }
+
+    return response.json() as Promise<RelayTransactionResponse>;
+  }
+
+  public async getResubmitted(
+    args: GetRetriedHashesArgs,
+    overrides: Partial<RelayOverrides> = {}
+  ): Promise<GetRetriedHashesResponse> {
+    const url = `${
+      overrides.relayerUrl || this._relayerUrl
+    }/api/v1/meta-tx/resubmitted?networkId=${args.networkId}&transactionHash=${
+      args.transactionHash
+    }`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "content-type": "application/json;charset=UTF-8",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+
+    if (!response.ok) {
+      throw new ApiError(
+        response.status,
+        `Failed to get resubmitted tx: ${response.statusText}`
+      );
+    }
+
+    return response.json() as Promise<GetRetriedHashesResponse>;
+  }
+
+  public async wait(
+    args: GetRetriedHashesArgs,
+    overrides: Partial<RelayOverrides> = {}
+  ): Promise<GetRetriedHashesResponse> {
+    let pending = true;
+    let resubmittedResponse: GetRetriedHashesResponse;
+
+    while (pending) {
+      resubmittedResponse = await this.getResubmitted(args, overrides);
+
+      pending = resubmittedResponse.data.newStatus === "PENDING";
+      if (pending) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, 1000);
+        });
+      }
+    }
+
+    return resubmittedResponse;
+  }
+}

package/src/meta-tx/handler.ts

@@ -1,8 +1,11 @@
-import { Web3LibAdapter } from "@bosonprotocol/common";
-import { BigNumberish } from "@ethersproject/bignumber";
+import { MetaTxConfig, Web3LibAdapter } from "@bosonprotocol/common";
+import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
+import { BytesLike } from "@ethersproject/bytes";
+import { ContractTransaction } from "@ethersproject/contracts";
 
 import { bosonExchangeHandlerIface } from "../exchanges/interface";
 import { prepareDataSignatureParameters } from "../utils/signature";
+import { Biconomy } from "./biconomy";
 
 type BaseMetaTxArgs = {
   web3Lib: Web3LibAdapter;
@@ -357,3 +360,82 @@ function makeExchangeMetaTxSigner(
     };
   };
 }
+
+export async function relayMetaTransaction(args: {
+  web3LibAdapter: Web3LibAdapter;
+  chainId: number;
+  contractAddress: string;
+  metaTx: {
+    config: MetaTxConfig;
+    params: {
+      userAddress: string;
+      functionName: string;
+      functionSignature: BytesLike;
+      nonce: BigNumberish;
+      sigR: BytesLike;
+      sigS: BytesLike;
+      sigV: BigNumberish;
+    };
+  };
+}): Promise<ContractTransaction> {
+  const { chainId, contractAddress, metaTx } = args;
+
+  const biconomy = new Biconomy(
+    metaTx.config.relayerUrl,
+    metaTx.config.apiKey,
+    metaTx.config.apiId
+  );
+
+  const relayTxResponse = await biconomy.relayTransaction({
+    to: contractAddress,
+    params: [
+      metaTx.params.userAddress,
+      metaTx.params.functionName,
+      metaTx.params.functionSignature,
+      metaTx.params.nonce,
+      metaTx.params.sigR,
+      metaTx.params.sigS,
+      metaTx.params.sigV
+    ],
+    from: metaTx.params.userAddress
+  });
+
+  return {
+    wait: async () => {
+      const waitResponse = await biconomy.wait({
+        networkId: chainId,
+        transactionHash: relayTxResponse.txHash
+      });
+
+      // TODO: add `getTransaction(hash)` to `Web3LibAdapter` and respective implementations
+      // in ethers and eth-connect flavors. This way we can populate the correct transaction
+      // data below.
+      return {
+        to: contractAddress,
+        from: metaTx.params.userAddress,
+        contractAddress: contractAddress,
+        transactionIndex: 0,
+        gasUsed: BigNumber.from(0),
+        logsBloom: "",
+        blockHash: "string",
+        transactionHash: waitResponse.data.newHash,
+        logs: [],
+        blockNumber: 0,
+        confirmations: 0,
+        cumulativeGasUsed: BigNumber.from(0),
+        effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice),
+        byzantium: true,
+        type: 0,
+        events: waitResponse.events?.map((event) => JSON.parse(event as string))
+      };
+    },
+    hash: relayTxResponse.txHash,
+    confirmations: 0,
+    from: metaTx.params.userAddress,
+    nonce: 0,
+    gasLimit: BigNumber.from(0),
+    data: "",
+    value: BigNumber.from(0),
+    chainId: chainId
+  };
+}

package/src/metadata/base.graphql

@@ -60,4 +60,6 @@ fragment BaseBaseMetadataEntityFields on BaseMetadataEntity {
   validFromDate
   validUntilDate
   quantityAvailable
+  numberOfCommits
+  numberOfRedemptions
 }

package/src/metadata/product-v1.graphql

@@ -96,7 +96,8 @@ fragment BaseProductV1MetadataEntityFields on ProductV1MetadataEntity {
   validFromDate
   validUntilDate
   quantityAvailable
-
+  numberOfCommits
+  numberOfRedemptions
   uuid
   product {
     ...BaseProductV1ProductFields

package/src/offers/queries.graphql

@@ -69,8 +69,11 @@ fragment BaseOfferFields on Offer {
   resolutionPeriodDuration
   metadataUri
   metadataHash
+  voided
   voidedAt
   disputeResolverId
+  numberOfCommits
+  numberOfRedemptions
   seller {
     ...BaseSellerFields
   }