Midgard SDK: Build Sundial L2 Transactions in TypeScript

import * as SDK from '@al-ft/midgard-sdk';
import { Lucid, Blockfrost } from '@lucid-evolution/lucid';
import { Effect } from 'effect';

const lucid = await Lucid(
  new Blockfrost('https://cardano-preprod.blockfrost.io/api/v0', process.env.BF_KEY),
  'Preprod'
);
lucid.selectWallet.fromSeed(process.env.WALLET_SEED);

// Fetch the Hub Oracle UTxO to read the protocol's policy IDs
const hubOracleUtxo = await SDK.fetchHubOracleUTxO(lucid, {
  hubOracleAddress:  'addr_test1...', // Hub Oracle validator address
  hubOraclePolicyId: 'abc123...',     // Hub Oracle NFT policy ID
});
const datum = hubOracleUtxo.datum; // HubOracleDatum

// From your instance's deployment
const depositScriptAddress = 'addr_test1...';                              // deposit validator address (bech32)
const depositMintingPolicy = { type: 'PlutusV3' as const, script: '...' }; // deposit minting policy script

// The L2 address to credit, as a credential
const l2Address = await Effect.runPromise(
  SDK.midgardAddressFromBech32('addr_test1...')
);

// Build the unsigned deposit transaction
const unsignedTx = await SDK.unsignedDepositTx(lucid, {
  depositScriptAddress,
  mintingPolicy: depositMintingPolicy,
  policyId:      datum.deposit,
  depositAmount: 5_000_000n, // 5 ADA in lovelace
  depositInfo: {
    l2Address,
    l2Datum: null, // or the datum bytes to attach to the L2 output
  },
});

// Sign and submit
const signedTx = await unsignedTx.sign.withWallet().complete();
const txHash = await signedTx.submit();
console.log('Deposit submitted:', txHash);

import * as SDK from '@al-ft/midgard-sdk';
import { Effect } from 'effect';

// From your instance's deployment
const withdrawalScriptAddress = 'addr_test1...';
const withdrawalMintingPolicy = { type: 'PlutusV3' as const, script: '...' };

// Withdrawal orders already on L1. fetchWithdrawalUTxOs returns a runner, not a promise.
const existingWithdrawals = await SDK.fetchWithdrawalUTxOs(lucid, {
  eventAddress:  withdrawalScriptAddress,
  eventPolicyId: datum.withdrawal,
}).unsafeRun();

// Where the funds go on L1, and where a refund goes if the order is invalid
const l1Address     = await Effect.runPromise(SDK.addressDataFromBech32('addr_test1...'));
const refundAddress = await Effect.runPromise(SDK.addressDataFromBech32('addr_test1...'));

const withdrawalBody: SDK.WithdrawalBody = {
  // The L2 output to withdraw
  l2_outref: {
    txHash:      { hash: '9e4f3a2b...' }, // 32-byte L2 transaction hash, hex
    outputIndex: 0n,
  },
  l2_owner: 'a1b2c3...', // 28-byte key hash that owns the L2 output, hex
  // policy ID -> asset name -> quantity. The empty strings are ADA.
  l2_value: { inner: new Map([['', new Map([['', 5_000_000n]])]]) },
  l1_address: l1Address,
  l1_datum:   'NoDatum',
};

// Verification key -> signature over the withdrawal body, by the owner of the L2 output
const withdrawalSignature: SDK.WithdrawalSignature = new Map([
  ['<verification key hex>', '<signature hex>'],
]);

const unsignedTx = await SDK.unsignedWithdrawalTx(lucid, {
  withdrawalScriptAddress,
  mintingPolicy: withdrawalMintingPolicy,
  policyId:      datum.withdrawal,
  withdrawalBody,
  withdrawalSignature,
  refundAddress,
});

const signedTx = await unsignedTx.sign.withWallet().complete();
const txHash = await signedTx.submit();
console.log('Withdrawal order submitted:', txHash);

import * as SDK from '@al-ft/midgard-sdk';
import { CML } from '@lucid-evolution/lucid';
import { Effect } from 'effect';

// From your instance's deployment
const txOrderScriptAddress = 'addr_test1...';
const txOrderMintingPolicy = { type: 'PlutusV3' as const, script: '...' };

// Your pre-built and signed L2 transaction
const l2Tx = CML.Transaction.from_cbor_hex('84a400818258...');

const refundAddress = await Effect.runPromise(SDK.addressDataFromBech32('addr_test1...'));

const unsignedTx = await SDK.unsignedTxOrderTx(lucid, {
  txOrderScriptAddress,
  mintingPolicy: txOrderMintingPolicy,
  policyId:      datum.txOrder,
  cardanoTx:     l2Tx,
  refundAddress,
});

const signedTx = await unsignedTx.sign.withWallet().complete();
const txHash = await signedTx.submit();
console.log('Tx order posted:', txHash);

import * as SDK from '@al-ft/midgard-sdk';
import { Effect } from 'effect';

// fetchSchedulerUTxOProgram returns an Effect; run it with Effect.runPromise
const schedulerUtxo = await Effect.runPromise(
  SDK.fetchSchedulerUTxOProgram(lucid, {
    schedulerAddress:  'addr_test1...', // scheduler validator address (bech32), from your deployment
    schedulerPolicyId: datum.scheduler,
  })
);

console.log('Scheduler UTxO:', schedulerUtxo);

import * as SDK from '@al-ft/midgard-sdk';
import { Effect } from 'effect';

// Build the first step of a fraud proof computation thread
const program = SDK.incompleteFraudProofComputationThreadInitTxProgram(lucid, {
  fraudProofCatalogueAddress:  datum.fraudProofCatalogueAddr,
  fraudProofCataloguePolicyId: datum.fraudProofCatalogue,
  fraudProofMintingPolicy:     { type: 'PlutusV3', script: '...' },
  stateQueueAddress:           datum.stateQueueAddr,
  disputedBlockUtxo:           invalidBlockUtxo,
});

const txBuilder = await Effect.runPromise(program);
const signedTx = await (await txBuilder.complete({ localUPLCEval: false }))
  .sign.withWallet()
  .complete();
await signedTx.submit();

import * as SDK from '@al-ft/midgard-sdk';
import { Effect } from 'effect';

const program = SDK.unsignedDepositTxProgram(lucid, depositParams).pipe(
  Effect.catchTag('DepositError', (e) => {
    console.error('Deposit build failed:', e.message, '—', e.cause);
    return Effect.fail(e);
  }),
  Effect.catchTag('LucidError', (e) => {
    console.error('Lucid error:', e.message);
    return Effect.fail(e);
  }),
);

const unsignedTx = await Effect.runPromise(program);