Comments

import {
  commentsABI,
  commentsAddress,
  emptyCommentIdentifier,
} from "@zoralabs/protocol-deployments";
import { zeroAddress, parseEther, parseEventLogs } from "viem";
import {
  publicClient,
  walletClient,
  chainId,
  commenterAccount,
  contractAddress1155,
  tokenId1155,
} from "./config";
 
// if no referrer, use zero address
const referrer = zeroAddress;
 
// if no smart wallet owner, use zero address
const smartWallet = zeroAddress;
 
const sparkValue = parseEther("0.000001");
 
// comment that we are replying to.  If there is no reply, use emptyCommentIdentifier() from @zoralabs/protocol-deployments
const replyTo = emptyCommentIdentifier();
// comment on token, paying the value of 1 spark to the contract
const hash = await walletClient.writeContract({
  abi: commentsABI,
  address: commentsAddress[chainId],
  functionName: "comment",
  args: [
    // account that is attributed with the comment; must match the account that is executing the transaction
    commenterAccount,
    // 1155 contract address to comment on.  Must be an admin or owner of the token.
    contractAddress1155,
    // tokenId of the token to comment on
    tokenId1155,
    // text content of the comment
    "This is a test comment",
    // empty reply to, since were not replying to any other comment
    replyTo,
    // optional smart wallet. smart wallet can be an owner or creator of the 1155 token.
    // and eoa that is the owner of the smart wallet can comment.
    smartWallet,
    // Optional referrer address to receive a portion of the sparks value
    referrer,
  ],
  // account that is executing the transaction. Must match the commenterAccount argument above.
  account: commenterAccount,
  // pay the value of 1 spark to the contract
  value: sparkValue,
});
 
// wait for comment to complete - make sure it succeeds
const receipt = await publicClient.waitForTransactionReceipt({ hash });
if (receipt.status !== "success") {
  throw new Error("Transaction failed");
}
 
// we can get the comment identifier from the Commented event in the receipt logs
const commentedEvent = parseEventLogs({
  abi: commentsABI,
  eventName: "Commented",
  logs: receipt.logs,
})[0]!;
 
const commentIdentifier = commentedEvent.args.commentIdentifier;
 
export { commentIdentifier };

import {
  commentsABI,
  commentsAddress,
  CommentIdentifier,
} from "@zoralabs/protocol-deployments";
import {
  commenterAccount,
  contractAddress1155,
  publicClient,
  tokenId1155,
  walletClient,
  chainId,
} from "./config";
import { commentIdentifier } from "./comment";
import { zeroAddress, parseEther } from "viem";
 
const sparkValue = parseEther("0.000001");
 
// this identifies the comment that we are replying to
// it can be gotten from the `Commented` event when commenting,
// or from the subgraph when querying for comments
const replyTo: CommentIdentifier = {
  commenter: commentIdentifier.commenter, 
  contractAddress: commentIdentifier.contractAddress, 
  tokenId: commentIdentifier.tokenId, 
  nonce: commentIdentifier.nonce, 
};
 
const referrer = zeroAddress;
 
const smartWallet = zeroAddress;
 
const hash = await walletClient.writeContract({
  abi: commentsABI,
  address: commentsAddress[chainId],
  functionName: "comment",
  args: [
    commenterAccount,
    contractAddress1155,
    tokenId1155,
    "This is a test reply",
    // when replying to a comment, we must pass the comment identifier of the comment we are replying to
    replyTo, 
    smartWallet,
    referrer,
  ],
  account: commenterAccount,
  value: sparkValue,
});
 
const receipt = await publicClient.waitForTransactionReceipt({ hash });
if (receipt.status !== "success") {
  throw new Error("Transaction failed");
}

import {
  commentsABI,
  commentsAddress,
  CommentIdentifier,
} from "@zoralabs/protocol-deployments";
import {
  commenterAccount,
  contractAddress1155,
  publicClient,
  tokenId1155,
  walletClient,
  chainId,
  sparkerAccount,
} from "./config";
import { keccak256, toBytes, zeroAddress, parseEther } from "viem";
 
// quantity of sparks to spark (like) the comment with
const sparksQuantity = 1n;
 
const sparkValue = parseEther("0.000001");
 
const commentIdentifier: CommentIdentifier = {
  commenter: commenterAccount,
  contractAddress: contractAddress1155,
  tokenId: tokenId1155,
  nonce: keccak256(toBytes(1)),
};
 
const referrer = zeroAddress;
 
const hash = await walletClient.writeContract({
  abi: commentsABI,
  address: commentsAddress[chainId],
  functionName: "sparkComment",
  args: [commentIdentifier, sparksQuantity, referrer],
  account: sparkerAccount,
  value: sparksQuantity * sparkValue,
});
 
const receipt = await publicClient.waitForTransactionReceipt({ hash });
if (receipt.status !== "success") {
  throw new Error("Transaction failed");
}

import {
  callerAndCommenterABI,
  callerAndCommenterAddress,
} from "@zoralabs/protocol-deployments";
import {
  publicClient,
  walletClient,
  chainId,
  minterAccount,
  contractAddress1155,
  tokenId1155,
} from "./config";
import { parseEther, zeroAddress } from "viem";
 
const mintFee = parseEther("0.000111");
 
const commenter = minterAccount;
const quantityToMint = 3n;
const collection = contractAddress1155;
const tokenId = tokenId1155;
const mintReferral = zeroAddress;
const comment = "This is a test comment";
 
// minting and commenting in one transaction, calling the `timedSaleMintAndComment` function
// on the `CallerAndCommenter` contract
const hash = await walletClient.writeContract({
  abi: callerAndCommenterABI,
  address: callerAndCommenterAddress[chainId],
  functionName: "timedSaleMintAndComment",
  args: [commenter, quantityToMint, collection, tokenId, mintReferral, comment],
  account: commenter,
  // when minting and commenting, only the mint fee needs to be paid;
  // no additional ETH is required to pay for commenting
  value: mintFee * quantityToMint,
});
 
const receipt = await publicClient.waitForTransactionReceipt({ hash });
if (receipt.status !== "success") {
  throw new Error("Transaction failed");
}

import {
  commentsABI,
  commentsAddress,
  emptyCommentIdentifier,
} from "@zoralabs/protocol-deployments";
import { zeroAddress, parseEther } from "viem";
import {
  publicClient,
  walletClient,
  chainId,
  commenterAccount,
  contractAddress1155,
  tokenId1155,
} from "./config";
 
// referrer is the address that will receive a portion of the Sparks value
const referrer = "0x1234567890123456789012345678901234567890"; 
 
const sparkValue = parseEther("0.000001");
 
const replyTo = emptyCommentIdentifier();
// comment on token, paying the value of 1 spark to the contract
const hash = await walletClient.writeContract({
  abi: commentsABI,
  address: commentsAddress[chainId],
  functionName: "comment",
  args: [
    commenterAccount,
    contractAddress1155,
    tokenId1155,
    "This is a test comment",
    replyTo,
    zeroAddress,
    // Optional referrer address to receive a portion of the Sparks value
    referrer, 
  ],
  // account that is executing the transaction. Must match the commenterAccount argument above.
  account: commenterAccount,
  // pay the value of 1 spark to the contract
  value: sparkValue,
});
 
// wait for comment to complete - make sure it succeeds
const receipt = await publicClient.waitForTransactionReceipt({ hash });
if (receipt.status !== "success") {
  throw new Error("Transaction failed");
}

import {
  zoraTimedSaleStrategyABI,
  zoraTimedSaleStrategyAddress,
  commentsABI,
  commentsAddress,
  emptyCommentIdentifier,
  sparkValue,
} from "@zoralabs/protocol-deployments";
 
import {
  publicClient,
  walletClient,
  chainId,
  smartWalletOwner,
  contractAddress1155,
  tokenId1155,
  bundlerClient,
  smartWalletAccount,
} from "./config";
 
import { zeroAddress } from "viem";
 
// 1. Mint as the smart wallet
 
// fist perform the mint as the smart wallet via the bundler,  making the
// smart wallet the owner of the token; we simulate it first.
const userOperationResponse = await bundlerClient.prepareUserOperation({
  account: smartWalletAccount,
  calls: [
    {
      abi: zoraTimedSaleStrategyABI,
      to: zoraTimedSaleStrategyAddress[chainId],
      functionName: "mint",
      args: [
        smartWalletAccount.address,
        1n,
        contractAddress1155,
        tokenId1155,
        zeroAddress,
        "0",
      ],
    },
  ],
});
 
// send the user operation with the bundler
const hash = await bundlerClient.sendUserOperation(userOperationResponse);
// ensure the user operation is accepted
const mintReceipt = await bundlerClient.waitForUserOperationReceipt({ hash });
if (!mintReceipt.success) {
  throw new Error("Mint failed");
}
 
// 2. Comment as the smart wallet owner
 
// We comment as an owner of the smart wallet.  The contract allows for commenting
// when a smart wallet owned by an account is the owner of the token.
 
const referrer = zeroAddress;
 
// now perform the comment as a smart wallet owner
const commentHash = await walletClient.writeContract({
  abi: commentsABI,
  address: commentsAddress[chainId],
  functionName: "comment",
  args: [
    // commenter account is an account that owns the smart wallet
    smartWalletOwner.address, 
    contractAddress1155,
    tokenId1155,
    "This is a test reply",
    // when replying to a comment, we must pass the comment identifier of the comment we are replying to
    emptyCommentIdentifier(),
    // we set the smart wallet parameter.  the smart wallet can be checked to see if it is the owner of the token
    smartWalletAccount.address, 
    referrer,
  ],
  account: smartWalletOwner, 
  value: sparkValue(),
});
 
const receipt = await publicClient.waitForTransactionReceipt({
  hash: commentHash,
});
if (receipt.status !== "success") {
  throw new Error("Transaction failed");
}

import {
  commentsABI,
  commentsAddress,
  emptyCommentIdentifier,
  permitCommentTypedDataDefinition,
  PermitComment,
  sparkValue,
} from "@zoralabs/protocol-deployments";
import { getClient } from "@reservoir0x/relay-sdk";
import { zeroAddress, keccak256, toBytes, encodeFunctionData } from "viem";
import { base, zora } from "viem/chains";
import {
  walletClient,
  chainId,
  commenterAccount,
  contractAddress1155,
  tokenId1155,
} from "./config";
 
// 1. Create and sign a cross-chain permit comment.
 
// Calculate a timestamp 30 seconds from now
const thirtySecondsFromNow =
  BigInt(Math.round(new Date().getTime() / 1000)) + 30n;
// Generate a random nonce
const randomNonce = () => keccak256(toBytes(Math.round(Math.random() * 1000)));
 
// Get the comments contract address for the current chain
const commentsContractAddress = commentsAddress[chainId];
 
// Define the permit comment object
const permitComment: PermitComment = {
  sourceChainId: base.id, // The chain where the transaction originates (Base)
  destinationChainId: zora.id, // The chain where the comment will be stored (Zora)
  contractAddress: contractAddress1155, // The address of the 1155 contract
  tokenId: tokenId1155, // The 1155 token ID being commented on
  commenter: commenterAccount, // The account making the comment.
  text: "hello world", // The content of the comment
  deadline: thirtySecondsFromNow,
  nonce: randomNonce(),
  referrer: zeroAddress, // No referrer in this case
  commenterSmartWallet: zeroAddress, // Not using a smart wallet for commenting
  replyTo: emptyCommentIdentifier(), // This is not a reply to another comment
};
 
// Generate the typed data for the permit comment using the helper
// method from @zoralabs/protocol-deployments
const permitCommentTypedData = permitCommentTypedDataDefinition(permitComment);
 
// Sign the permit
const permitCommentSignature = await walletClient.signTypedData(
  permitCommentTypedData,
);
 
// 2. Execute the cross-chain transaction with relay
 
// Initialize the relay client
const relayClient = getClient();
 
// Get a quote from relay for the cross-chain transaction
const quote = await relayClient.actions.getQuote({
  wallet: walletClient,
  chainId: permitComment.sourceChainId, // The origin chain (Base)
  toChainId: permitComment.destinationChainId, // The destination chain (Zora)
  amount: sparkValue().toString(), // The value to send to the comments contract on the destination chain
  tradeType: "EXACT_OUTPUT",
  currency: zeroAddress, // ETH
  toCurrency: zeroAddress, // ETH
  txs: [
    {
      to: commentsContractAddress,
      value: sparkValue().toString(),
      // we will call permitComment on the destination chain
      data: encodeFunctionData({
        abi: commentsABI,
        functionName: "permitComment",
        args: [permitComment, permitCommentSignature],
      }),
    },
  ],
});
 
// Execute the cross-chain transaction
await relayClient.actions.execute({
  quote,
  wallet: walletClient, // The wallet initiating the transaction
});

import {
  commentsABI,
  commentsAddress,
  PermitSparkComment,
  sparkValue,
  permitSparkCommentTypedDataDefinition,
} from "@zoralabs/protocol-deployments";
import { getClient } from "@reservoir0x/relay-sdk";
import { zeroAddress, keccak256, toBytes, encodeFunctionData } from "viem";
import { base, zora } from "viem/chains";
import { walletClient, chainId, sparkerAccount } from "./config";
import { commentIdentifier } from "./comment";
 
// 1. Create and sign a cross-chain permit spark comment.
 
// Calculate a timestamp 30 seconds from now
const thirtySecondsFromNow =
  BigInt(Math.round(new Date().getTime() / 1000)) + 30n;
// Generate a random nonce
const randomNonce = () => keccak256(toBytes(Math.round(Math.random() * 1000)));
 
// Get the comments contract address for the current chain
const commentsContractAddress = commentsAddress[chainId];
 
// Define the number of sparks to add
const sparksQuantity = 3n;
 
// Define the permit spark comment object
const permitSparkComment: PermitSparkComment = {
  comment: commentIdentifier, // The comment to spark
  deadline: thirtySecondsFromNow,
  nonce: randomNonce(),
  sparker: sparkerAccount, // The account sparking the comment
  sparksQuantity: sparksQuantity, // The number of sparks to add
  sourceChainId: base.id, // The chain where the transaction originates (Base)
  destinationChainId: zora.id, // The chain where the spark will be stored (Zora)
  referrer: zeroAddress, // No referrer in this case
};
 
// Generate the typed data for the permit spark comment using the helper
// method from @zoralabs/protocol-deployments
const permitSparkCommentTypedData =
  permitSparkCommentTypedDataDefinition(permitSparkComment);
 
// Sign the permit
const permitSparkCommentSignature = await walletClient.signTypedData(
  permitSparkCommentTypedData,
);
 
// 2. Execute the cross-chain transaction with relay
 
// Initialize the relay client
const relayClient = getClient();
 
// Get a quote from relay for the cross-chain transaction
const quote = await relayClient.actions.getQuote({
  wallet: walletClient,
  chainId: permitSparkComment.sourceChainId, // The origin chain (Base)
  toChainId: permitSparkComment.destinationChainId, // The destination chain (Zora)
  amount: (sparkValue() * sparksQuantity).toString(), // The total value to send to the comments contract on the destination chain
  tradeType: "EXACT_OUTPUT",
  currency: zeroAddress, // ETH
  toCurrency: zeroAddress, // ETH
  txs: [
    {
      to: commentsContractAddress,
      value: sparkValue().toString(),
      // We will call permitSparkComment on the destination chain
      data: encodeFunctionData({
        abi: commentsABI,
        functionName: "permitSparkComment",
        args: [permitSparkComment, permitSparkCommentSignature],
      }),
    },
  ],
});
 
// Execute the cross-chain transaction
await relayClient.actions.execute({
  quote,
  wallet: walletClient, // The wallet initiating the transaction
});

import {
  callerAndCommenterAddress,
  callerAndCommenterABI,
  permitMintAndCommentTypedDataDefinition,
  PermitMintAndComment,
} from "@zoralabs/protocol-deployments";
import { getClient } from "@reservoir0x/relay-sdk";
import {
  zeroAddress,
  keccak256,
  toBytes,
  encodeFunctionData,
  parseEther,
} from "viem";
import { base, zora } from "viem/chains";
import {
  walletClient,
  minterAccount,
  contractAddress1155,
  tokenId1155,
} from "./config";
 
// 1. Create and sign a cross-chain permit mint and comment.
 
// Calculate a timestamp 30 seconds from now
const thirtySecondsFromNow =
  BigInt(Math.round(new Date().getTime() / 1000)) + 30n;
// Generate a random nonce
const randomNonce = () => keccak256(toBytes(Math.round(Math.random() * 1000)));
 
// Define the number of 1155 tokens to mint
const quantityToMint = 3n;
 
// Define the permit mint and comment object
const permit: PermitMintAndComment = {
  commenter: minterAccount,
  comment: "This is a test comment",
  deadline: thirtySecondsFromNow,
  mintReferral: zeroAddress, // No mint referral in this case
  quantity: quantityToMint,
  collection: contractAddress1155,
  tokenId: tokenId1155,
  nonce: randomNonce(),
  sourceChainId: base.id, // The chain where the transaction originates (Base)
  destinationChainId: zora.id, // The chain where the mint and comment will be executed (Zora)
};
 
// Generate the typed data for the permit mint and comment using the helper
// method from @zoralabs/protocol-deployments
const typedData = permitMintAndCommentTypedDataDefinition(permit);
 
// Sign the permit
const signature = await walletClient.signTypedData(typedData);
 
const mintFee = parseEther("0.000111");
 
// 2. Execute the cross-chain transaction with relay
 
// Initialize the relay client
const relayClient = getClient();
 
// Value to send to the CallerAndCommenter contract on the destination chain
// is the mint fee multiplied by the quantity of tokens to mint
const valueToSend = mintFee * quantityToMint;
 
// Get a quote from relay for the cross-chain transaction
const quote = await relayClient.actions.getQuote({
  wallet: walletClient,
  chainId: permit.sourceChainId, // The origin chain (Base)
  toChainId: permit.destinationChainId, // The destination chain (Zora)
  amount: valueToSend.toString(), // The total value to send to the CallerAndCommenter contract on the destination chain
  tradeType: "EXACT_OUTPUT",
  currency: zeroAddress, // ETH
  toCurrency: zeroAddress, // ETH
  txs: [
    {
      to: callerAndCommenterAddress[
        permit.destinationChainId as keyof typeof callerAndCommenterAddress
      ],
      value: valueToSend.toString(),
      // We will call permitTimedSaleMintAndComment on the destination chain
      data: encodeFunctionData({
        abi: callerAndCommenterABI,
        functionName: "permitTimedSaleMintAndComment",
        args: [permit, signature],
      }),
    },
  ],
});
 
// Execute the cross-chain transaction
await relayClient.actions.execute({
  quote,
  wallet: walletClient, // The wallet initiating the transaction
});