Function Templates

Here are some common function templates you can use as starting points for your Stratus functions. Simply copy the code and replace the placeholder values with your specific parameters.

Smart Contract Interaction

This function listens to transaction entries and mints/burns tokens based on account balance changes.

const { encodeFunctionData } = require("viem");

module.exports.handler = async (input, output) => {
  let operations = [];

  // Parse input if it's a string
  if (typeof input === "string") {
    try {
      let parsed = JSON.parse(input);
      if (typeof parsed === "string") {
        parsed = JSON.parse(parsed);
      }
      input = parsed;
    } catch (err) {
      output.setResult({
        message: "Invalid JSON input",
        error: err,
        input: input,
        operations,
      });
      return output.buildOutput();
    }
  }

  if (!Array.isArray(input)) {
    output.setResult({
      message: "Expected input to be an array of events",
      input: input,
      operations,
    });
    return output.buildOutput();
  }

  // Replace with your contract address
  const ERC20_CONTRACT_ADDRESS = "YOUR_CONTRACT_ADDRESS";

  const mintABI = [
    {
      inputs: [
        { internalType: "address", name: "to", type: "address" },
        { internalType: "uint256", name: "amount", type: "uint256" },
      ],
      name: "mint",
      outputs: [],
      stateMutability: "nonpayable",
      type: "function",
    },
  ];

  const burnABI = [
    {
      inputs: [
        { internalType: "address", name: "from", type: "address" },
        { internalType: "uint256", name: "amount", type: "uint256" },
      ],
      name: "burn",
      outputs: [],
      stateMutability: "nonpayable",
      type: "function",
    },
  ];

  try {
    for (const event of input) {
      if (!event.data) continue;

      const dataItem = event.data;
      const tokenAmount = BigInt(dataItem.amount) * (BigInt(10) ** BigInt(18));

      // Replace with your loyalty currency ID
      if (dataItem.loyaltyCurrencyId !== "YOUR_LOYALTY_CURRENCY_ID") {
        continue;
      }

      let operationType = null;
      if (dataItem.direction === "credit") {
        operationType = "mint";
      } else if (dataItem.direction === "debit") {
        operationType = "burn";
      } else {
        continue;
      }

      const walletAddress = dataItem.loyaltyAccount?.user?.walletAddress;
      if (!walletAddress) continue;

      let data;
      if (operationType === "mint") {
        data = encodeFunctionData({
          abi: mintABI,
          functionName: "mint",
          args: [walletAddress, tokenAmount.toString()],
        });
      } else if (operationType === "burn") {
        data = encodeFunctionData({
          abi: burnABI,
          functionName: "burn",
          args: [walletAddress, tokenAmount.toString()],
        });
      }

      output.addTransaction({
        to: ERC20_CONTRACT_ADDRESS,
        data: data,
        value: "0x0",
      });
    }

    output.setResult({
      message: "Token transactions created.",
      operations,
    });

    return output.buildOutput();
  } catch (error) {
    console.error("Error in user code:", error);
    throw error;
  }
};

Bridge Rewards

This function rewards users for bridging assets, using Chainlink price feeds and Redis for rate limiting.

const { createPublicClient, http } = require('viem');
const { mainnet } = require('viem/chains');
const { Redis } = require("ioredis");
const axios = require('axios');

const MULTIPLIER = 1; // Adjust reward multiplier
const LOYALTY_RULE_ID = "YOUR_LOYALTY_RULE_ID";
const REDIS_URL = "YOUR_REDIS_URL";

const redis = new Redis(REDIS_URL);
const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

// Chainlink ETH/USD Price Feed
const aggregatorAddress = '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419';
const aggregatorAbi = [
  {
    inputs: [],
    name: 'decimals',
    outputs: [{ internalType: 'uint8', name: '', type: 'uint8' }],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [],
    name: 'latestRoundData',
    outputs: [
      { internalType: 'uint80', name: 'roundId', type: 'uint80' },
      { internalType: 'int256', name: 'answer', type: 'int256' },
      { internalType: 'uint256', name: 'startedAt', type: 'uint256' },
      { internalType: 'uint256', name: 'updatedAt', type: 'uint256' },
      { internalType: 'uint80', name: 'answeredInRound', type: 'uint80' },
    ],
    stateMutability: 'view',
    type: 'function',
  },
];

function applyPointsFormula(x) {
  return Math.pow(2, Math.log10(x) - 1);
}

async function getEthUsdPriceNow() {
  const latestRoundData = await client.readContract({
    address: aggregatorAddress,
    abi: aggregatorAbi,
    functionName: 'latestRoundData',
  });
  const decimals = await client.readContract({
    address: aggregatorAddress,
    abi: aggregatorAbi,
    functionName: 'decimals',
  });
  const [, answer] = latestRoundData;
  return Number(answer) / 10 ** Number(decimals);
}

module.exports.handler = async (input, output) => {
  try {
    if (typeof input === 'string') {
      let parsed = JSON.parse(input);
      if (typeof parsed === 'string') {
        parsed = JSON.parse(parsed);
      }
      input = parsed;
    }

    if (!Array.isArray(input) || input.length === 0) {
      output.setResult({ message: 'No event data provided', input });
      return output.buildOutput();
    }

    const event = input[0];
    if (!event.decodedEvent || !event.decodedEvent.args) {
      throw new Error('Event data missing decodedEvent.args');
    }

    const amountWei = event.decodedEvent.args.amount;
    const bridgedEth = Number(amountWei) / 1e18;
    const ethPrice = await getEthUsdPriceNow();
    const dollarValue = bridgedEth * ethPrice;
    const recipientWallet = event.decodedEvent.args.to;

    // Redis rate limiting logic
    const redisKey = `${recipientWallet}-bridge`;
    let storedPointsStr = await redis.get(redisKey);
    let storedPoints = storedPointsStr ? parseInt(storedPointsStr, 10) : 0;

    let rawPoints = Math.round((dollarValue + storedPoints) * MULTIPLIER);
    let computedPoints = Math.round(applyPointsFormula(rawPoints));
    let pointsToAward = computedPoints - storedPoints;

    if (pointsToAward < 0) pointsToAward = 0;

    if (storedPointsStr === null) {
      await redis.set(redisKey, pointsToAward, 'EX', 86400);
    } else {
      await redis.incrby(redisKey, pointsToAward);
    }

    // Complete loyalty rule
    await completeLoyaltyRule(LOYALTY_RULE_ID, pointsToAward, recipientWallet);

    output.setResult({
      message: `User ${recipientWallet} given ${pointsToAward} points`,
      bridgedEth,
      ethPrice,
      computedPoints,
    });
    return output.buildOutput();
  } catch (error) {
    console.error("Error in user code:", error);
    output.setError(error.message);
    return output.buildOutput();
  }
};

DEX Trading Rewards

This function tracks and rewards users based on their trading volume, using Redis for persistence.

const { Redis } = require("ioredis");
const axios = require('axios');

const LOYALTY_RULE_ID = "YOUR_LOYALTY_RULE_ID";
const REDIS_URL = "YOUR_REDIS_URL";
const VOLUME_THRESHOLD = 10; // $10 USD threshold

const redis = new Redis(REDIS_URL);

module.exports.handler = async (input, output) => {
  const operations = [];
  try {
    operations.push("Starting handler execution: parsing input");
    if (typeof input === 'string') {
      let parsed = JSON.parse(input);
      if (typeof parsed === 'string') parsed = JSON.parse(parsed);
      input = parsed;
    }

    if (!Array.isArray(input) || input.length === 0) {
      output.setResult({ message: 'No event data provided', input, operations });
      return output.buildOutput();
    }
    
    const event = input[0];
    if (!event.decodedEvent || !event.decodedEvent.args) {
      throw new Error('Event data missing decodedEvent.args');
    }
    const args = event.decodedEvent.args;

    // Process swap events (assuming token0 is USDC with 6 decimals)
    if (args.hasOwnProperty('amount0')) {
      const { sender, amount0 } = args;
      const traderWallet = sender;
      const tradeDollarValue = Math.abs(Number(amount0)) / 1e6;

      const redisVolumeKey = `${traderWallet}-swapVolume`;
      const redisRewardedKey = `${traderWallet}-swapRewarded`;

      const alreadyRewarded = await redis.get(redisRewardedKey);
      if (alreadyRewarded) {
        output.setResult({ 
          message: `User ${traderWallet} has already been rewarded for swap volume.`, 
          operations 
        });
        return output.buildOutput();
      }

      const storedVolumeStr = await redis.get(redisVolumeKey);
      const storedVolume = storedVolumeStr ? parseFloat(storedVolumeStr) : 0;
      const newVolume = storedVolume + tradeDollarValue;

      await redis.set(redisVolumeKey, newVolume.toString());

      if (storedVolume < VOLUME_THRESHOLD && newVolume >= VOLUME_THRESHOLD) {
        // Complete loyalty rule when threshold is reached
        await completeLoyaltyRule(LOYALTY_RULE_ID, traderWallet);
        await redis.set(redisRewardedKey, "true");
        
        output.setResult({
          message: `User ${traderWallet} rewarded for reaching $${VOLUME_THRESHOLD} swap volume.`,
          cumulativeSwapVolume: newVolume,
          operations
        });
        return output.buildOutput();
      }

      output.setResult({
        message: `User ${traderWallet} cumulative swap volume updated to $${newVolume.toFixed(2)}.`,
        cumulativeSwapVolume: newVolume,
        operations
      });
      return output.buildOutput();
    }

    output.setResult({ message: 'Unknown event type', operations });
    return output.buildOutput();
  } catch (error) {
    operations.push(`Error encountered: ${error.message}`);
    console.error("Error in handler:", error);
    output.setError(error.message);
    output.setResult({ operations });
    return output.buildOutput();
  }
};

Usage Notes

Replace placeholder values (marked with YOUR_*) with your specific parameters
Update Redis URLs with your instance details
Adjust reward multipliers and thresholds as needed
Test thoroughly in development before deploying to production

Remember to handle your API keys and sensitive data securely. Never commit them directly in your code.

Common Parameters to Replace

LOYALTY_RULE_ID: Your specific loyalty rule identifier
REDIS_URL: Your Redis instance connection string
ERC20_CONTRACT_ADDRESS: The address of your token contract
VOLUME_THRESHOLD: Minimum volume required for rewards
MULTIPLIER: Reward calculation multiplier

These templates are starting points. You should modify them based on your specific requirements and add appropriate error handling.

Introduction

Loyalty

Stratus

Marketplace

Function Templates

Function Templates

Smart Contract Interaction

Bridge Rewards

DEX Trading Rewards

Usage Notes

Common Parameters to Replace

Introduction

Loyalty

Stratus

Marketplace

​Function Templates

​Smart Contract Interaction

​Bridge Rewards

​DEX Trading Rewards

​Usage Notes

​Common Parameters to Replace

Function Templates

Smart Contract Interaction

Bridge Rewards

DEX Trading Rewards

Usage Notes

Common Parameters to Replace