@bosonprotocol/core-sdk 1.40.0-alpha.2 → 1.40.0-alpha.21

package/src/errors/mixin.ts

@@ -0,0 +1,47 @@
+import { Interface } from "@ethersproject/abi";
+import { abis, ErrorFragment } from "@bosonprotocol/common";
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+
+export class ErrorMixin extends BaseCoreSDK {
+  public parseError(error: object): object {
+    return { ...error, decoded: this.recurseParseError(error) };
+  }
+
+  private recurseParseError(error: object): string | undefined {
+    if (this.isValidError(error)) {
+      return this.decodeError(error["data"]);
+    }
+    if (error["data"] && error["data"]["originalError"]) {
+      return this.recurseParseError(error["data"]["originalError"]);
+    }
+    if (error["error"]) {
+      return this.recurseParseError(error["error"]);
+    }
+    return undefined;
+  }
+
+  private isValidError(error: object): boolean {
+    return error["data"] && /^0x[0-9a-fA-F]{8}$/.test(error["data"]);
+  }
+
+  private decodeError(data: string): string | undefined {
+    this.parseAbis();
+    const error = this._errorsMap.get(data.toLowerCase());
+    return error?.name;
+  }
+
+  private parseAbis() {
+    if (this._errorsMap.size === 0) {
+      Object.keys(abis).forEach((abi) => {
+        const iface = new Interface(abis[abi]);
+        Object.keys(iface.errors).forEach((error) => {
+          const sigHash = iface.getSighash(error);
+          this._errorsMap.set(
+            sigHash.toLowerCase(),
+            iface.errors[error] as ErrorFragment
+          );
+        });
+      });
+    }
+  }
+}

package/src/exchanges/mixin.ts

@@ -1,7 +1,7 @@
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import * as subgraph from "../subgraph";
 import { TransactionResponse, Log } from "@bosonprotocol/common";
-import { BigNumberish } from "@ethersproject/bignumber";
+import { BigNumberish, BigNumber } from "@ethersproject/bignumber";
 import { getValueFromLogs } from "../utils/logs";
 import {
   commitToOffer,
@@ -208,4 +208,21 @@ export class ExchangesMixin extends BaseCoreSDK {
       subgraphUrl: this._subgraphUrl
     });
   }
+
+  public getExchangeTokenId(
+    exchangeId: BigNumberish,
+    offerId: BigNumberish
+  ): BigNumber {
+    // Since v2.2.1, tokenId = exchangeId | offerId << 128
+    return BigNumber.from(offerId).shl(128).add(exchangeId);
+  }
+
+  public parseTokenId(tokenId: BigNumberish): {
+    offerId: BigNumber;
+    exchangeId: BigNumber;
+  } {
+    const offerId = BigNumber.from(tokenId).shr(128);
+    const exchangeId = BigNumber.from(tokenId).mask(128);
+    return { offerId, exchangeId };
+  }
 }

package/src/metadata/storeMetadataItems.ts

@@ -11,7 +11,7 @@ export async function storeMetadataItems(args: {
       const offerMetadata = await args.metadataStorage?.getMetadata(
         offerToCreate.metadataUri
       );
-      if (offerMetadata.type === "BUNDLE") {
+      if (offerMetadata?.type === "BUNDLE") {
         await Promise.all(
           offerMetadata.items.map((item) => {
             return storeMetadataOnTheGraph({

package/src/mixins/base-core-sdk.ts

@@ -3,7 +3,8 @@ import {
   MetadataStorage,
   MetaTxConfig,
   ContractAddresses,
-  Lens
+  Lens,
+  ErrorFragment
 } from "@bosonprotocol/common";
 import { TokenInfoManager } from "../utils/tokenInfoManager";
 
@@ -17,6 +18,8 @@ export class BaseCoreSDK {
   protected _chainId: number;
   protected _tokenInfoManager: TokenInfoManager;
 
+  protected _errorsMap = new Map<string, ErrorFragment>();
+
   protected _metaTxConfig?: Partial<MetaTxConfig>;
   protected _lens?: Lens;
   protected _contracts?: ContractAddresses;

package/src/subgraph/mixin.ts

@@ -0,0 +1,113 @@
+import { GraphQLClient, gql } from "graphql-request";
+import { TransactionReceipt, TransactionResponse } from "@bosonprotocol/common";
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+
+const DELAYS_PER_CHAINID: {
+  [key: number]: {
+    BLOCK_DELAY: number;
+    MAX_SAME_BLOCK: number;
+    MAX_SAME_BLOCK_DELAY: number;
+    DEFAULT_TIMEOUT: number;
+  };
+} = {
+  1: {
+    BLOCK_DELAY: 12000,
+    MAX_SAME_BLOCK: 20,
+    MAX_SAME_BLOCK_DELAY: 30000,
+    DEFAULT_TIMEOUT: 60000
+  },
+  137: {
+    BLOCK_DELAY: 1000,
+    MAX_SAME_BLOCK: 20,
+    MAX_SAME_BLOCK_DELAY: 5000,
+    DEFAULT_TIMEOUT: 30000
+  },
+  80001: {
+    BLOCK_DELAY: 1000,
+    MAX_SAME_BLOCK: 20,
+    MAX_SAME_BLOCK_DELAY: 5000,
+    DEFAULT_TIMEOUT: 30000
+  },
+  80002: {
+    BLOCK_DELAY: 1000,
+    MAX_SAME_BLOCK: 20,
+    MAX_SAME_BLOCK_DELAY: 5000,
+    DEFAULT_TIMEOUT: 30000
+  },
+  11155111: {
+    BLOCK_DELAY: 12000,
+    MAX_SAME_BLOCK: 20,
+    MAX_SAME_BLOCK_DELAY: 30000,
+    DEFAULT_TIMEOUT: 60000
+  },
+  31337: {
+    BLOCK_DELAY: 200,
+    MAX_SAME_BLOCK: 20,
+    MAX_SAME_BLOCK_DELAY: 1000,
+    DEFAULT_TIMEOUT: 3000
+  }
+};
+
+export class SubgraphMixin extends BaseCoreSDK {
+  public async waitForGraphNodeIndexing(
+    blockNumberOrTransaction?: number | TransactionResponse | TransactionReceipt
+  ) {
+    const delays = DELAYS_PER_CHAINID[this._chainId];
+    let blockToWaitFor = 0;
+    if (typeof blockNumberOrTransaction === "number") {
+      blockToWaitFor = blockNumberOrTransaction;
+    } else if (blockNumberOrTransaction?.["blockNumber"]) {
+      blockToWaitFor = (blockNumberOrTransaction as TransactionReceipt)
+        .blockNumber;
+    } else if (blockNumberOrTransaction?.["wait"]) {
+      const txReceipt = await (
+        blockNumberOrTransaction as TransactionResponse
+      ).wait();
+      blockToWaitFor = txReceipt.blockNumber;
+    }
+    if (blockToWaitFor > 0) {
+      let currentBlock = await this.getSubgraphBlockNumber();
+      let oldCurrentBlock = currentBlock;
+      let sameBlockNumber = 0;
+      while (currentBlock < blockToWaitFor) {
+        await this.wait(delays.BLOCK_DELAY);
+        currentBlock = await this.getSubgraphBlockNumber();
+        if (currentBlock === oldCurrentBlock) {
+          if (sameBlockNumber++ >= delays.MAX_SAME_BLOCK) {
+            // Seems that the subgraph does not update its current block
+            console.error(
+              `Seems that the subgraph does not update its current block after ${currentBlock}`
+            );
+            await this.wait(delays.MAX_SAME_BLOCK_DELAY);
+            return;
+          }
+        }
+        oldCurrentBlock = currentBlock;
+      }
+      return;
+    }
+    await this.wait(delays.DEFAULT_TIMEOUT);
+  }
+
+  public async getSubgraphBlockNumber(): Promise<number> {
+    const client = new GraphQLClient(this._subgraphUrl);
+    const response = await client.request<{
+      _meta?: { block?: { number?: number } };
+    }>(gql`
+      query MyQuery {
+        _meta {
+          block {
+            number
+          }
+        }
+      }
+    `);
+    return response?._meta?.block?.number || 0;
+  }
+
+  protected async wait(ms: number) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+}