In this tutorial, we will explore how to use deBridge to perform cross-chain royalty payments. For this tutorial specifically, we’ll pay an IP Asset on Story using Base $ETH. From a high level, it involves:
  1. Constructing a deBridge API call that will return tx data to swap tokens across chains and perform some action (e.g. pay royalty to an IP Asset on Story)
  2. Executing the API call to receive that tx data
  3. Executing the transaction (using the returned tx data) on the source chain
Cross-Chain Royalty Payments

​
Step 1: Constructing the deBridge API Call

The first step is to construct a deBridge API call. The purpose of this API call is to receive back a response that will contain transaction data so we can then execute it on the source chain. This deBridge order swaps tokens from one chain to another. We can also optionally attach a dlnHook that will execute an arbitrary action upon order completion (ex. after $ETH has been swapped for $WIP). This is where the magic happens.
You can learn more about dlnHooks here.
In this case, the dlnHook will be a call to payRoyaltyOnBehalf, which is a function in this contract that pays royalties to an IP Asset on Story. You may be wondering, “where does the Royalty Module (the contract spending the tokens on Story) get approved to spend the $WIP?” The answer is that deBridge automatically handles token approvals for you using their IExternalCallExecutor, where it approves the target address to spend the tokens on the destination chain. In this case because the target address is the Royalty Module itself, token approval is handled for us without having to create a custom multicall contract like we do in the cross-chain license minting tutorial.
You can learn more about the IExternalCallExecutor here.
To summarize, we will construct a deBridge API call that says “we want to swap $ETH for $IP, then use a dlnHook to call a smart contract on Story that pays royalties to an IP Asset on Story”.

​
Step 1a. Constructing the dlnHook

The dlnHook is a JSON object that will be attached to the deBridge API call. It will contain the following information:
  • The type of action to execute (evm_transaction_call)
  • The address of the contract to call (RoyaltyModule.sol)
  • The calldata to execute (payRoyaltyOnBehalf)
main.ts
const ROYALTY_MODULE =
  "0xD2f60c40fEbccf6311f8B47c4f2Ec6b040400086";

// Build the dlnHook for Story royalty payment
const buildRoyaltyPaymentHook = ({ ipId: `0x${string}`, amount: bigint }): string => {
  // Encode the payRoyaltyOnBehalf function call
  const calldata = encodeFunctionData({
    abi: [
      {
        name: "payRoyaltyOnBehalf",
        type: "function",
        inputs: [
          { name: "receiverIpId", type: "address" },
          { name: "payerIpId", type: "address" },
          { name: "token", type: "address" },
          { name: "amount", type: "uint256" },
        ],
      },
    ],
    functionName: "payRoyaltyOnBehalf",
    args: [
      ipId,
      zeroAddress, // because it's not coming from another IP Asset. It's coming from an external address.
      WIP_TOKEN_ADDRESS,
      amount,
    ],
  });

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

  return JSON.stringify(dlnHook);
};

​
Step 1b. Constructing the deBridge API Call

Now that we have the dlnHook, we can construct the whole deBridge API call, including the dlnHook.
You can view deBridge’s documentation on the create-tx endpoint here. I also highly recommend checking out the Swagger UI for the create-tx endpoint as well.
AttributeDescription
srcChainIdThe ID of the source blockchain (e.g., Ethereum mainnet is 1).
srcChainTokenInThe address of the token being swapped on the source chain (ETH in this case).
srcChainTokenInAmountThe amount of the source token to swap, set to auto for automatic calculation.
dstChainIdThe ID of the destination blockchain (e.g., Story mainnet is 100000013).
dstChainTokenOutThe address of the token to receive on the destination chain (WIP token).
dstChainTokenOutAmountThe amount of the destination token to receive. It should be the same as the amount we’re paying in payRoyaltyOnBehalf in step 1a.
dstChainTokenOutRecipientThis can just be the same as senderAddress.
senderAddressThe address initiating the transaction.
srcChainOrderAuthorityAddressThe address authorized to manage the order on the source chain. This can just be the same as senderAddress.
dstChainOrderAuthorityAddressThe address authorized to manage the order on the destination chain. This can just be the same as senderAddress.
enableEstimateA flag to enable transaction simulation and estimation.
prependOperatingExpensesA flag to include operating expenses in the transaction.
dlnHookThe URL-encoded hook that specifies additional actions to execute post-swap.
main.ts
import { base } from "viem/chains";
import { WIP_TOKEN_ADDRESS } from "@story-protocol/core-sdk";

// ... previous code here ...

// Build deBridge API URL for cross-chain royalty payment
const buildDeBridgeApiUrl = ({
  ipId: `0x${string}`,
  senderAddress: `0x${string}`,
  paymentAmount: string // should be in wei
}): string => {
  const dlnHook = buildRoyaltyPaymentHook({ ipId, paymentAmount });
  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=${WIP_TOKEN_ADDRESS}` +
    // we set the amount of $IP to pay for the payment on Story
    `&dstChainTokenOutAmount=${paymentAmount}` +
    // the address of the contract that will pay the royalty 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;
};

​
Step 2: Executing the API Call

Once the API call is constructed, execute it to receive a response. This response includes transaction data and an estimate for running the transaction on the source swap chain (e.g., Ethereum, Solana). 
// ... previous code here ...

const getDeBridgeTransactionData = async ({
  ipId: `0x${string}`,
  senderAddress: `0x${string}`,
  paymentAmount: string // should be in wei
}): Promise<DeBridgeApiResponse> => {
  try {
    const apiUrl = buildDeBridgeApiUrl({ ipId, senderAddress, paymentAmount });

    const response = await fetch(apiUrl, {
      method: "GET",
      headers: {
        Accept: "application/json",
      },
    });

    if (!response.ok) {
      throw new Error(
        `deBridge API error: ${response.status} ${response.statusText}`
      );
    }

    const data = (await response.json()) as DeBridgeApiResponse;

    // Validate the response
    if (!data.tx || !data.estimation || !data.orderId) {
      throw new Error("Invalid deBridge API response: missing required fields");
    }

    return data;
  } catch (error) {
    console.error("Error calling deBridge API:", error);
    throw error;
  }
};

​
Step 3: Executing the Transaction on the Source Chain

Next, you would take the API response and execute the transaction on the source chain.
View the docs here on submitting the transaction, including how this would be done differently on Solana.
TypeScript
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}`;
  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",
  senderAddress: account.address,
  paymentAmount: parseEther("5"), // 5 $WIP
};

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

​
Conclusion

Congratulations! You have successfully set up cross-chain royalty payments using deBridge.