SDK quickstart

import { Connection, Keypair, PublicKey, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
import {
  ENCRYPT_DEVNET,
  EncryptInputClient,
  PayrollCrank,
  PayrollInstructions,
  SquadsV4Authority,
  UNLIMITED,
  companyIdFromSlug,
  deriveEncryptAccounts,
  encryptAmounts,
  fetchCompany,
} from "@dagon/payroll-sdk"; // unpublished: in the monorepo, import sdks/payroll/src/index.js

// Placeholders you supply:
declare const hr: Keypair;     // a Squads member with Initiate permission
declare const payer: Keypair;  // any crank payer (SOL + Encrypt deposit)
declare const mint: PublicKey; // the payroll SPL mint

const connection = new Connection("https://api.devnet.solana.com", "confirmed");
const networkKey = Buffer.from(process.env.NETWORK_KEY!, "hex");

const squads = new SquadsV4Authority(new PublicKey(process.env.MULTISIG!));
const payroll = new PayrollInstructions();

// The Company PDA is seeded by the authority it was created for (this vault).
const company = payroll.pdas.company(squads.authority, companyIdFromSlug("acme"));

const hrEnc = deriveEncryptAccounts(hr.publicKey, networkKey);
const { ix, signers } = payroll.createCompany({
  companyId: companyIdFromSlug("acme"),
  mint,                        // the payroll SPL mint
  authority: squads.authority, // the multisig vault PDA
  payer: hr.publicKey,
  encrypt: hrEnc,
});
await sendAndConfirmTransaction(connection, new Transaction().add(ix), [hr, ...signers]);

const { createEncryptClient } = (await import("@encrypt.xyz/pre-alpha-solana-client/grpc")) as {
  createEncryptClient: (url?: string) => EncryptInputClient;
};
const encryptClient = createEncryptClient(ENCRYPT_DEVNET.grpcUrl);

const hires = [
  { wallet: new PublicKey("..."), salary: 8_500_000000n },
  { wallet: new PublicKey("..."), salary: 11_250_000000n },
];
const salaryCts = await encryptAmounts(
  encryptClient,
  payroll.programId,
  networkKey,
  hires.map((h) => h.salary),
);

const c = await fetchCompany(connection, company);

const payrollIxs = [
  ...hires.map((h, i) =>
    payroll.authority.addEmployee({ company, authority: squads.authority, wallet: h.wallet, salaryCt: salaryCts[i] }),
  ),
  payroll.authority.openPayRun({
    company,
    authority: squads.authority,
    nextRunId: c.lastRunId + 1n,
    period: 202609n,
    budget: UNLIMITED, // or a public ceiling in base units
  }),
];

const { transactionIndex, ixs } = await squads.proposeIxs({
  connection,
  creator: hr.publicKey,
  payrollIxs,
  memo: "Payroll 2026-09",
});
await sendAndConfirmTransaction(connection, new Transaction().add(...ixs), [hr]);

const crankEnc = deriveEncryptAccounts(payer.publicKey, networkKey);
const crank = new PayrollCrank(connection, payer, crankEnc, undefined, console.log);

await crank.syncTreasury(company);
const { lastRunId } = await fetchCompany(connection, company);
const result = await crank.runPayroll(company, lastRunId);
// → { paid, bonuses, closed }

import { fetchEmployee } from "@dagon/payroll-sdk";

declare const wallet: Keypair;       // the employee
declare const recipient: PublicKey; // SPL token account of the payroll mint

const employeePda = payroll.pdas.employee(company, wallet.publicKey);
const e = await fetchEmployee(connection, employeePda);
const employeeEnc = deriveEncryptAccounts(wallet.publicKey, networkKey);

const withdraw = payroll.employee.withdraw({
  company,
  wallet: wallet.publicKey,
  balanceCt: e.balanceCt,
  recipient,
  amount: 2_000_000000n,
  payer: wallet.publicKey,
  encrypt: employeeEnc,
});
await sendAndConfirmTransaction(connection, new Transaction().add(withdraw.ix), [wallet, ...withdraw.signers]);

// Same keypair: for ~150 slots only the initiator may request decryption.
const employeeCrank = new PayrollCrank(connection, wallet, employeeEnc);
await employeeCrank.settleWithdrawal(payroll.pdas.withdrawal(employeePda));

import { ViewTarget } from "@dagon/payroll-sdk";

declare const lenderPubkey: PublicKey;

const view = payroll.grantView({
  target: ViewTarget.Balance,
  company,
  employee: employeePda,
  sourceCt: e.balanceCt,
  viewer: lenderPubkey,
  grantor: wallet.publicKey,
  payer: wallet.publicKey,
  encrypt: employeeEnc,
});
await sendAndConfirmTransaction(connection, new Transaction().add(view.ix), [wallet, ...view.signers]);