LayerZero V2 OFT on Starknet

// Get fee and receipt estimates
let send_param = SendParam {
    dst_eid: 30101,  // Ethereum Mainnet
    to: recipient_bytes32,
    amount_ld: 1000000000000000000_u256,  // 1 token
    min_amount_ld: 900000000000000000_u256,  // 0.9 token minimum
    extra_options: build_options(200000),
};

let quote = oft.quote_oft(send_param);
// quote.receipt.amount_sent_ld = actual amount debited
// quote.receipt.amount_received_ld = amount received on destination

let messaging_fee = oft.quote_send(send_param, false);
// messaging_fee.native_fee = STRK/ETH needed for LayerZero

// Approve tokens if using OFTAdapter
if oft.approval_required() {
    token.approve(oft_address, send_param.amount_ld);
}

// Approve native token for messaging fee
native_token.approve(oft_address, messaging_fee.native_fee);

// Send tokens
let result = oft.send(send_param, messaging_fee, refund_address);
// result.message_receipt.guid = unique message ID
// result.oft_receipt = actual amounts sent/received

// OFT amounts are always u256
let amount_ld: u256 = 1000000000000000000_u256;  // 1 token (18 decimals)
let min_amount_ld: u256 = 900000000000000000_u256;  // 0.9 token minimum

// Shared decimals = 6 means max precision of 6 decimal places
// A token with 18 local decimals has conversion rate of 10^12

const SHARED_DECIMALS: u8 = 6;
let local_decimals: u8 = 18;
let conversion_rate = 10_u256.pow((local_decimals - SHARED_DECIMALS).into()); // 10^12

// Sending 1.123456789012345678 tokens (18 decimals)
// Shared representation: 1.123456 (6 decimals)
// Dust lost: 0.000000789012345678

fn _remove_dust(self: @ComponentState, amount_ld: u256) -> u256 {
    let conversion_rate = self.OFTCore_decimal_conversion_rate.read();
    (amount_ld / conversion_rate) * conversion_rate
}

import {readFileSync} from 'node:fs';
import {RpcProvider, Account, Contract} from 'starknet';
import {
  getEndpointV2Contract,
  getOAppContract,
  encodeUlnConfig,
  encodeExecutorConfig,
  MessageLibConfigType,
} from '@layerzerolabs/lz-v2-protocol-starknet';
import {Options} from '@layerzerolabs/lz-v2-utilities';
import {EndpointId, ChainName, Environment} from '@layerzerolabs/lz-definitions';

async function main() {
  const RPC_URL = process.env.RPC_URL!;
  const ACCOUNT_ADDRESS = process.env.ACCOUNT_ADDRESS!;
  const PRIVATE_KEY = process.env.PRIVATE_KEY!;
  const OFT_ADDRESS = process.env.OFT_ADDRESS!;
  const OFT_ARTIFACT_PATH = process.env.OFT_ARTIFACT_PATH!;

  const compiledArtifact = JSON.parse(readFileSync(OFT_ARTIFACT_PATH, 'utf8'));
  const provider = new RpcProvider({nodeUrl: RPC_URL});
  const account = new Account({provider, address: ACCOUNT_ADDRESS, signer: PRIVATE_KEY});
  const endpoint = await getEndpointV2Contract(ChainName.STARKNET, Environment.TESTNET, provider);
  const oapp = await getOAppContract(OFT_ADDRESS, provider);
  const oappOptions = new Contract({
    abi: compiledArtifact.abi,
    address: OFT_ADDRESS,
    provider,
  }).typedv2(compiledArtifact.abi);

  const remoteEid = EndpointId.ETHEREUM_V2_MAINNET;

  // Configuration code goes here...
}

main().catch(console.error);

const setDelegateCall = oapp.populateTransaction.set_delegate(DELEGATE_ADDRESS);
await account.execute([setDelegateCall]);

const setSendLibCall = endpoint.populateTransaction.set_send_library(
  OFT_ADDRESS,
  remoteEid,
  SEND_LIB_ADDRESS,
);
const setReceiveLibCall = endpoint.populateTransaction.set_receive_library(
  OFT_ADDRESS,
  remoteEid,
  RECEIVE_LIB_ADDRESS,
  0, // Grace period in blocks
);
await account.execute([setSendLibCall, setReceiveLibCall]);

const sendLibAddress = (await endpoint.get_send_library(OFT_ADDRESS, remoteEid)).lib;
const receiveLibAddress = (await endpoint.get_receive_library(OFT_ADDRESS, remoteEid)).lib;

const sendUlnConfig = encodeUlnConfig({
  confirmations: 15,
  has_confirmations: true,
  required_dvns: [LAYERZERO_DVN_ADDRESS],
  has_required_dvns: true,
  optional_dvns: [],
  optional_dvn_threshold: 0,
  has_optional_dvns: false,
});

const setSendConfigCall = endpoint.populateTransaction.set_send_configs(
  OFT_ADDRESS,
  sendLibAddress,
  [
    {
      eid: remoteEid,
      config_type: MessageLibConfigType.ULN, // 2
      config: sendUlnConfig,
    },
  ],
);
await account.execute([setSendConfigCall]);

const receiveUlnConfig = encodeUlnConfig({
  confirmations: 15,
  has_confirmations: true,
  required_dvns: [LAYERZERO_DVN_ADDRESS],
  has_required_dvns: true,
  optional_dvns: [],
  optional_dvn_threshold: 0,
  has_optional_dvns: false,
});

const setReceiveConfigCall = endpoint.populateTransaction.set_receive_configs(
  OFT_ADDRESS,
  receiveLibAddress,
  [
    {
      eid: remoteEid,
      config_type: MessageLibConfigType.ULN, // 2
      config: receiveUlnConfig,
    },
  ],
);
await account.execute([setReceiveConfigCall]);

const executorConfig = encodeExecutorConfig({
  max_message_size: 10000,
  executor: EXECUTOR_ADDRESS,
});

const setExecutorConfigCall = endpoint.populateTransaction.set_send_configs(
  OFT_ADDRESS,
  sendLibAddress,
  [
    {
      eid: remoteEid,
      config_type: MessageLibConfigType.EXECUTOR, // 1
      config: executorConfig,
    },
  ],
);
await account.execute([setExecutorConfigCall]);

const options = Options.newOptions()
  .addExecutorLzReceiveOption(200000, 0) // 200k gas for lz_receive
  .toBytes();

const setOptionsCall = oappOptions.populateTransaction.set_enforced_options([
  {
    eid: remoteEid,
    msg_type: 1, // SEND
    options,
  },
]);
await account.execute([setOptionsCall]);

const peerBytes32 = {value: BigInt('0x000000000000000000000000' + EVM_OFT_ADDRESS.slice(2))};
const setPeerCall = oapp.populateTransaction.set_peer(remoteEid, peerBytes32);
await account.execute([setPeerCall]);

// Tokens sent to another chain
#[derive(Drop, starknet::Event)]
pub struct OFTSent {
    #[key]
    pub guid: Bytes32,
    pub dst_eid: u32,
    pub from: ContractAddress,
    pub amount_sent_ld: u256,
    pub amount_received_ld: u256,
}

// Tokens received from another chain
#[derive(Drop, starknet::Event)]
pub struct OFTReceived {
    #[key]
    pub guid: Bytes32,
    pub src_eid: u32,
    pub to: ContractAddress,
    pub amount_received_ld: u256,
}