How to use Stability AI in Story

﻿
Let's say you generate an image using Stability AI. Without adding a proper license to your image, others could use it freely. In this tutorial, you will learn how to add a license to your Stability AI-Generated image so that if others want to use it, they must properly license it from you.
🧾 References and Sites
﻿https://docs.story.foundation/docs/register-stability-images﻿
﻿https://docs.story.foundation/docs/deployed-smart-contracts﻿
﻿https://platform.stability.ai/﻿
﻿https://app.pinata.cloud/﻿
﻿
🛠️ Prerequisites before starting
1. Install Node.js
⌨️
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo bash - sudo apt-get install -y nodejs
node -v
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo bash - sudo apt-get install -y nodejs
node -v
﻿
﻿
📍Result : Terminal
﻿
2. Install the dependencies
⌨️
 mkdir story_si && cd story_si
 npm install @story-protocol/core-sdk pinata viem axios sharp form-data
 mkdir story_si && cd story_si
 npm install @story-protocol/core-sdk pinata viem axios sharp form-data
﻿
﻿
📍Result : Terminal
﻿
3. Config .env
The private key is an EVM wallet and the wallet must hold at least one IP token.
Pinata. Stability API is available for free on their website.
⌨️
 nano .env
 nano .env
﻿
⌨️
WALLET_PRIVATE_KEY=
PINATA_JWT=
PINATA_GATEWAY=
STABILITY_API_KEY=
RPC_PROVIDER_URL=https://rpc.odyssey.storyrpc.io
ROYALTY_POLICY_LAP_ADDRESS=0x28b4F70ffE5ba7A26aEF979226f77Eb57fb9Fdb6
SUSD_ADDRESS=0xC0F6E387aC0B324Ec18EAcf22EE7271207dCE3d5
WALLET_PRIVATE_KEY=
PINATA_JWT=
PINATA_GATEWAY=
STABILITY_API_KEY=
RPC_PROVIDER_URL=https://rpc.odyssey.storyrpc.io
ROYALTY_POLICY_LAP_ADDRESS=0x28b4F70ffE5ba7A26aEF979226f77Eb57fb9Fdb6
SUSD_ADDRESS=0xC0F6E387aC0B324Ec18EAcf22EE7271207dCE3d5
﻿
📍Result : Terminal
﻿
🖼️  How to register NFT in Story
1.  Generating Stability API Images
⌨️
nano si_image.js
nano si_image.js
﻿
⌨️
import dotenv from 'dotenv';
dotenv.config();
import { PinataSDK } from 'pinata'
const pinata = new PinataSDK({
  pinataJwt: process.env.PINATA_JWT,
  pinataGateway: process.env.PINATA_GATEWAY
})

// Find or create a group to store public images
export async function getOrCreatePublicGroup() {
  const response = await pinata.groups.list()
  const groups = response.groups // Access the groups array

  // Check if groups is an array
  if (Array.isArray(groups)) {
    let group = groups.find(g => g.name === 'Public Stability Images')

    // If the group doesn't exist, create it
    if (!group) {
      group = await pinata.groups.create({
        name: 'Public Stability Images',
        isPublic: true,
      })
    }

    return group.id
  } else {
    throw new Error('The format of groups is not an array.')
  }
}

// Upload our image to IPFS by putting it in a public group
export async function uploadBlobToIPFS(blob, fileName, groupId) {
  const file = new File([blob], fileName, { type: 'image/png' })
  
  // Start the upload
  const response = await pinata.upload.file(file).group(groupId)
  const { cid } = await response
  return cid
}

// Example usage
const blob = new Blob(['Your image data here'], { type: 'image/png' })
const fileName = 'compressed_image.png'
const groupId = await getOrCreatePublicGroup()

uploadBlobToIPFS(blob, fileName, groupId).then((cid) => {
  console.log(`Image uploaded to IPFS with CID: ${cid}`)
}).catch((error) => {
  console.error('Error uploading image:', error)
})
import dotenv from 'dotenv';
dotenv.config();
import { PinataSDK } from 'pinata'
const pinata = new PinataSDK({
  pinataJwt: process.env.PINATA_JWT,
  pinataGateway: process.env.PINATA_GATEWAY
})

// Find or create a group to store public images
export async function getOrCreatePublicGroup() {
  const response = await pinata.groups.list()
  const groups = response.groups // Access the groups array

  // Check if groups is an array
  if (Array.isArray(groups)) {
    let group = groups.find(g => g.name === 'Public Stability Images')

    // If the group doesn't exist, create it
    if (!group) {
      group = await pinata.groups.create({
        name: 'Public Stability Images',
        isPublic: true,
      })
    }

    return group.id
  } else {
    throw new Error('The format of groups is not an array.')
  }
}

// Upload our image to IPFS by putting it in a public group
export async function uploadBlobToIPFS(blob, fileName, groupId) {
  const file = new File([blob], fileName, { type: 'image/png' })
  
  // Start the upload
  const response = await pinata.upload.file(file).group(groupId)
  const { cid } = await response
  return cid
}

// Example usage
const blob = new Blob(['Your image data here'], { type: 'image/png' })
const fileName = 'compressed_image.png'
const groupId = await getOrCreatePublicGroup()

uploadBlobToIPFS(blob, fileName, groupId).then((cid) => {
  console.log(`Image uploaded to IPFS with CID: ${cid}`)
}).catch((error) => {
  console.error('Error uploading image:', error)
})
﻿
📍Result : Terminal
﻿
2.  Store Image in IPFS
⌨️
nano ipfs.js
nano ipfs.js
﻿
⌨️
import dotenv from 'dotenv';
dotenv.config();
import { PinataSDK } from 'pinata'

const pinata = new PinataSDK({
  pinataJwt: process.env.PINATA_JWT,
  pinataGateway: process.env.PINATA_GATEWAY
})

// Find or create a group to store public images
export async function getOrCreatePublicGroup() {
  const response = await pinata.groups.list()
  const groups = response.groups // Access the groups array

  // Check if groups is an array
  if (Array.isArray(groups)) {
    let group = groups.find(g => g.name === 'Public Stability Images')

    // If the group doesn't exist, create it
    if (!group) {
      group = await pinata.groups.create({
        name: 'Public Stability Images',
        isPublic: true,
      })
    }

    return group.id
  } else {
    throw new Error('The format of groups is not an array.')
  }
}

// Upload our image to IPFS by putting it in a public group
export async function uploadBlobToIPFS(blob, fileName, groupId) {
  const file = new File([blob], fileName, { type: 'image/png' })
  
  // Start the upload
  const response = await pinata.upload.file(file).group(groupId)
  const { cid } = await response
  return cid
}

// Example usage
const blob = new Blob(['Your image data here'], { type: 'image/png' })
const fileName = 'compressed_image.png'
const groupId = await getOrCreatePublicGroup()

uploadBlobToIPFS(blob, fileName, groupId).then((cid) => {
  console.log(`Image uploaded to IPFS with CID: ${cid}`)
}).catch((error) => {
  console.error('Error uploading image:', error)
})
import dotenv from 'dotenv';
dotenv.config();
import { PinataSDK } from 'pinata'

const pinata = new PinataSDK({
  pinataJwt: process.env.PINATA_JWT,
  pinataGateway: process.env.PINATA_GATEWAY
})

// Find or create a group to store public images
export async function getOrCreatePublicGroup() {
  const response = await pinata.groups.list()
  const groups = response.groups // Access the groups array

  // Check if groups is an array
  if (Array.isArray(groups)) {
    let group = groups.find(g => g.name === 'Public Stability Images')

    // If the group doesn't exist, create it
    if (!group) {
      group = await pinata.groups.create({
        name: 'Public Stability Images',
        isPublic: true,
      })
    }

    return group.id
  } else {
    throw new Error('The format of groups is not an array.')
  }
}

// Upload our image to IPFS by putting it in a public group
export async function uploadBlobToIPFS(blob, fileName, groupId) {
  const file = new File([blob], fileName, { type: 'image/png' })
  
  // Start the upload
  const response = await pinata.upload.file(file).group(groupId)
  const { cid } = await response
  return cid
}

// Example usage
const blob = new Blob(['Your image data here'], { type: 'image/png' })
const fileName = 'compressed_image.png'
const groupId = await getOrCreatePublicGroup()

uploadBlobToIPFS(blob, fileName, groupId).then((cid) => {
  console.log(`Image uploaded to IPFS with CID: ${cid}`)
}).catch((error) => {
  console.error('Error uploading image:', error)
})
﻿
⌨️
node ipfs.js
node ipfs.js
﻿
📍Result : Terminal
﻿
📍Result : https://app.pinata.cloud/﻿
﻿
 3. Set up your IP NFT (Metadata, License Terms, E.T.C.)
⌨️
nano story_nft.mjs
nano story_nft.mjs
﻿
⌨️
import dotenv from 'dotenv';
dotenv.config();

import pkg from '@story-protocol/core-sdk';
const { StoryClient, IpMetadata, LicenseTerms } = pkg;
import { http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { uploadJSONToIPFS } from "./utils/uploadToIpfs.js";
import { createHash } from "crypto";

// Set environment variables
const privateKey = `0x${process.env.WALLET_PRIVATE_KEY}`;
const account = privateKeyToAccount(privateKey);

const config = {
  account: account,
  transport: http(process.env.RPC_PROVIDER_URL),
  chainId: "odyssey",
};

const client = new StoryClient(config);

// Check available methods in the client object
console.log(client);

// Function to register an image as IP
async function registerImageAsIP(cid, title, description) {
  const ipMetadata = {
    title: title,
    description: description,
    ipType: 'image',
    attributes: [
      {
        key: 'Model',
        value: 'Stability',
      },
      {
        key: 'Service',
        value: 'Stable Image Core'
      },
      {
        key: 'Prompt',
        value: 'Lighthouse on a cliff overlooking the ocean',
      },
    ],
    creators: [
      {
        name: 'zstake',
        contributionPercent: 100,
        address: account.address,
      },
    ],
  };

  const nftMetadata = {
    name: 'NFT representing ownership of our image',
    description: 'This NFT represents ownership of the image generated by Stability',
    image: process.env.PINATA_GATEWAY + '/files/' + cid,
    attributes: [
      {
        key: 'Model',
        value: 'Stability',
      },
      {
        key: 'Service',
        value: 'Stable Image Core'
      },
      {
        key: 'Prompt',
        value: 'Lighthouse on a cliff overlooking the ocean',
      },
    ]
  };

  try {
    // Upload IP metadata to IPFS
    const ipIpfsHash = await uploadJSONToIPFS(ipMetadata);
    const ipHash = createHash("sha256")
      .update(JSON.stringify(ipMetadata))
      .digest("hex");

    // Upload NFT metadata to IPFS
    const nftIpfsHash = await uploadJSONToIPFS(nftMetadata);
    const nftHash = createHash("sha256")
      .update(JSON.stringify(nftMetadata))
      .digest("hex");

    console.log(`IP metadata IPFS hash: ${ipIpfsHash}`);
    console.log(`IP metadata SHA-256 hash: ${ipHash}`);
    console.log(`NFT metadata IPFS hash: ${nftIpfsHash}`);
    console.log(`NFT metadata SHA-256 hash: ${nftHash}`);

    // After confirming the exact method name, use it.
    // const response = await client.<methodName>(ipMetadata);
    // console.log(`Image successfully registered. ID: ${response.id}`);
  } catch (error) {
    console.error('Error registering image as IP:', error);
  }
}

// Set and register license terms
const royaltyPolicyLAPAddress = '0x28b4F70ffE5ba7A26aEF979226f77Eb57fb9Fdb6'; // Insert RoyaltyPolicyLAP address
const susdAddress = '0xC0F6E387aC0B324Ec18EAcf22EE7271207dCE3d5'; // Insert SUSD address

const commercialRemixTerms = {
  transferable: true,
  royaltyPolicy: '0x28b4F70ffE5ba7A26aEF979226f77Eb57fb9Fdb6',
  defaultMintingFee: BigInt(10),
  expiration: BigInt(0),
  commercialUse: true,
  commercialAttribution: true, // Copyright notice required
  commercializerChecker: '0x0000000000000000000000000000000000000000',
  commercializerCheckerData: '0x0000000000000000000000000000000000000000',
  commercialRevShare: 50, // Claim 50% of derivative revenue
  commercialRevCeiling: BigInt(0),
  derivativesAllowed: true,
  derivativesAttribution: true,
  derivativesApproval: false,
  derivativesReciprocal: true,
  derivativeRevCeiling: BigInt(0),
  currency: susdAddress,
  uri: '',
}

// Function to register license terms
async function registerLicenseTerms() {
  try {
    // After confirming the exact method name, use it.
    // const response = await client.<methodName>(commercialRemixTerms);
    // console.log('License terms registered successfully:', response);
  } catch (error) {
    console.error('Error registering license terms:', error);
  }
}

// Example usage
const cid = 'YOUR CID'; 
const title = 'YOUR Titile';
const description = '~~~';

registerImageAsIP(cid, title, description);
registerLicenseTerms();

import dotenv from 'dotenv';
dotenv.config();

import pkg from '@story-protocol/core-sdk';
const { StoryClient, IpMetadata, LicenseTerms } = pkg;
import { http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { uploadJSONToIPFS } from "./utils/uploadToIpfs.js";
import { createHash } from "crypto";

// Set environment variables
const privateKey = `0x${process.env.WALLET_PRIVATE_KEY}`;
const account = privateKeyToAccount(privateKey);

const config = {
  account: account,
  transport: http(process.env.RPC_PROVIDER_URL),
  chainId: "odyssey",
};

const client = new StoryClient(config);

// Check available methods in the client object
console.log(client);

// Function to register an image as IP
async function registerImageAsIP(cid, title, description) {
  const ipMetadata = {
    title: title,
    description: description,
    ipType: 'image',
    attributes: [
      {
        key: 'Model',
        value: 'Stability',
      },
      {
        key: 'Service',
        value: 'Stable Image Core'
      },
      {
        key: 'Prompt',
        value: 'Lighthouse on a cliff overlooking the ocean',
      },
    ],
    creators: [
      {
        name: 'zstake',
        contributionPercent: 100,
        address: account.address,
      },
    ],
  };

  const nftMetadata = {
    name: 'NFT representing ownership of our image',
    description: 'This NFT represents ownership of the image generated by Stability',
    image: process.env.PINATA_GATEWAY + '/files/' + cid,
    attributes: [
      {
        key: 'Model',
        value: 'Stability',
      },
      {
        key: 'Service',
        value: 'Stable Image Core'
      },
      {
        key: 'Prompt',
        value: 'Lighthouse on a cliff overlooking the ocean',
      },
    ]
  };

  try {
    // Upload IP metadata to IPFS
    const ipIpfsHash = await uploadJSONToIPFS(ipMetadata);
    const ipHash = createHash("sha256")
      .update(JSON.stringify(ipMetadata))
      .digest("hex");

    // Upload NFT metadata to IPFS
    const nftIpfsHash = await uploadJSONToIPFS(nftMetadata);
    const nftHash = createHash("sha256")
      .update(JSON.stringify(nftMetadata))
      .digest("hex");

    console.log(`IP metadata IPFS hash: ${ipIpfsHash}`);
    console.log(`IP metadata SHA-256 hash: ${ipHash}`);
    console.log(`NFT metadata IPFS hash: ${nftIpfsHash}`);
    console.log(`NFT metadata SHA-256 hash: ${nftHash}`);

    // After confirming the exact method name, use it.
    // const response = await client.<methodName>(ipMetadata);
    // console.log(`Image successfully registered. ID: ${response.id}`);
  } catch (error) {
    console.error('Error registering image as IP:', error);
  }
}

// Set and register license terms
const royaltyPolicyLAPAddress = '0x28b4F70ffE5ba7A26aEF979226f77Eb57fb9Fdb6'; // Insert RoyaltyPolicyLAP address
const susdAddress = '0xC0F6E387aC0B324Ec18EAcf22EE7271207dCE3d5'; // Insert SUSD address

const commercialRemixTerms = {
  transferable: true,
  royaltyPolicy: '0x28b4F70ffE5ba7A26aEF979226f77Eb57fb9Fdb6',
  defaultMintingFee: BigInt(10),
  expiration: BigInt(0),
  commercialUse: true,
  commercialAttribution: true, // Copyright notice required
  commercializerChecker: '0x0000000000000000000000000000000000000000',
  commercializerCheckerData: '0x0000000000000000000000000000000000000000',
  commercialRevShare: 50, // Claim 50% of derivative revenue
  commercialRevCeiling: BigInt(0),
  derivativesAllowed: true,
  derivativesAttribution: true,
  derivativesApproval: false,
  derivativesReciprocal: true,
  derivativeRevCeiling: BigInt(0),
  currency: susdAddress,
  uri: '',
}

// Function to register license terms
async function registerLicenseTerms() {
  try {
    // After confirming the exact method name, use it.
    // const response = await client.<methodName>(commercialRemixTerms);
    // console.log('License terms registered successfully:', response);
  } catch (error) {
    console.error('Error registering license terms:', error);
  }
}

// Example usage
const cid = 'YOUR CID'; 
const title = 'YOUR Titile';
const description = '~~~';

registerImageAsIP(cid, title, description);
registerLicenseTerms();
﻿
⌨️
node story_nft.mjs
node story_nft.mjs
﻿
📍Result : Terminal
﻿
📍Result : https://app.pinata.cloud/    * IPFS meta upload(data.json)
﻿
4. Create NFT collection
⌨️
nano create_nft_collection.mjs
nano create_nft_collection.mjs
﻿
⌨️
import dotenv from 'dotenv';
dotenv.config();

import pkg from '@story-protocol/core-sdk';
const { StoryClient } = pkg; 
import { http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

const privateKey = `0x${process.env.WALLET_PRIVATE_KEY}`;
const account = privateKeyToAccount(privateKey);

const config = {
  account: account,
  transport: http(process.env.RPC_PROVIDER_URL),
  chainId: 'odyssey',
};

const client = new StoryClient(config);

const createNFTCollection = async () => {
  const newCollection = await client.nftClient.createNFTCollection({
    name: 'zstake NFTs',
    symbol: 'zNFT',
    isPublicMinting: true,
    mintOpen: true,
    mintFeeRecipient: '0x0000000000000000000000000000000000000000', // zeroAddress
    contractURI: '',
    txOptions: { waitForTransaction: true },
  });

  console.log(
    `New SPG NFT collection created at transaction hash ${newCollection.txHash}`,
    `SPG NFT contract address: ${newCollection.spgNftContract}`
  );
};

// Call the function
createNFTCollection();
import dotenv from 'dotenv';
dotenv.config();

import pkg from '@story-protocol/core-sdk';
const { StoryClient } = pkg; 
import { http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

const privateKey = `0x${process.env.WALLET_PRIVATE_KEY}`;
const account = privateKeyToAccount(privateKey);

const config = {
  account: account,
  transport: http(process.env.RPC_PROVIDER_URL),
  chainId: 'odyssey',
};

const client = new StoryClient(config);

const createNFTCollection = async () => {
  const newCollection = await client.nftClient.createNFTCollection({
    name: 'zstake NFTs',
    symbol: 'zNFT',
    isPublicMinting: true,
    mintOpen: true,
    mintFeeRecipient: '0x0000000000000000000000000000000000000000', // zeroAddress
    contractURI: '',
    txOptions: { waitForTransaction: true },
  });

  console.log(
    `New SPG NFT collection created at transaction hash ${newCollection.txHash}`,
    `SPG NFT contract address: ${newCollection.spgNftContract}`
  );
};

// Call the function
createNFTCollection();
﻿
⌨️
node create_nft_collection.mjs
node create_nft_collection.mjs
﻿
📍Result : Terminal
﻿
📍Result : Odyssey Testnet Scan
﻿
5. Install the dependencies
SPG_NFT_CONTRACT_ADDRESS= runs node create_nft_collection.mjs and uses the output address.
⌨️
 nano .env
 nano .env
﻿
⌨️
SPG_NFT_CONTRACT_ADDRESS= =
SPG_NFT_CONTRACT_ADDRESS= =
﻿
      <npm install>
﻿
6. NFT mint and register IP
⌨️
nano mint_and_register_ip_asset.mjs
nano mint_and_register_ip_asset.mjs
﻿
⌨️
import dotenv from 'dotenv';
dotenv.config();

import pkg from '@story-protocol/core-sdk';
const { StoryClient } = pkg;
import { http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { createHash } from 'crypto';

const privateKey = `0x${process.env.WALLET_PRIVATE_KEY}`;
const account = privateKeyToAccount(privateKey);

const config = {
  account: account,
  transport: http(process.env.RPC_PROVIDER_URL),
  chainId: 'odyssey',
};

const client = new StoryClient(config);

const ipIpfsHash = 'bafkreibhof7bofpx5ya2qmvzipslrirhel7egb2cvw4abr4tlhxqjybcoy';
const ipHash = createHash('sha256').update('ip metadata').digest('hex');
const nftIpfsHash = 'bafkreiaiohxpcdpz4xrcxubsoakxclruwg4px2tzj2ybscwve3se2kxho4';
const nftHash = createHash('sha256').update('nft metadata').digest('hex');

const royaltyPolicyLAPAddress = process.env.ROYALTY_POLICY_LAP_ADDRESS;
const susdAddress = process.env.SUSD_ADDRESS;

const commercialRemixTerms = {
  transferable: true,
  royaltyPolicy: royaltyPolicyLAPAddress,
  defaultMintingFee: BigInt(10),
  expiration: BigInt(0),
  commercialUse: true,
  commercialAttribution: true,
  commercializerChecker: '0x0000000000000000000000000000000000000000',
  commercializerCheckerData: '0x0000000000000000000000000000000000000000',
  commercialRevShare: 50,
  commercialRevCeiling: BigInt(0),
  derivativesAllowed: true,
  derivativesAttribution: true,
  derivativesApproval: false,
  derivativesReciprocal: true,
  derivativeRevCeiling: BigInt(0),
  currency: susdAddress,
  uri: '',
};

const registerIpAsset = async () => {
  const response = await client.ipAsset.mintAndRegisterIpAssetWithPilTerms({
    spgNftContract: process.env.SPG_NFT_CONTRACT_ADDRESS,
    terms: [commercialRemixTerms],
    ipMetadata: {
      ipMetadataURI: process.env.PINATA_GATEWAY + '/files/' + ipIpfsHash,
      ipMetadataHash: `0x${ipHash}`,
      nftMetadataURI: process.env.PINATA_GATEWAY + '/files/' + nftIpfsHash,
      nftMetadataHash: `0x${nftHash}`,
    },
    txOptions: { waitForTransaction: true },
  });

  console.log(
    `Root IPA created at transaction hash ${response.txHash}, IPA ID: ${response.ipId}`
  );
  console.log(
    `View on the explorer: https://explorer.story.foundation/ipa/${response.ipId}`
  );
};

// Call the function
registerIpAsset();
import dotenv from 'dotenv';
dotenv.config();

import pkg from '@story-protocol/core-sdk';
const { StoryClient } = pkg;
import { http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { createHash } from 'crypto';

const privateKey = `0x${process.env.WALLET_PRIVATE_KEY}`;
const account = privateKeyToAccount(privateKey);

const config = {
  account: account,
  transport: http(process.env.RPC_PROVIDER_URL),
  chainId: 'odyssey',
};

const client = new StoryClient(config);

const ipIpfsHash = 'bafkreibhof7bofpx5ya2qmvzipslrirhel7egb2cvw4abr4tlhxqjybcoy';
const ipHash = createHash('sha256').update('ip metadata').digest('hex');
const nftIpfsHash = 'bafkreiaiohxpcdpz4xrcxubsoakxclruwg4px2tzj2ybscwve3se2kxho4';
const nftHash = createHash('sha256').update('nft metadata').digest('hex');

const royaltyPolicyLAPAddress = process.env.ROYALTY_POLICY_LAP_ADDRESS;
const susdAddress = process.env.SUSD_ADDRESS;

const commercialRemixTerms = {
  transferable: true,
  royaltyPolicy: royaltyPolicyLAPAddress,
  defaultMintingFee: BigInt(10),
  expiration: BigInt(0),
  commercialUse: true,
  commercialAttribution: true,
  commercializerChecker: '0x0000000000000000000000000000000000000000',
  commercializerCheckerData: '0x0000000000000000000000000000000000000000',
  commercialRevShare: 50,
  commercialRevCeiling: BigInt(0),
  derivativesAllowed: true,
  derivativesAttribution: true,
  derivativesApproval: false,
  derivativesReciprocal: true,
  derivativeRevCeiling: BigInt(0),
  currency: susdAddress,
  uri: '',
};

const registerIpAsset = async () => {
  const response = await client.ipAsset.mintAndRegisterIpAssetWithPilTerms({
    spgNftContract: process.env.SPG_NFT_CONTRACT_ADDRESS,
    terms: [commercialRemixTerms],
    ipMetadata: {
      ipMetadataURI: process.env.PINATA_GATEWAY + '/files/' + ipIpfsHash,
      ipMetadataHash: `0x${ipHash}`,
      nftMetadataURI: process.env.PINATA_GATEWAY + '/files/' + nftIpfsHash,
      nftMetadataHash: `0x${nftHash}`,
    },
    txOptions: { waitForTransaction: true },
  });

  console.log(
    `Root IPA created at transaction hash ${response.txHash}, IPA ID: ${response.ipId}`
  );
  console.log(
    `View on the explorer: https://explorer.story.foundation/ipa/${response.ipId}`
  );
};

// Call the function
registerIpAsset();
﻿
⌨️
node mint_and_register_ip_asset.mjs
node mint_and_register_ip_asset.mjs
﻿
📍Result : Terminal
﻿
📍Result : Odyssey Testnet Scan
﻿
﻿
﻿
💡  Zstake thoughts
You all probably know about the collaboration with Stability AI. We are all excited about this news, as Story Protocol is working on a real collaboration partnership.The announcement was made, but in just one day, the Story Protocol team has proven this through the official DOC, showing how IP works.
When we actually implemented it, all the functions were already in place on-chain and working through the API was smooth. IP will protect the survival of all creators in the future.
﻿
Ecosystem Travel Guide
Verio