Writing to snapchain

import {
  ID_GATEWAY_ADDRESS,
  idGatewayABI,
  ID_REGISTRY_ADDRESS,
  idRegistryABI,
  FarcasterNetwork,
  MessageType,
} from '@farcaster/hub-web';
import { Metadata } from '@grpc/grpc-js';
import { zeroAddress } from 'viem';
import { optimism } from 'viem/chains';
import { generatePrivateKey, privateKeyToAccount, toAccount } from "viem/accounts";
 
/**
 * Populate the following constants with your own values
 */
const CUSTODY_PRIVATE_KEY = '<REQUIRED>'; // A private key corresponding with any ETH address.
const OP_PROVIDER_URL = '<REQUIRED>'; // Alchemy or Infura url
const RECOVERY_ADDRESS = zeroAddress; // Optional, using the default value means the account will not be recoverable later if the mnemonic is lost
const SIGNER_PRIVATE_KEY: Hex = zeroAddress; // Optional, using the default means a new signer will be created each time
 
// Note: crackle is the Farcaster team's mainnet node, which is password protected to prevent abuse. Use a 3rd party node 
// provider like https://neynar.com/ Or, run your own mainnet node and broadcast to it permissionlessly.
const HUB_URL = 'crackle.farcaster.xyz:3383'; // URL + Port of the node 
const HUB_USERNAME = ''; // Username for auth, leave blank if not using TLS
const HUB_PASS = ''; // Password for auth, leave blank if not using TLS
const USE_SSL = false; // set to true if talking to a node that uses SSL (3rd party hosted nodes or nodes that require auth)
const FC_NETWORK = FarcasterNetwork.MAINNET; // Network of the node
 
// Call metadata for every hubClient call below. Carries basic auth when the node requires it;
// stays empty otherwise. Named `rpcMetadata` to keep it distinct from `KeyAddBody.metadata`,
// which is a different thing entirely (see step 3).
const rpcMetadata = new Metadata();
if (HUB_USERNAME && HUB_PASS) {
  rpcMetadata.set('authorization', `Basic ${Buffer.from(`${HUB_USERNAME}:${HUB_PASS}`).toString('base64')}`);
}
 
const CHAIN = optimism;
 
const IdGateway = {
  abi: idGatewayABI,
  address: ID_GATEWAY_ADDRESS,
  chain: CHAIN,
};
const IdContract = {
  abi: idRegistryABI,
  address: ID_REGISTRY_ADDRESS,
  chain: CHAIN,
};
 
// Message types this signer may sign. KEY_ADD and KEY_REMOVE are never admissible; the full
// admissible set is exported as ADMISSIBLE_KEY_ADD_SCOPES.
const SCOPES = [
  MessageType.CAST_ADD,
  MessageType.CAST_REMOVE,
  MessageType.REACTION_ADD,
  MessageType.REACTION_REMOVE,
  MessageType.LINK_ADD,
  MessageType.LINK_REMOVE,
  MessageType.USER_DATA_ADD,
  MessageType.VERIFICATION_ADD_ETH_ADDRESS,
  MessageType.VERIFICATION_REMOVE,
];
 
const TTL = 30 * 24 * 60 * 60; // Sliding window, refreshed on every use. Max 90 days.

const getOrRegisterFid = async (): Promise<number> => {
  const balance = await getBalance(walletClient, { address: account.address });
  const existingFid = (await readContract(walletClient, {
    ...IdContract,
    functionName: "idOf",
    args: [account.address],
  })) as bigint;
 
  console.log(`Using address: ${account.address} with balance: ${balance}, private key: ${accountPrivateKey}`);
 
  if (balance === 0n && existingFid === 0n) {
    throw new Error("No existing Fid and no funds to register an fid");
  }
 
  if (existingFid > 0n) {
    return parseInt(existingFid.toString());
  }
 
  const price = await readContract(walletClient, {
    ...IdGateway,
    functionName: "price",
  });
 
  if (balance < price) {
    throw new Error(`Insufficient balance to rent storage, required: ${price}, balance: ${balance}`);
  }
 
  const { request: registerRequest } = await simulateContract(walletClient, {
    ...IdGateway,
    functionName: "register",
    args: [RECOVERY_ADDRESS],
    value: price,
  });
  const registerTxHash = await writeContract(walletClient, registerRequest);
  const registerTxReceipt = await waitForTransactionReceipt(walletClient, { hash: registerTxHash });
 
  if (registerTxReceipt.logs[0]) {
    // Now extract the FID from the logs
    const registerLog = decodeEventLog({
      abi: idRegistryABI,
      data: registerTxReceipt.logs[0].data,
      topics: registerTxReceipt.logs[0].topics,
    });
 
    const fid = parseInt(registerLog.args["id"]);
    return fid;
  } else {
    throw new Error("Did not receive logs for registered fid");
  }
};
 
const fid = await getOrRegisterFid();

const getOrRegisterSigner = async (fid: number) => {
  if (SIGNER_PRIVATE_KEY !== zeroAddress) {
    // If a private key is provided, we assume the signer is already registered
    return fromHex(SIGNER_PRIVATE_KEY, "bytes");
  }
 
  const privateKey = new Uint8Array(randomBytes(32));
  const signer = new NobleEd25519Signer(Buffer.from(privateKey));
  const key = (await signer.getSignerKey())._unsafeUnwrap();
 
  // Nonces are strictly increasing per fid. Read the current value and add one.
  const signers = await hubClient.getSignersByFid({ fid, requesterFids: [] }, rpcMetadata);
  if (signers.isErr()) {
    throw new Error(`Error reading signers: ${signers.error}`);
  }
 
  // Signs the SignedKeyRequest metadata and the custody authorization over the key, its
  // scopes and its TTL. Pass a separate Eip712Signer as the third argument when the
  // requesting app's custody key differs from the fid's.
  const body = await makeKeyAddBody(
    {
      fid: BigInt(fid),
      key,
      scopes: SCOPES,
      ttl: TTL,
      nonce: signers.value.currentUserNonce + 1,
      deadline: getFarcasterTime()._unsafeUnwrap() + 60 * 60, // Farcaster time, 1 hour from now
    },
    new ViemLocalEip712Signer(toAccount(account)),
  );
  if (body.isErr()) {
    throw new Error(`Error building KEY_ADD: ${body.error}`);
  }
 
  // The envelope is signed by the new key itself — proof of possession.
  const message = await makeKeyAdd(body.value, { fid, network: FC_NETWORK }, signer);
  if (message.isErr()) {
    throw new Error(`Error creating KEY_ADD: ${message.error}`);
  }
 
  const result = await hubClient.submitMessage(message.value, rpcMetadata);
  if (result.isErr()) {
    throw new Error(`Error submitting KEY_ADD to node: ${result.error}`);
  }
 
  return privateKey;
};
 
 
const signerPrivateKey = await getOrRegisterSigner(fid);

const registerFname = async (fid: number) => {
  try {
    // First check if this fid already has an fname
    const response = await axios.get(`https://fnames.farcaster.xyz/transfers/current?fid=${fid}`);
    const fname = response.data.transfer.username;
    return fname;
  } catch (e) {
    // No username, ignore and continue with registering
  }
 
  const fname = `fid-${fid}`;
  const timestamp = Math.floor(Date.now() / 1000);
  const localAccount = toAccount(account);
  const signer = new ViemLocalEip712Signer(localAccount as LocalAccount<string>);
  const userNameProofSignature = await signer.signUserNameProofClaim(
    makeUserNameProofClaim({
      name: fname,
      timestamp: timestamp,
      owner: account.address,
    }),
  );
 
  try {
    const response = await axios.post("https://fnames.farcaster.xyz/transfers", {
      name: fname, // Name to register
      from: 0, // Fid to transfer from (0 for a new registration)
      to: fid, // Fid to transfer to (0 to unregister)
      fid: fid, // Fid making the request (must match from or to)
      owner: account.address, // Custody address of fid making the request
      timestamp: timestamp, // Current timestamp in seconds
      signature: bytesToHex(userNameProofSignature._unsafeUnwrap()), // EIP-712 signature signed by the current custody address of the fid
    });
    return fname;
  } catch (e) {
    // @ts-ignore
    throw new Error(`Error registering fname: ${JSON.stringify(e.response.data)} (status: ${e.response.status})`);
  }
};
 
const fname = await registerFname(fid);

const submitMessage = async (resultPromise: HubAsyncResult<Message>) => {
  const result = await resultPromise;
  if (result.isErr()) {
    throw new Error(`Error creating message: ${result.error}`);
  }
  const messageSubmitResult = await hubClient.submitMessage(result.value, rpcMetadata);
  if (messageSubmitResult.isErr()) {
    throw new Error(`Error submitting message to node: ${messageSubmitResult.error}`);
  }
};
 
const signer = new NobleEd25519Signer(signerPrivateKey);
const dataOptions = {
fid: fid,
network: FC_NETWORK,
};
const userDataPfpBody = {
type: UserDataType.USERNAME,
value: fname,
};
await submitMessage(makeUserDataAdd(userDataPfpBody, dataOptions, signer));
 
await submitMessage(
makeCastAdd(
    {
    text: "Hello World!",
    embeds: [],
    embedsDeprecated: [],
    mentions: [],
    mentionsPositions: [],
    type: CastType.CAST,
    },
    dataOptions,
    signer,
));