qubic-typescript

import { generateSeed, createWallet, createVault, unlockVault } from '@qubic.org/wallet'
import { createLiveClient } from '@qubic.org/rpc'

const live = createLiveClient()
const tickInfoResult = await live.getTickInfo()
if (!tickInfoResult.ok) throw tickInfoResult.error
const tickInfo = tickInfoResult.value

// Generate and persist a seed in an encrypted vault
const seed = generateSeed()
const vault = await createVault('strong-password', [seed])
// exportVault(vault) → persist JSON to disk / localStorage

// Later: unlock and use
const [storedSeed] = await unlockVault(vault, 'strong-password')
const wallet = createWallet(storedSeed)

console.log(wallet.identity) // 60-char Qubic identity

const { encoded } = await wallet.buildTransaction({
  destination: 'BZBQFLLBNCXEMGLOBHUVFTLUPLVCPQUASSILFABOFFBCADQSSUPNWLZBQEXK',
  amount: 1_000_000n,
  targetTick: tickInfo.tick + 5,
  currentTick: tickInfo.tick,
})

const result = await live.broadcastTransaction(encoded)
if (!result.ok) throw result.error
console.log('peers:', result.value.peersBroadcastedTo)

import { VaultManager, TaintStatusEnum } from '@qubic.org/vault'
import { deriveIdentityFromSeed } from '@qubic.org/crypto'

const vault = new VaultManager()

// Create vault with multiple seeds
const encrypted = await vault.create({
  seeds: [
    {
      publicId: deriveIdentityFromSeed('seed-one'),
      encryptedSeed: new TextEncoder().encode('seed-one'),
      alias: 'Main account',
      taintStatus: TaintStatusEnum.UNTAINTED,
    },
    {
      publicId: deriveIdentityFromSeed('seed-two'),
      encryptedSeed: new TextEncoder().encode('seed-two'),
      alias: 'Secondary account',
      taintStatus: TaintStatusEnum.UNTAINTED,
    },
  ],
  metadata: {
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    appVersion: '1.0.0',
    schemaVersion: 3,
  },
}, 'strong-password')

// Add another seed
const updated = await vault.addSeed(encrypted, 'strong-password', {
  publicId: deriveIdentityFromSeed('seed-three'),
  encryptedSeed: new TextEncoder().encode('seed-three'),
  alias: 'Trading account',
})

// Unlock and access seeds
const payload = await vault.unlock(updated, 'strong-password')
for (const entry of payload.seeds) {
  console.log(`${entry.alias}: ${entry.publicId}`)
}

// Upgrade legacy v1 vault
const upgraded = await vault.upgrade(v1VaultData, 'old-password', 'new-password')

import { createWallet } from '@qubic.org/wallet'
import { toSeed } from '@qubic.org/types'
import { createLiveClient } from '@qubic.org/rpc'
import { buildQearnUnlockInput } from '@qubic.org/contracts'
import { contractIndexToIdentity } from '@qubic.org/crypto'

const live = createLiveClient()
const tickInfoResult = await live.getTickInfo()
if (!tickInfoResult.ok) throw tickInfoResult.error
const tickInfo = tickInfoResult.value
const wallet = createWallet(toSeed('a'.repeat(55)))

const call = buildQearnUnlockInput({ amount: 10_000_000n, lockedEpoch: tickInfo.epoch - 1 })

const { encoded } = await wallet.buildContractCall({
  destination: contractIndexToIdentity(call.contractIndex),
  amount: 10_000_000n,
  targetTick: tickInfo.tick + 5,
  currentTick: tickInfo.tick,
  inputType: call.inputType,
  payload: call.payload,
})

const result = await live.broadcastTransaction(encoded)
if (!result.ok) throw result.error
console.log('peers:', result.value.peersBroadcastedTo)

import { createLiveClient } from '@qubic.org/rpc'
import { qearn } from '@qubic.org/contracts'
import { identityToPublicKey, publicKeyToIdentity } from '@qubic.org/crypto'

const live = createLiveClient()

const result = await qearn.getStateOfRound(live, { epoch: 212 }, {
  identityToPublicKey,
  publicKeyToIdentity,
})

if (result.ok) {
  console.log('state:', result.value.state)
} else {
  console.error('RPC error:', result.error.status, result.error.endpoint)
}

import { subscribeQuTransfers, subscribeAssetEvents, eventFilter, LOG_TYPE } from '@qubic.org/events'
import { createBobSubscriptionClient } from '@qubic.org/bob'

const bob = createBobSubscriptionClient({ wsUrl: 'wss://bob.qubic.org/v1/ws' })

// Stream QU transfers to/from a specific identity — decoded and typed
for await (const event of subscribeQuTransfers(bob, { identity: 'BZBQFLLBNCXEMGLOBHUVFTLUPLVCPQUASSILFABOFFBCADQSSUPNWLZBQEXK' })) {
  const { source, destination, amount } = event.data.data
  console.log(`${source} → ${destination}: ${amount} QU at tick ${event.data.tick}`)
}

// Build a filter for asset events from a specific tick
const filter = eventFilter()
  .ofTypes(LOG_TYPE.ASSET_ISSUANCE, LOG_TYPE.ASSET_OWNERSHIP_CHANGE)
  .fromTick(25_000_000)
  .build()

for await (const event of subscribeAssetEvents(bob, filter)) {
  if (event.data.logType === LOG_TYPE.ASSET_ISSUANCE) {
    console.log('New asset:', event.data.data.assetName, 'by', event.data.data.issuer)
  }
}

import { createNodePool, requestCurrentTickInfo, requestEntity, broadcastTransaction } from '@qubic.org/tcp'
import { createWallet } from '@qubic.org/wallet'
import { toSeed } from '@qubic.org/types'
import { identityToPublicKey } from '@qubic.org/crypto'

const pool = createNodePool([
  'node1.qubic.org',
  'node2.qubic.org',
  'node3.qubic.org',
])

// Current tick — retries automatically on peer failure
const { epoch, tick } = await requestCurrentTickInfo(pool)

// Entity balance directly from a peer
const pk = identityToPublicKey('BZBQFLLBNCXEMGLOBHUVFTLUPLVCPQUASSILFABOFFBCADQSSUPNWLZBQEXK')
const { entity, identity } = await requestEntity(pool, pk)
console.log(identity, entity.incomingAmount - entity.outgoingAmount)

// Broadcast a signed transaction
const wallet = createWallet(toSeed('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'))
const { bytes } = await wallet.buildTransaction({
  destination: 'BZBQFLLBNCXEMGLOBHUVFTLUPLVCPQUASSILFABOFFBCADQSSUPNWLZBQEXK',
  amount: 1n,
  targetTick: tick + 5,
  currentTick: tick,
})
await broadcastTransaction(pool, bytes)

pool.close()

import { createRegistryClient } from '@qubic.org/registry/client'
import { decodePayload } from '@qubic.org/registry'
import { publicKeyToIdentity } from '@qubic.org/crypto'

// Get the ABI active at the epoch when the tx was submitted
const registry = createRegistryClient()
const { version } = await registry.getAbi(9 /* Qearn */, 180 /* epoch */)

const lockProc = version.procedures.find(p => p.name === 'lock_input')!
const decoded = decodePayload(payloadBytes, lockProc.inputFields, version.structs, publicKeyToIdentity)
// decoded.amount, decoded.numberOfEpochs, etc.

import { qearn, qx, quottery } from '@qubic.org/contracts'

// Read-only query
const state = await qearn.getStateOfRound(live, { epoch: 212 })

// Payload builder (for transaction construction)
const payload = qx.buildAddToAskOrderInput({
  assetName: 'CFB',
  issuer: 'CFBMEMZOIDEXQAUXYYSZIURADQLAPWPMNJXQSNVQZAHYVOPYUKKJBJUCTVJL',
  price: 500n,
  numberOfShares: 10n,
})