Environments and RPCs

import { TaskContext, Chain } from "compose";

export async function main({ evm }: TaskContext) {
  // This is a local-only private key I've funded on my test chain (thus safe to hard code)
  // For private keys used on mainnets and testnets, always use Secrets
  const privateKey = "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";

  const wallet = await evm.wallet({ privateKey });

  const localChain: Chain = {
    id: 0,
    name: "foundry-local",
    testnet: true,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }, // this is the url used by your local Anvil (etc) node
      public:  { http: ["http://127.0.0.1:8545"] },
    },
    blockExplorers: {
      default: { name: "na", url: "http://127.0.0.1:8545" }, // not used for local dev, so you can pass in any value here
    },
  };

  const localContractAddress = "0x1234567890abcdef1234567890abcdef12345678" as `0x${string}`;
  const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
  const payouts = [1000n, 2000n, 3000n];

  const { hash } = await wallet.writeContract(
    localChain,
    localContractAddress,
    "reportPayouts(bytes32,uint256[])",
    [resultId, payouts],
    { 
      confirmations: 3,
    }
  );
}

name: "my_app"
env: # since we're only specifying a local version of the RPC_URL env var, it'll be undefined when deployed to cloud
  local:
    # This is a local-only private key I've funded on my test chain (thus safe to hard code)
    # For private keys used on mainnets and testnets, always use Secrets
    PRIVATE_KEY: "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
    RPC_URL: "http://127.0.0.1:8545"
    CONTRACT_ADDRESS: "0x67206e6E82FA1b11fd8C545Ad3422dBb1444E53C" # we can update this as we iterate on the contract locally
  cloud:
    CONTRACT_ADDRESS: "0x1234567890abcdef1234567890abcdef12345678" # we can update this when we deploy our contract to mainnet
tasks:
  - name: "bitcoin_oracle"
    path: "./src/tasks/bitcoin_oracle.ts"
    triggers:
      - type: "cron"
        expression: "* * * * *"

import { TaskContext } from "compose";

export async function main({ evm, env }: TaskContext) {
  // private key will be undefined in cloud (since env var isn't set for cloud) and the wallet will default to our auto-funded smart wallets
  // however you can use a mainnet private key if you want by saving it as a secret, see wallet docs for more info
  const wallet = await evm.wallet({ privateKey: env.PRIVATE_KEY });

  const chain = {
    ...evm.chains.base,
  };

  // override the chain's RPC only if the env var is set
  if (env.RPC_URL) {
    chain.rpcUrls = {
      default: { http: [env.RPC_URL] }, // this is the url used by your local Anvil (etc) node
      public:  { http: [env.RPC_URL] },
    };
  }

  const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
  const payouts = [1000n, 2000n, 3000n];

  const { hash } = await wallet.writeContract(
    chain,
    env.CONTRACT_ADDRESS as `0x${string}`, // use the env var for the contract address which we'll update as we iterate
    "reportPayouts(bytes32,uint256[])",
    [resultId, payouts],
    { 
      confirmations: 3,
    }
  );
}

import { TaskContext } from "compose";

export async function main({ evm }: TaskContext) {
  // we'll auto-fund all smart wallets in forking mode so you can simulate gas sponsoring in prod
  const wallet = await evm.wallet({ name: "my-smart-wallet" });

  const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
  const payouts = [1000n, 2000n, 3000n];

  const { hash } = await wallet.writeContract(
    // when you run compose with the --fork-chains flag we'll make a fork of base at the time of running the app and we'll clone all your existing contract state
    // when you deploy this to cloud, it'll run against the actual base mainnet, thus you don't need any special dev code when testing locally with forking
    evm.chains.base,
    "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as `0x${string}`,
    "reportPayouts(bytes32,uint256[])",
    [resultId, payouts],
    { 
      confirmations: 3,
    }
  );
}

name: "my_app"
secrets:
  # set these with "goldsky compose secret set <NAME> --value <VALUE>" prior to deploying, see secrets docs for more info
  - PROD_FUNDING_WALLET
  - ALCHEMY_TOKEN
env:
  local:
    ALCHEMY_BASEURL: "https://base-testnet.g.alchemy.com/v2/"
  cloud:
    ALCHEMY_BASEURL: "https://base-mainnet.g.alchemy.com/v2/"
tasks:
  - name: "bitcoin_oracle"
    path: "./src/tasks/bitcoin_oracle.ts"
    triggers:
      - type: "cron"
        expression: "* * * * *"

import { TaskContext } from "compose";

export async function main({ evm, env }: TaskContext) {
  // env.PROD_FUNDING_WALLET was populated via the secrets reference in the manifest
  const wallet = await evm.wallet({ privateKey: env.PROD_FUNDING_WALLET });

  const chain = {
    ...evm.chains.base,
    rpcUrls: {
      default: { http: [`${env.ALCHEMY_BASEURL}${env.ALCHEMY_TOKEN}`] },
      public: { http: [`${env.ALCHEMY_BASEURL}${env.ALCHEMY_TOKEN}`] },
    },
  };

  const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
  const payouts = [1000n, 2000n, 3000n];

  const { hash } = await wallet.writeContract(
    chain,
    "0x1234567890abcdef1234567890abcdef12345678" as `0x${string}`,
    "reportPayouts(bytes32,uint256[])",
    [resultId, payouts],
    {
      confirmations: 3,
    }
  );
}

name: "my_app"
env:
  local:
    API_BASE: "http://localhost:4001"
  cloud:
    API_BASE: "https://api.mydomain.com"
tasks:
  - name: "bitcoin_oracle"
    path: "./src/tasks/bitcoin_oracle.ts"
    triggers:
      - type: "cron"
        expression: "* * * * *"

import { TaskContext } from "compose";

export async function main({ env, fetch }: TaskContext) {
  const apiEndpoint = `${env.API_BASE}/some/endpoint`;

  const resp = await fetch(apiEndpoint);
}