@bosonprotocol/react-kit 0.41.0-alpha.2 → 0.41.0-alpha.4

package/src/lib/roblox/types.ts

@@ -0,0 +1,94 @@
+import { subgraph } from "@bosonprotocol/core-sdk";
+
+export type RobloxClaims = {
+  sub: string;
+  name: string;
+  nickname?: string;
+  picture?: string;
+  preferred_username?: string;
+  email?: string;
+  profile?: string;
+};
+
+export type RobloxUser = Omit<RobloxClaims, "sub"> & { userId: string };
+
+/**
+ * Product Metadata subgraph, with related Roblox assetId
+ */
+export type BosonRobloxProduct =
+  subgraph.ProductV1MetadataEntityFieldsFragment & {
+    robloxAssetId: string;
+  };
+
+export type BosonRobloxExchange = subgraph.ExchangeFieldsFragment & {
+  robloxAssetId: string;
+};
+
+export type RobloxInventoryItem = {
+  path: string;
+  assetDetails: {
+    assetId: string;
+  };
+};
+
+export type RobloxAsset = {
+  productType: string;
+  assetId: string;
+  productId: number;
+  name: string;
+  description: string;
+  iconImageAssetId: number;
+  assetTypeId: number;
+  isLimited: boolean;
+  isLimitedUnique: boolean;
+};
+
+export type GetInfoResponse = {
+  userId: string;
+  claims: RobloxClaims;
+  inventoryItems: RobloxInventoryItem[];
+};
+
+export type GetAssetDetailsResponse = RobloxAsset;
+
+export type GetLoggedInResponse = {
+  isLoggedIn: boolean;
+  claims: RobloxClaims | null;
+  nonce: string | null;
+};
+
+export type GetWalletAuthResponse = {
+  walletAuth: boolean;
+  address: string | null;
+  sellerId: string | null;
+};
+
+export type PendingRequest = { txHash: string; txId: string };
+
+/**
+ * A Product can be:
+ * - Unknown: the user is not authenticated on roblox
+ * - Not available: the roblox user is authenticated and it doesn't have the required Roblox asset
+ * - Potentially: the roblox user is authenticated and it has the required Roblox asset, the user wallet is not known yet
+ * - Pending: the roblox user is authenticated and it has the required Roblox asset and their wallet doesn't own the required NFT yet (minting is pending)
+ * - Available: the roblox user is authenticated and it has the required Roblox asset and their wallet owns the required NFT
+ *  */
+export type ProductAvailabilityStatus =
+  | { status: "UNKNOWN" | "POTENTIALLY" | "NOT_AVAILABLE" | "AVAILABLE" }
+  | { status: "PENDING"; pendingData: PendingRequest };
+
+export type BosonRobloxProductWithAvailability = BosonRobloxProduct & {
+  availability: ProductAvailabilityStatus;
+};
+
+export type HasMore = true | false | "maybe";
+
+export type GetProductsResponse = {
+  products: BosonRobloxProductWithAvailability[];
+  hasMore: HasMore;
+};
+
+export type GetExchangesResponse = {
+  exchanges: BosonRobloxExchange[];
+  hasMore: HasMore;
+};

package/src/lib/roblox/utils.ts

@@ -0,0 +1,57 @@
+import { subgraph } from "@bosonprotocol/core-sdk";
+import { ASSET_ID_ATTR_TRAIT_TYPE, ROBLOX_PRODUCT_TAG } from "./constants";
+import { ConditionStruct, TokenType } from "@bosonprotocol/common";
+
+/**
+ * Filter a Boson product, whether it's Roblox-related or not
+ * @param offerMetadata the Product Metadata object from Boson subgraph
+ * @param condition the ConditionStruct attached to the Boson offer
+ * @param nftContract address of the NFT contract used to token-gate the Roblox-Boson offer
+ * @param offerMetadata the Product Metadata object from Boson subgraph
+ * @returns false if not Roblox-related,
+ *  otherwise returns the Roblox assetId the offer is related to
+ */
+export function filterRobloxProduct(
+  offerMetadata: Pick<
+    subgraph.ProductV1MetadataEntityFieldsFragment,
+    "attributes"
+  > & { product: Pick<subgraph.ProductV1Product, "details_tags"> },
+  condition: ConditionStruct | undefined,
+  nftContract: string
+): string | false {
+  if (
+    offerMetadata.product &&
+    offerMetadata.product.details_tags &&
+    offerMetadata.product.details_tags
+      .map((t) => t.toLowerCase())
+      .includes(ROBLOX_PRODUCT_TAG.toLowerCase())
+  ) {
+    const robloxAssetId = offerMetadata.attributes?.find(
+      (attr) =>
+        attr.traitType.toLowerCase() === ASSET_ID_ATTR_TRAIT_TYPE.toLowerCase()
+    )?.value;
+    if (
+      condition &&
+      robloxAssetId &&
+      checkTokenGatingCondition(condition, {
+        tokenId: robloxAssetId,
+        nftContract
+      })
+    ) {
+      return robloxAssetId;
+    }
+  }
+  return false;
+}
+
+function checkTokenGatingCondition(
+  condition: ConditionStruct,
+  expected: { tokenId: string; nftContract: string }
+): boolean {
+  return (
+    condition.minTokenId.toString() === expected.tokenId &&
+    condition.maxTokenId.toString() === expected.tokenId &&
+    condition.tokenType === TokenType.MultiToken &&
+    condition.tokenAddress === expected.nftContract.toLowerCase()
+  );
+}