Mera
ExecutionInstant confidential swapsClear from encrypted balances in one 150ms slot.Hidden-size limit ordersLock encrypted size in a private escrow PDA.Sealed RFQ block tradesRequest signed quotes without leaking size.
Vault & AuditShielded vault & keysDeposit SOL, SPL, or Token-2022 into a Ring.Viewing key verifierDecrypt and prove a single settled fill.
Docs/Protocol & Reference
3 min read

TypeScript SDK Reference

Complete reference for @mera/sdk (createMeraClient, keypairSigner, high-level execution methods, and re-exported @mera/contract types).

@mera/sdk (v0.1.0) is the typed TypeScript client for programmatic traders, market makers, desks, and auditors. It wraps @mera/contract and @solana/web3.js so every action handles transaction building, VersionedTransaction deserialization, signing, and submission in one call.

Package exports

@mera/sdk exports:

  • createMeraClient(options: MeraClientOptions): MeraClient
  • keypairSigner(keypair: Keypair): MeraSigner
  • Types MeraSigner, MeraClientOptions, MeraClient
  • All exports from @mera/contract: createMeraApiClient, zod schemas, error tables (errors, BASE_ERROR_STATUS), fromBase64, toBase64, toBase58, fromBase58

Initialization

ts
import { Keypair } from '@solana/web3.js'
import { createMeraClient, keypairSigner, type MeraSigner } from '@mera/sdk'

const signer: MeraSigner = keypairSigner(Keypair.generate())

const mera = createMeraClient({
  apiUrl: 'http://127.0.0.1:36102',
  signer,
  headers: {
    // Optional custom headers, e.g. Authorization: 'Bearer <siws-token>'
  },
})

MeraClientOptions:

FieldTypeRequiredDescription
apiUrlstringYesBase URL of the Mera API & matching relay
signerMeraSignerNoDefault signer ({ publicKey: { toBase58(): string }, signTransaction(tx) }). Required for write methods unless passed per call
headersRecord<string, string>NoExtra headers sent on every HTTP request
fetchtypeof globalThis.fetchNoCustom fetch implementation for tests or proxies

Read-only clients (such as an auditor verifying TVKs) can omit signer.

Read methods

MethodParametersReturns
mera.health()NonePromise<HealthResponse>
mera.getStats()NonePromise<ProtocolStats>
mera.getMints()NonePromise<MintsResponse>
mera.getPairs()NonePromise<PairsResponse>
mera.getRings()NonePromise<RingsResponse>
mera.getRing(ringId)ringId: stringPromise<RingDetail>
mera.getBalances(wallet, ringId?)wallet: string, ringId?: stringPromise<WalletBalancesResponse>
mera.getHiddenOrders(query?){ ringId?, pairId?, status? }Promise<HiddenOrdersPage>
mera.getMyHiddenOrders(wallet, ringId?)wallet: string, ringId?: stringPromise<MyHiddenOrdersResponse>
mera.getFills(query?){ ringId?, wallet? }Promise<FillsPage>
mera.verifyTvk(tvk)tvk: stringPromise<VerifiedReceiptResponse>

Write and execution methods

Every write method accepts an optional trailing signer parameter that overrides options.signer for that single call.

MethodInputReturns
mera.createRing(input, signer?){ name, mode, allowlistEnabled?, auditorPubkey?, authority? }Promise<TxSubmissionResponse>
mera.setRingMember(ringId, input, signer?)ringId, { member, allowed, frozen?, authority? }Promise<TxSubmissionResponse>
mera.shieldDeposit(input, signer?){ ringId, mint, amount, commitment?, wallet? }Promise<TxSubmissionResponse>
mera.shieldWithdraw(input, signer?){ ringId, mint, amount, recipient?, noteId?, wallet? }Promise<TxSubmissionResponse>
mera.executeSwap(input, signer?){ ringId, pairId, side, inputAmount, slippageBps?, wallet? }Promise<{ quote: SwapQuoteResponse, submission: TxSubmissionResponse }>
mera.placeHiddenOrder(input, signer?){ ringId, pairId, side, limitPrice, size, expirySlots?, wallet? }Promise<{ orderId: string, submission: TxSubmissionResponse }>
mera.cancelHiddenOrder(orderId, signer?)orderId: stringPromise<TxSubmissionResponse>
mera.fillHiddenOrder(orderId, input?, signer?)orderId, { counterpartyAmount? }Promise<TxSubmissionResponse>
mera.requestAndAcceptRfq(input, signer?){ ringId, pairId, side, size, ttlSeconds?, wallet? }Promise<{ rfq: RfqRequestResponse, quote: SealedRfqQuote, submission: TxSubmissionResponse }>

Low-level API access (`mera.api`)

mera.api exposes the underlying MeraApiClient from @mera/contract whenever you want to inspect a quote or unsigned TxBuildResponse before signing:

  • mera.api.quoteSwap(body) and mera.api.buildSwap(body)
  • mera.api.requestRfq(body), mera.api.rfqQuotes(requestId), and mera.api.buildAcceptRfq(requestId, body)
  • mera.api.buildCreateRing(body) and mera.api.buildSetRingMember(ringId, body)
  • mera.api.buildShieldDeposit(body) and mera.api.buildShieldWithdraw(body)
  • mera.api.buildPlaceHiddenOrder(body), mera.api.buildCancelHiddenOrder(orderId, body), mera.api.buildFillHiddenOrder(orderId, body)
  • mera.api.submitTransaction(body) and mera.api.transactionStatus(id)
  • mera.api.eventsUrl(ringId?)

Complete programmatic example

ts
import { Keypair } from '@solana/web3.js'
import { createMeraClient, keypairSigner } from '@mera/sdk'

export async function runDeskFlow(deskKeypair: Keypair, apiUrl: string) {
  const mera = createMeraClient({
    apiUrl,
    signer: keypairSigner(deskKeypair),
  })

  const health = await mera.health()
  if (health.status !== 'ready') {
    throw new Error(`Mera API not ready: ${health.status}`)
  }

  const { items: mints } = await mera.getMints()
  const sol = mints.find((m) => m.symbol === 'SOL')!

  // Shield 2 SOL into Default Ring
  await mera.shieldDeposit({
    ringId: 'ring-default',
    mint: sol.mint,
    amount: '2000000000',
  })

  // Execute a 1 SOL sealed RFQ block
  const { quote, submission } = await mera.requestAndAcceptRfq({
    ringId: 'ring-default',
    pairId: 'SOL-USDC',
    side: 'sell',
    size: '1000000000',
    ttlSeconds: 30,
  })

  if (!submission.tvk) {
    throw new Error('Missing TVK receipt on settled RFQ')
  }

  const receipt = await mera.verifyTvk(submission.tvk)
  return {
    maker: quote.makerLabel,
    price: receipt.executionPrice,
    feeAmount: receipt.feeAmount,
    slot: receipt.slot,
    finalityMs: receipt.finalityMs,
    onchainMatched: receipt.onchainMatched,
  }
}