Cross-Chain License Minting

const STORY_WRAP_THEN_LICENSE_MULTICALL =
  "0x6429a616f76a8958e918145d64bf7681c3936d6a";

// Build the dlnHook for Story royalty payment
const buildRoyaltyPaymentHook = ({ ipId: `0x${string}`, licenseTermsId: bigint, receiverAddress: `0x${string}` }): string => {
  // Encode the mintLicenseTokensCrossChain function call
  const calldata = encodeFunctionData({
    abi: [
      {
        name: "mintLicenseTokensCrossChain",
        type: "function",
        inputs: [
          { name: "licensorIpId", type: "address" },
          { name: "licenseTermsId", type: "uint256" },
          { name: "tokenAmount", type: "uint256" },
          { name: "receiver", type: "address" },
        ],
      },
    ],
    functionName: "mintLicenseTokensCrossChain",
    args: [
      ipId,
      licenseTermsId,
      BigInt(1),
      receiverAddress,
    ],
  });

  // Build the dlnHook JSON
  const dlnHook = {
    type: "evm_transaction_call",
    data: {
      to: STORY_WRAP_THEN_LICENSE_MULTICALL,
      calldata: calldata,
      gas: 0,
    },
  };

  return JSON.stringify(dlnHook);
};

import { base } from "viem/chains";

// ... previous code here ...

// Build deBridge API URL for cross-chain royalty payment
const buildDeBridgeApiUrl = ({
  ipId: `0x${string}`,
  licenseTermsId: bigint,
  receiverAddress: `0x${string}`,
  senderAddress: `0x${string}`,
  paymentAmount: string // should be in wei
}): string => {
  const dlnHook = buildRoyaltyPaymentHook({ ipId, licenseTermsId, receiverAddress });
  const encodedHook = encodeURIComponent(dlnHook);
  const url =
    `https://dln.debridge.finance/v1.0/dln/order/create-tx?` +
    `srcChainId=${base.id}` +
    // we make this zero address which represents the native token ($ETH)
    `&srcChainTokenIn=0x0000000000000000000000000000000000000000` +
    // we set this to auto which will automatically calculate the amount of $ETH to swap
    `&srcChainTokenInAmount=auto` +
    // Story's mainnet chain ID
    `&dstChainId=100000013` +
    // we make this zero address which represents the native token ($IP)
    `&dstChainTokenOut=0x0000000000000000000000000000000000000000` +
    // we set the amount of $IP to pay for the license on Story
    `&dstChainTokenOutAmount=${paymentAmount}` +
    // the address of the contract that will wrap the $IP and mint the license on Story
    `&dstChainTokenOutRecipient=${senderAddress}` +
    // the address of the user initiating the transaction
    `&senderAddress=${senderAddress}` +
    // the address authorized to manage the order on the source chain
    `&srcChainOrderAuthorityAddress=${senderAddress}` +
    // the address authorized to manage the order on the destination chain
    `&dstChainOrderAuthorityAddress=${senderAddress}` +
    // we set this to true to enable transaction simulation and estimation
    `&enableEstimate=true` +
    // we set this to true to include operating expenses in the transaction
    `&prependOperatingExpenses=true` +
    `&dlnHook=${encodedHook}`;

  return url;
};

import { base } from "viem/chains";
import { createWalletClient, http, WalletClient, parseEther } from "viem";
import { privateKeyToAccount, Address, Account } from "viem/accounts";
import dotenv from "dotenv";

dotenv.config();

// Validate environment variables
if (!process.env.WALLET_PRIVATE_KEY) {
  throw new Error("WALLET_PRIVATE_KEY is required in .env file");
}

// Create account from private key
const account: Account = privateKeyToAccount(
  `0x${process.env.WALLET_PRIVATE_KEY}` as Address
);

// Initialize the wallet client
const walletClient = createWalletClient({
  chain: base,
  transport: http("https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID"), // Use Infura or another Ethereum provider
  account,
}) as WalletClient;

// ... previous code here ...

// Function to send a transaction
const executeLicenseMint = async (params: {
  ipId: `0x${string}`;
  licenseTermsId: bigint;
  receiverAddress: `0x${string}`;
  senderAddress: `0x${string}`;
  paymentAmount: string; // should be in wei
}) => {
  // Get transaction data from deBridge
  const deBridgeResponse = await getDeBridgeTransactionData(params);

  try {
    // Execute the transaction using the user's wallet
    const txHash = await walletClient.sendTransaction({
      to: deBridgeResponse.tx.to as Address,
      data: deBridgeResponse.tx.data as Address,
      value: BigInt(deBridgeResponse.tx.value),
      account: account as Account,
      chain: base,
    });
    console.log("Transaction sent:", txHash);

    // Wait for the transaction to be mined
    const receipt = await walletClient.waitForTransactionReceipt(txHash);
    console.log("Transaction mined:", receipt.transactionHash);
  } catch (error) {
    console.error("Error sending transaction:", error);
  }
};

// Example usage with a mock API response
const params = {
  ipId: "0xcb6B9CCae4108A103097B30cFc25e1E257D4b5Fe",
  licenseTermsId: BigInt(27910),
  receiverAddress: "0x01", // replace with the address that should receive the license on Story
  senderAddress: account.address,
  paymentAmount: parseEther("0.00001"), // 0.00001 $WIP since the license on Story costs 0.00001 $WIP
};

// Execute the function to send the transaction
executeLicenseMint(params);