nft-openaction-kit

Description

The nft-openaction-kit package simplifies the process of integrating an NFT minting open action into Lens applications. This package has two core functionalities:

When a user posts a link to an NFT in a Lens Publication, this package will parse data from the URL and smart contracts to embed an NFT minting open action into the Lens Publication.

When a post appears in a Lens application feed with the NFT minting action attached, the app can use this package to populate metadata to appear on a UI and generate calldata to perform the transaction.

Features

Function 1: detectAndReturnCalldata. Detects the NFT platform and returns the calldata to be used in the post action.
Function 2: actionDataFromPost. Returns the encoded calldata from Decent and UI data for the post action.
Extensible: the kit is extensible to add new NFT platforms with the usage of IPlatformService interface.
Zora detection logic: detect collections with an active sale (ZoraCreatorFixedPriceSaleStrategy for ERC1155 or contract collection for ERC721). All other cases are discarded as they don't represent a minting event (require specific handling - e.g. Seaport integration).

actionDataFromPost is returing undefined as the actionResponse from Decent is empty.

The route from Polygon to Zora is not configured in the Decent API.

Installation

Clone the repo

git clone https://github.com/0xnogo/nft-openAction-kit.git

Install NPM packages
```
yarn install
```
Build
```
yarn build
```

Usage

The package is not published. To use is locally, run yarn link in the root directory and yarn link nft-openaction-kit in the project you want to use it.

Create a .env file in the root directory and add the following variables:
```
DECENT_API_KEY=api-key
RARIBLE_API_KEY=api-key
OPENSEA_API_KEY=api-key
```
Instantiate the NFTOpenActionKit class and use the detectAndReturnCalldata and actionDataFromPost methods.

import { NftOpenActionKit } from "nft-openaction-kit";

const nftOpenActionKit = new NftOpenActionKit({
  decentApiKey: process.env.DECENT_API_KEY,
  raribleApiKey: process.env.RARIBLE_API_KEY,
  openSeaApiKey: process.env.OPENSEA_API_KEY,
});

Only the decentApiKey is required. The raribleApiKey and openSeaApiKey are optional, which would make the detection available for these platforms.

Use detectAndReturnCalldata

const fetchCalldata = async () => {
  try {
    const result = await nftOpenActionKit.detectAndReturnCalldata({
      contentURI: url,
      publishingClientProfileId: "10",
    });
    console.log(result || "No calldata found");
  } catch (err) {
    console.log(err);
  }
};

Use actionDataFromPost

const publication = {
  profileId: "48935",
  actionModules: ["0x99Cd5A6e51C85CCc63BeC61A177003A551953628"],
  actionModulesInitDatas: [calldata],
  pubId: "10",
};

try {
  // Call the async function and pass the link
  const result: ActionData = await nftOpenActionKit.actionDataFromPost({
    post: publication,
    profileId,
    profileOwnerAddress,
    senderAddress,
    srcChainId,
    quantity,
    paymentToken,
    executingClientProfileId,
    mirrorerProfileId,
    mirrorPubId,
    sourceUrl,
  });
} catch (error) {
  console.log(error);
}

The actionDataFromPost function is accepting a subset of fields from Publication events (example event defined in https://github.com/wkantaros/lens-openAction).

Add a new NFT platform

If an api is required, modify the SdkConfig type in src/types/index.ts:

type SdkConfig = {
  decentApiKey: string,
  raribleApiKey?: string,
  openSeaApiKey?: string,
};

Modify the initializePlatformConfig function in src/DetectionEngine.ts and add the new platform config following the type:

type NFTPlatform = {
  platformName: string,
  platformLogoUrl: string,
  urlPattern: RegExp,
  urlExtractor: (url: string) => Promise<NFTExtraction | undefined>,
  platformService: PlatformServiceConstructor,
};

Create a new file in src/platform and add the platform service class. The class should implement the IPlatformService interface.

export type NFTPlatform = {
  platformName: string,
  platformLogoUrl: string,
  urlPattern: RegExp,
  urlExtractor: (url: string) => Promise<NFTExtraction | undefined>,
  urlExtractor: (url: string) => Promise<NFTExtraction | undefined>,
  platformService: PlatformServiceConstructor,
  apiKey?: string,
};

If an api key is required, make sure to add it in the DetectionEngine class and handle it in the initializePlatformConfig function. The Rareble detection is an example of how to handle an api key.

Create a new file in src/platform and add the platform service class. The class should implement the IPlatformService interface.

interface IPlatformService {
  platformName: string;
  getMinterAddress(
    contract: string,
    tokenId: bigint
  ): Promise<string | undefined>;
  getMintSignature(nftDetails: NFTExtraction): Promise<string | undefined>;
  getUIData(
    signature: string,
    contract: string,
    tokenId: bigint,
    dstChainId: bigint,
    sourceUrl?: string
  ): Promise<UIData | undefined>;
  getPrice(
    contractAddress: string,
    nftId: bigint,
    signature: string,
    userAddress: string,
    unit?: bigint,
    sourceUrl?: string
  ): Promise<bigint | undefined>;
  getArgs(
    contractAddress: string,
    tokenId: bigint,
    senderAddress: string,
    signature: string,
    price: bigint,
    quantity: bigint,
    profileOwnerAddress: string,
    sourceUrl?: string
  ): Promise<any[]>;
}

hanahem / nft-openAction-kit