dash-shielded-native 0.0.1

package/rust/uniffi-bindgen.rs

@@ -0,0 +1,3 @@
+fn main() {
+    uniffi::uniffi_bindgen_main()
+}

package/src/load-addon.ts

@@ -0,0 +1,99 @@
+import { existsSync } from 'fs'
+import { join } from 'path'
+
+export interface NativeDashAddon {
+  setDocumentDirectory: (path: string) => void
+  initialize: (
+    mnemonicSeed: string,
+    account: number,
+    alias: string,
+    networkName: string,
+    defaultHost: string,
+    defaultPort: number
+  ) => Promise<void>
+  stop: (alias: string) => Promise<string>
+  startSync: (alias: string) => Promise<void>
+  stopSync: (alias: string) => Promise<void>
+  deriveShieldedAddress: (alias: string) => Promise<{ shieldedAddress: string }>
+  isValidAddress: (address: string, network: string) => boolean
+  deriveViewingKey: (mnemonicSeed: string, network: string) => string
+  warmUpProver: () => Promise<void>
+  isProverReady: () => boolean
+  poll: (
+    alias: string
+  ) => Promise<{
+    alias: string
+    status: string
+    scanProgress: number
+    networkBlockHeight: number
+    availableCredits: string
+    totalCredits: string
+    transactions: Array<{
+      txid: string
+      blockTimeInSeconds: number
+      minedHeight: number
+      value: string
+      fee?: string
+      toAddress?: string
+      memos: string[]
+    }>
+  }>
+  proposeTransfer: (
+    alias: string,
+    amountCredits: string,
+    toAddress: string,
+    memo?: string
+  ) => Promise<string>
+  createTransfer: (
+    alias: string,
+    proposalId: string,
+    mnemonicSeed: string
+  ) => Promise<string>
+}
+
+function candidatePaths(): string[] {
+  const here = __dirname
+  const platform = `${process.platform}-${process.arch}`
+  const out: string[] = []
+  let dir = here
+  for (let i = 0; i < 6; i++) {
+    out.push(join(dir, 'prebuilds', platform, 'dashshielded.node'))
+    out.push(join(dir, 'rust', 'target', 'release', 'libdashshielded.dylib'))
+    out.push(join(dir, 'rust', 'target', 'release', 'libdashshielded.so'))
+    const parent = join(dir, '..')
+    if (parent === dir) break
+    dir = parent
+  }
+  return out
+}
+
+let cached: NativeDashAddon | undefined
+
+export function loadNativeAddon(): NativeDashAddon {
+  if (cached != null) return cached
+
+  const errors: string[] = []
+  const missing: string[] = []
+  for (const candidate of candidatePaths()) {
+    try {
+      if (!existsSync(candidate)) {
+        missing.push(candidate)
+        continue
+      }
+      const mod = require(candidate) as NativeDashAddon
+      if (typeof mod.initialize !== 'function') continue
+      cached = mod
+      return cached
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      errors.push(`${candidate}: ${message}`)
+    }
+  }
+
+  throw new Error(
+    'dash-shielded-native Node addon not found. Run `npm run build-native-host`. ' +
+      (errors.length > 0
+        ? errors.join('; ')
+        : `Looked in: ${missing.join(', ')}`)
+  )
+}

package/src/node.ts

@@ -0,0 +1,248 @@
+import { mkdirSync } from 'fs'
+
+import { loadNativeAddon, NativeDashAddon } from './load-addon'
+import {
+  Addresses,
+  CreateTransferOpts,
+  InitializerConfig,
+  Network,
+  ProposalSuccess,
+  ProposeTransferOpts,
+  SpendFailure,
+  SpendSuccess,
+  SynchronizerCallbacks,
+  ViewingKeySet
+} from './types'
+
+export * from './types'
+
+export interface MakeNodeDashShieldedOpts {
+  documentDirectory: string
+}
+
+function parseJsonObject(value: string): unknown {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return { errorMessage: value }
+  }
+}
+
+export const Tools = {
+  deriveViewingKey: (
+    mnemonicSeed: string,
+    network: Network
+  ): Promise<ViewingKeySet> => {
+    const addon = loadNativeAddon()
+    return Promise.resolve({
+      fullViewingKey: addon.deriveViewingKey(mnemonicSeed, network)
+    })
+  },
+  deriveShieldedAddress: async (
+    mnemonicSeed: string,
+    network: Network,
+    account: number = 0
+  ): Promise<string> => {
+    const addon = loadNativeAddon()
+    const alias = `tools-addr-${network}-${account}`
+    await addon.initialize(mnemonicSeed, account, alias, network, '', 0)
+    const { shieldedAddress } = await addon.deriveShieldedAddress(alias)
+    await addon.stop(alias)
+    return shieldedAddress
+  },
+  isValidAddress: (
+    address: string,
+    network: Network = 'mainnet'
+  ): Promise<boolean> => {
+    const addon = loadNativeAddon()
+    return Promise.resolve(addon.isValidAddress(address, network))
+  },
+  warmUpProver: async (): Promise<void> => {
+    const addon = loadNativeAddon()
+    await addon.warmUpProver()
+  },
+  isProverReady: (): Promise<boolean> => {
+    const addon = loadNativeAddon()
+    return Promise.resolve(addon.isProverReady())
+  }
+}
+
+export class Synchronizer {
+  alias: string
+  network: Network
+  private readonly addon: NativeDashAddon
+  private timer?: ReturnType<typeof setTimeout>
+  private callbacks?: SynchronizerCallbacks
+  private lastStatus?: string
+
+  constructor(alias: string, network: Network, addon: NativeDashAddon) {
+    this.alias = alias
+    this.network = network
+    this.addon = addon
+  }
+
+  async stop(): Promise<string> {
+    this.unsubscribe()
+    return this.addon.stop(this.alias)
+  }
+
+  async initialize(config: InitializerConfig): Promise<void> {
+    const seed = config.mnemonicSeed ?? config.seedHex
+    if (seed == null) throw new Error('Missing mnemonicSeed')
+    await this.addon.initialize(
+      seed,
+      config.account,
+      config.alias,
+      config.network,
+      config.defaultHost,
+      config.defaultPort
+    )
+  }
+
+  async startSync(): Promise<void> {
+    await this.addon.startSync(this.alias)
+  }
+
+  async stopSync(): Promise<void> {
+    await this.addon.stopSync(this.alias)
+  }
+
+  async deriveShieldedAddress(): Promise<Addresses> {
+    return this.addon.deriveShieldedAddress(this.alias)
+  }
+
+  async getBalance(): Promise<{
+    availableCredits: string
+    totalCredits: string
+  }> {
+    const snap = await this.addon.poll(this.alias)
+    return {
+      availableCredits: snap.availableCredits,
+      totalCredits: snap.totalCredits
+    }
+  }
+
+  async getTransactions(): Promise<
+    Array<{
+      txid: string
+      blockTimeInSeconds: number
+      minedHeight: number
+      value: string
+      fee?: string
+      toAddress?: string
+      memos: string[]
+    }>
+  > {
+    const snap = await this.addon.poll(this.alias)
+    return snap.transactions
+  }
+
+  async proposeTransfer(opts: ProposeTransferOpts): Promise<ProposalSuccess> {
+    const raw = await this.addon.proposeTransfer(
+      this.alias,
+      opts.amountCredits,
+      opts.toAddress,
+      opts.memo
+    )
+    return parseJsonObject(raw) as ProposalSuccess
+  }
+
+  async createTransfer(
+    opts: CreateTransferOpts
+  ): Promise<SpendSuccess | SpendFailure> {
+    try {
+      const raw = await this.addon.createTransfer(
+        this.alias,
+        opts.proposalId,
+        opts.mnemonicSeed
+      )
+      return parseJsonObject(raw) as SpendSuccess
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error)
+      return { errorMessage }
+    }
+  }
+
+  subscribe(callbacks: SynchronizerCallbacks): void {
+    this.callbacks = callbacks
+    this.pump().catch(error => {
+      callbacks.onError({
+        alias: this.alias,
+        level: 'error',
+        message: `event pump failed: ${String(error)}`
+      })
+    })
+  }
+
+  unsubscribe(): void {
+    if (this.timer != null) {
+      clearTimeout(this.timer)
+      this.timer = undefined
+    }
+    this.callbacks = undefined
+  }
+
+  private async pump(): Promise<void> {
+    if (this.callbacks == null) return
+    const snap = await this.addon.poll(this.alias)
+    const {
+      onBalanceChanged,
+      onStatusChanged,
+      onTransactionsChanged,
+      onUpdate
+    } = this.callbacks
+
+    onBalanceChanged({
+      availableCredits: snap.availableCredits,
+      totalCredits: snap.totalCredits
+    })
+
+    if (snap.status !== this.lastStatus) {
+      this.lastStatus = snap.status
+      onStatusChanged({
+        alias: this.alias,
+        name: snap.status as 'STOPPED' | 'DISCONNECTED' | 'SYNCING' | 'SYNCED'
+      })
+    }
+
+    onTransactionsChanged({ transactions: snap.transactions })
+    onUpdate({
+      alias: this.alias,
+      scanProgress: snap.scanProgress,
+      networkBlockHeight: snap.networkBlockHeight
+    })
+
+    const delay = snap.status === 'SYNCING' ? 500 : 2000
+    this.timer = setTimeout(() => {
+      this.pump().catch(error => {
+        this.callbacks?.onError({
+          alias: this.alias,
+          level: 'error',
+          message: `event pump failed: ${String(error)}`
+        })
+      })
+    }, delay)
+  }
+}
+
+export const makeSynchronizer = async (
+  config: InitializerConfig
+): Promise<Synchronizer> => {
+  const addon = loadNativeAddon()
+  const synchronizer = new Synchronizer(config.alias, config.network, addon)
+  await synchronizer.initialize(config)
+  return synchronizer
+}
+
+export function makeNodeDashShieldedModule(
+  opts: MakeNodeDashShieldedOpts
+): {
+  Tools: typeof Tools
+  makeSynchronizer: typeof makeSynchronizer
+} {
+  mkdirSync(opts.documentDirectory, { recursive: true })
+  const addon = loadNativeAddon()
+  addon.setDocumentDirectory(opts.documentDirectory)
+  return { Tools, makeSynchronizer }
+}

package/src/react-native.ts

@@ -0,0 +1,212 @@
+import {
+  EventSubscription,
+  NativeEventEmitter,
+  NativeModules
+} from 'react-native'
+
+import {
+  Addresses,
+  CreateTransferOpts,
+  InitializerConfig,
+  Network,
+  ProposalSuccess,
+  ProposeTransferOpts,
+  SpendFailure,
+  SpendSuccess,
+  SynchronizerCallbacks,
+  ViewingKeySet
+} from './types'
+export * from './types'
+
+const { RNDashShielded } = NativeModules
+
+function parseJsonObject(value: string): unknown {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return { errorMessage: value }
+  }
+}
+
+export const Tools = {
+  deriveViewingKey: async (
+    mnemonicSeed: string,
+    network: Network
+  ): Promise<ViewingKeySet> => {
+    const fullViewingKey = await RNDashShielded.deriveViewingKey(
+      mnemonicSeed,
+      network
+    )
+    return { fullViewingKey }
+  },
+  deriveShieldedAddress: async (
+    mnemonicSeed: string,
+    network: Network,
+    account: number = 0
+  ): Promise<string> => {
+    return RNDashShielded.deriveShieldedAddressFromSeed(
+      mnemonicSeed,
+      network,
+      account
+    )
+  },
+  isValidAddress: async (
+    address: string,
+    network: Network = 'mainnet'
+  ): Promise<boolean> => {
+    return RNDashShielded.isValidAddress(address, network)
+  },
+  warmUpProver: async (): Promise<void> => {
+    await RNDashShielded.warmUpProver()
+  },
+  isProverReady: async (): Promise<boolean> => {
+    return RNDashShielded.isProverReady()
+  }
+}
+
+export class Synchronizer {
+  eventEmitter: NativeEventEmitter
+  subscriptions: EventSubscription[]
+  alias: string
+  network: Network
+  private timer?: ReturnType<typeof setTimeout>
+  private callbacks?: SynchronizerCallbacks
+  private lastStatus?: string
+
+  constructor(alias: string, network: Network) {
+    this.eventEmitter = new NativeEventEmitter(RNDashShielded)
+    this.subscriptions = []
+    this.alias = alias
+    this.network = network
+  }
+
+  async stop(): Promise<string> {
+    this.unsubscribe()
+    return RNDashShielded.stop(this.alias)
+  }
+
+  async initialize(config: InitializerConfig): Promise<void> {
+    const seed = config.mnemonicSeed ?? config.seedHex
+    if (seed == null) throw new Error('Missing mnemonicSeed')
+    await RNDashShielded.initialize(
+      seed,
+      config.account,
+      config.alias,
+      config.network,
+      config.defaultHost,
+      config.defaultPort
+    )
+  }
+
+  async startSync(): Promise<void> {
+    await RNDashShielded.startSync(this.alias)
+  }
+
+  async stopSync(): Promise<void> {
+    await RNDashShielded.stopSync(this.alias)
+  }
+
+  async deriveShieldedAddress(): Promise<Addresses> {
+    return RNDashShielded.deriveShieldedAddress(this.alias)
+  }
+
+  async proposeTransfer(opts: ProposeTransferOpts): Promise<ProposalSuccess> {
+    const result = await RNDashShielded.proposeTransfer(
+      this.alias,
+      opts.amountCredits,
+      opts.toAddress,
+      opts.memo
+    )
+    return parseJsonObject(result) as ProposalSuccess
+  }
+
+  async createTransfer(
+    opts: CreateTransferOpts
+  ): Promise<SpendSuccess | SpendFailure> {
+    try {
+      const result = await RNDashShielded.createTransfer(
+        this.alias,
+        opts.proposalId,
+        opts.mnemonicSeed
+      )
+      return parseJsonObject(result) as SpendSuccess
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error)
+      return { errorMessage }
+    }
+  }
+
+  subscribe(callbacks: SynchronizerCallbacks): void {
+    this.callbacks = callbacks
+    this.pump().catch(error => {
+      callbacks.onError({
+        alias: this.alias,
+        level: 'error',
+        message: `event pump failed: ${String(error)}`
+      })
+    })
+  }
+
+  unsubscribe(): void {
+    if (this.timer != null) {
+      clearTimeout(this.timer)
+      this.timer = undefined
+    }
+    this.callbacks = undefined
+    this.subscriptions.forEach(subscription => {
+      subscription.remove()
+    })
+    this.subscriptions = []
+  }
+
+  private async pump(): Promise<void> {
+    if (this.callbacks == null) return
+    const snap = await RNDashShielded.poll(this.alias)
+    const {
+      onBalanceChanged,
+      onStatusChanged,
+      onTransactionsChanged,
+      onUpdate
+    } = this.callbacks
+
+    onBalanceChanged({
+      availableCredits: snap.availableCredits,
+      totalCredits: snap.totalCredits
+    })
+
+    if (snap.status !== this.lastStatus) {
+      this.lastStatus = snap.status
+      onStatusChanged({
+        alias: this.alias,
+        name: snap.status as 'STOPPED' | 'DISCONNECTED' | 'SYNCING' | 'SYNCED'
+      })
+    }
+
+    onTransactionsChanged({ transactions: snap.transactions })
+    onUpdate({
+      alias: this.alias,
+      scanProgress: snap.scanProgress,
+      networkBlockHeight: snap.networkBlockHeight
+    })
+
+    const delay = snap.status === 'SYNCING' ? 500 : 2000
+    this.timer = setTimeout(() => {
+      this.pump().catch(error => {
+        this.callbacks?.onError({
+          alias: this.alias,
+          level: 'error',
+          message: `event pump failed: ${String(error)}`
+        })
+      })
+    }, delay)
+  }
+}
+
+export const makeSynchronizer = async (
+  config: InitializerConfig
+): Promise<Synchronizer> => {
+  const synchronizer = new Synchronizer(config.alias, config.network)
+  await synchronizer.initialize(config)
+  return synchronizer
+}

package/src/types.ts

@@ -0,0 +1,88 @@
+export type Network = 'mainnet' | 'testnet'
+
+export interface ViewingKeySet {
+  fullViewingKey: string
+}
+
+export interface InitializerConfig {
+  network: Network
+  seedHex?: string
+  mnemonicSeed?: string
+  account: number
+  alias: string
+  dataDir: string
+  defaultHost: string
+  defaultPort: number
+}
+
+export interface ProposeTransferOpts {
+  toAddress: string
+  amountCredits: string
+  memo?: string
+}
+
+export interface CreateTransferOpts {
+  proposalId: string
+  mnemonicSeed: string
+}
+
+export interface ProposalSuccess {
+  proposalId: string
+  feeCredits: string
+}
+
+export interface SpendSuccess {
+  txid: string
+}
+
+export interface SpendFailure {
+  errorMessage?: string
+}
+
+export interface BalanceEvent {
+  availableCredits: string
+  totalCredits: string
+}
+
+export interface StatusEvent {
+  alias: string
+  name: 'STOPPED' | 'DISCONNECTED' | 'SYNCING' | 'SYNCED'
+}
+
+export interface DashShieldedTx {
+  txid: string
+  blockTimeInSeconds: number
+  minedHeight: number
+  value: string
+  fee?: string
+  toAddress?: string
+  memos: string[]
+}
+
+export interface TransactionEvent {
+  transactions: DashShieldedTx[]
+}
+
+export interface UpdateEvent {
+  alias: string
+  scanProgress: number
+  networkBlockHeight: number
+}
+
+export interface ErrorEvent {
+  alias: string
+  level: 'critical' | 'error'
+  message: string
+}
+
+export interface SynchronizerCallbacks {
+  onBalanceChanged(balance: BalanceEvent): void
+  onStatusChanged(status: StatusEvent): void
+  onTransactionsChanged(transactions: TransactionEvent): void
+  onUpdate(event: UpdateEvent): void
+  onError(error: ErrorEvent): void
+}
+
+export interface Addresses {
+  shieldedAddress: string
+}