react-native-pirate-wallet 0.2.1

package/scripts/verify-package.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const packageRoot = path.resolve(__dirname, '..');
+
+function fail(message) {
+  console.error(`[react-native-pirate-wallet] ${message}`);
+  process.exitCode = 1;
+}
+
+function requireFile(relativePath) {
+  const absolutePath = path.join(packageRoot, relativePath);
+  if (!fs.statSync(absolutePath, {throwIfNoEntry: false})?.isFile()) {
+    fail(`Required package file is missing: ${relativePath}`);
+    return;
+  }
+  if (fs.statSync(absolutePath).size === 0) {
+    fail(`Required package file is empty: ${relativePath}`);
+  }
+}
+
+function rejectPath(relativePath) {
+  if (fs.existsSync(path.join(packageRoot, relativePath))) {
+    fail(`Generated build path must not be published: ${relativePath}`);
+  }
+}
+
+function collectFiles(directory) {
+  if (!fs.statSync(directory, {throwIfNoEntry: false})?.isDirectory()) {
+    return [];
+  }
+
+  return fs.readdirSync(directory, {withFileTypes: true}).flatMap(entry => {
+    const entryPath = path.join(directory, entry.name);
+    return entry.isDirectory() ? collectFiles(entryPath) : [entryPath];
+  });
+}
+
+const packageJson = JSON.parse(
+  fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'),
+);
+
+if (packageJson.name !== 'react-native-pirate-wallet') {
+  fail(`Unexpected package name: ${packageJson.name}`);
+}
+if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(packageJson.version)) {
+  fail(`Package version is not valid semantic versioning: ${packageJson.version}`);
+}
+if (packageJson.private === true) {
+  fail('The publishable package must not be marked private');
+}
+if (packageJson.repository?.url !== 'https://github.com/PirateNetwork/Pirate-Unified-Light-Wallet.git') {
+  fail('The repository URL must match the GitHub repository used for npm provenance');
+}
+if (packageJson.publishConfig?.access !== 'public') {
+  fail('publishConfig.access must remain public');
+}
+
+[
+  'LICENSE-MIT',
+  'README.md',
+  'react-native.config.js',
+  'react-native-pirate-wallet.podspec',
+  'scripts/assemble-ios-framework.js',
+  'scripts/resolve-android-packages.js',
+  'test/smoke.js',
+  'src/index.js',
+  'src/index.d.ts',
+  'android/src/main/AndroidManifest.xml',
+  'android/src/main/java/com/pirate/wallet/reactnative/PirateWalletReactNativeModule.kt',
+  'ios/PirateWalletReactNative.m',
+  'ios/PirateWalletReactNative.swift',
+].forEach(requireFile);
+
+if (process.argv.includes('--publish-layout')) {
+  [
+    'android/.gradle',
+    'android/build',
+    'android/src/main/jniLibs',
+    'ios/Frameworks/PirateWalletNative.xcframework',
+  ].forEach(rejectPath);
+}
+
+const binaryPackageNames = [
+  'react-native-pirate-wallet-android',
+  'react-native-pirate-wallet-android-x86_64',
+  'react-native-pirate-wallet-ios-device',
+  'react-native-pirate-wallet-ios-simulator',
+];
+for (const binaryPackageName of binaryPackageNames) {
+  if (
+    packageJson.optionalDependencies?.[binaryPackageName] !== packageJson.version
+  ) {
+    fail(`${binaryPackageName} must use the same exact version as the wrapper`);
+  }
+}
+
+if (
+  !process.argv.includes('--publish-layout') &&
+  (process.platform === 'darwin' || process.argv.includes('--all-platforms'))
+) {
+  const staticLibraries = collectFiles(
+    path.join(packageRoot, 'ios', 'Frameworks', 'PirateWalletNative.xcframework'),
+  ).filter(file => file.endsWith('.a'));
+  if (staticLibraries.length !== 2) {
+    fail('The iOS XCFramework must contain device and simulator static libraries');
+  }
+  for (const library of staticLibraries) {
+    if (fs.statSync(library).size === 0) {
+      fail(`The iOS static library is empty: ${path.relative(packageRoot, library)}`);
+    }
+  }
+}
+
+try {
+  const {resolveAndroidJniLibsPaths} = require('./resolve-android-packages');
+  if (resolveAndroidJniLibsPaths().length !== 2) {
+    fail('Both Android binary packages must resolve');
+  }
+} catch (error) {
+  fail(error.message);
+}
+
+if (process.exitCode) {
+  process.exit(process.exitCode);
+}

package/src/index.d.ts

@@ -0,0 +1,245 @@
+export type SyncMode = 'Compact' | 'Deep'
+export type SynchronizerStatus = 'STOPPED' | 'SYNCING' | 'SYNCED'
+export type AmountString = string
+export type AmountInput = AmountString | number | bigint
+export type MnemonicLanguage =
+  | 'english'
+  | 'chinese_simplified'
+  | 'chinese_traditional'
+  | 'french'
+  | 'italian'
+  | 'japanese'
+  | 'korean'
+  | 'spanish'
+
+export interface MnemonicInspection {
+  isValid: boolean
+  detectedLanguage: MnemonicLanguage | null
+  ambiguousLanguages: MnemonicLanguage[]
+  wordCount: number
+}
+
+export interface WalletMeta {
+  id: string
+  name: string
+  createdAt: number
+  watchOnly: boolean
+  birthdayHeight: number
+  networkType?: 'mainnet' | 'testnet' | 'regtest' | null
+}
+
+export interface SynchronizerConfig {
+  syncMode?: SyncMode
+  syncingPollIntervalMs?: number
+  syncedPollIntervalMs?: number
+  errorPollIntervalMs?: number
+  transactionLimit?: number | null
+}
+
+export interface PirateWalletAccountStorageConfig {
+  accountId: string
+  passphrase: string
+  storagePath?: string | null
+}
+
+export interface SynchronizerSnapshot {
+  walletId: string
+  alias: string
+  status: SynchronizerStatus
+  progressPercent: number
+  syncStatus: any
+  latestBirthdayHeight: number | null
+  balance: Balance | null
+  transactions: TransactionInfo[]
+  updatedAtMillis: number | null
+  lastError: Error | null
+}
+
+export interface SynchronizerCallbacks {
+  onStatusChanged?(event: { walletId: string; alias: string; name: SynchronizerStatus }): void
+  onUpdate?(snapshot: SynchronizerSnapshot): void
+  onError?(error: Error): void
+}
+
+export interface PaymentDisclosure {
+  disclosureType: 'sapling' | 'ironwood' | string
+  txid: string
+  outputIndex: number
+  address: string
+  amount: AmountString
+  memo: string | null
+  disclosure: string
+}
+
+export interface PaymentDisclosureVerification {
+  disclosureType: 'sapling' | 'ironwood' | string
+  txid: string
+  outputIndex: number
+  address: string
+  amount: AmountString
+  memo: string | null
+  memoHex: string
+}
+
+export interface TransactionOutput {
+  addr: string
+  amount: AmountInput
+  memo?: string | null
+}
+
+export interface Balance {
+  total: AmountString
+  spendable: AmountString
+  pending: AmountString
+}
+
+export interface ShieldedPoolBalances {
+  sapling: Balance
+  ironwood: Balance
+}
+
+export interface TransactionInfo {
+  txid: string
+  height: number | null
+  timestamp: number
+  amount: AmountString
+  fee: AmountString
+  memo: string | null
+  confirmed: boolean
+}
+
+export interface TransactionRecipient {
+  address: string
+  pool: string
+  amount: AmountString
+  outputIndex: number
+  memo: string | null
+  paymentDisclosure?: string | null
+}
+
+export interface TransactionDetails {
+  txid: string
+  height: number | null
+  timestamp: number
+  amount: AmountString
+  fee: AmountString
+  confirmed: boolean
+  memo: string | null
+  recipients: TransactionRecipient[]
+}
+
+export interface PendingTransaction {
+  id: string
+  outputs: TransactionOutput[]
+  totalAmount: AmountString
+  fee: AmountString
+  change: AmountString
+  inputTotal: AmountString
+  numInputs: number
+  expiryHeight: number
+  createdAt: number
+}
+
+export interface FeeInfo {
+  defaultFee: AmountString
+  minFee: AmountString
+  maxFee: AmountString
+  feePerOutput: AmountString
+  memoFeeMultiplier: number
+}
+
+export class PirateWalletAdvancedKeyManagement {
+  listKeyGroups(walletId: string): Promise<any[]>
+  exportKeyGroupKeys(walletId: string, keyId: number): Promise<any>
+  importSpendingKey(
+    requestOrWalletId: any,
+    birthdayHeight?: number | null,
+    saplingSpendingKey?: string | null,
+    ironwoodSpendingKey?: string | null
+  ): Promise<number>
+  exportSeed(walletId: string, mnemonicLanguage?: MnemonicLanguage | null): Promise<string>
+}
+
+export class PirateWalletSynchronizer {
+  constructor(sdk: PirateWalletSdk, walletId: string, config?: SynchronizerConfig)
+  walletId: string
+  config: SynchronizerConfig
+  status: SynchronizerStatus
+  progress: number
+  syncStatus: any
+  latestBirthdayHeight: number | null
+  balance: any
+  transactions: any[]
+  lastError: Error | null
+  currentSnapshot(): SynchronizerSnapshot
+  isRunning(): boolean
+  isSyncing(): boolean
+  isComplete(): boolean
+  start(): Promise<void>
+  stop(): Promise<void>
+  refresh(): Promise<SynchronizerSnapshot>
+  close(): Promise<void>
+  subscribe(callbacks?: SynchronizerCallbacks): () => void
+}
+
+export class PirateWalletSdk {
+  advancedKeyManagement: PirateWalletAdvancedKeyManagement
+  invoke(requestJson: string, pretty?: boolean): Promise<string>
+  configureAccountStorage(config: PirateWalletAccountStorageConfig): Promise<any>
+  createSynchronizer(walletId: string, config?: SynchronizerConfig): PirateWalletSynchronizer
+  buildInfoJson(pretty?: boolean): Promise<string>
+  buildInfo(): Promise<any>
+  walletRegistryExists(): Promise<boolean>
+  listWallets(): Promise<WalletMeta[]>
+  getActiveWalletId(): Promise<string | null>
+  getActiveWallet(): Promise<WalletMeta | null>
+  getWallet(walletId: string): Promise<WalletMeta | null>
+  createWallet(requestOrName: any, birthdayHeight?: number | null, mnemonicLanguage?: MnemonicLanguage | null): Promise<string>
+  restoreWallet(requestOrName: any, mnemonic?: string, birthdayHeight?: number | null, mnemonicLanguage?: MnemonicLanguage | null): Promise<string>
+  importViewingWallet(requestOrName: any, saplingViewingKey?: string | null, ironwoodViewingKey?: string | null, birthdayHeight?: number): Promise<string>
+  switchWallet(walletId: string): Promise<any>
+  renameWallet(walletId: string, newName: string): Promise<any>
+  deleteWallet(walletId: string): Promise<any>
+  setWalletBirthdayHeight(walletId: string, birthdayHeight: number): Promise<any>
+  getLatestBirthdayHeight(walletId: string): Promise<number | null>
+  generateMnemonic(wordCount?: number | null, mnemonicLanguage?: MnemonicLanguage | null): Promise<string>
+  validateMnemonic(mnemonic: string, mnemonicLanguage?: MnemonicLanguage | null): Promise<boolean>
+  inspectMnemonic(mnemonic: string): Promise<MnemonicInspection>
+  getNetworkInfo(): Promise<any>
+  isValidShieldedAddr(address: string): Promise<boolean>
+  validateAddress(address: string): Promise<any>
+  validateConsensusBranch(walletId: string): Promise<any>
+  formatAmount(arrrtoshis: AmountInput): Promise<string>
+  parseAmount(arrr: string): Promise<AmountString>
+  getCurrentReceiveAddress(walletId: string): Promise<string>
+  getCurrentAddress(walletId: string): Promise<string>
+  getNextReceiveAddress(walletId: string): Promise<string>
+  getNextAddress(walletId: string): Promise<string>
+  listAddresses(walletId: string): Promise<any[]>
+  listAddressBalances(walletId: string, keyId?: number | null): Promise<any[]>
+  getBalance(walletId: string): Promise<Balance>
+  getShieldedPoolBalances(walletId: string): Promise<ShieldedPoolBalances>
+  getSpendabilityStatus(walletId: string): Promise<any>
+  listTransactions(walletId: string, limit?: number | null): Promise<TransactionInfo[]>
+  fetchTransactionMemo(walletId: string, txId: string, outputIndex?: number | null): Promise<string | null>
+  getTransactionDetails(walletId: string, txId: string): Promise<TransactionDetails | null>
+  exportPaymentDisclosures(walletId: string, txId: string): Promise<PaymentDisclosure[]>
+  exportSaplingPaymentDisclosure(walletId: string, txId: string, outputIndex: number): Promise<string>
+  exportIronwoodPaymentDisclosure(walletId: string, txId: string, actionIndex: number): Promise<string>
+  verifyPaymentDisclosure(walletId: string, disclosure: string): Promise<PaymentDisclosureVerification>
+  getFeeInfo(): Promise<FeeInfo>
+  startSync(walletIdOrRequest: any, mode?: SyncMode): Promise<any>
+  getSyncStatus(walletId: string): Promise<any>
+  cancelSync(walletId: string): Promise<any>
+  rescan(walletIdOrRequest: any, fromHeight?: number | null): Promise<any>
+  buildTransaction(walletIdOrRequest: any, outputs?: TransactionOutput | TransactionOutput[] | null, fee?: AmountInput | null): Promise<PendingTransaction>
+  signTransaction(walletId: string, pending: PendingTransaction): Promise<any>
+  broadcastTransaction(signed: any): Promise<string>
+  send(walletId: string, outputsOrOutput: TransactionOutput | TransactionOutput[], fee?: AmountInput | null): Promise<string>
+  exportSaplingViewingKey(walletId: string): Promise<string>
+  exportIronwoodViewingKey(walletId: string): Promise<string>
+  importSaplingViewingKeyAsWatchOnly(requestOrName: any, saplingViewingKey?: string | null, birthdayHeight?: number | null): Promise<string>
+  getWatchOnlyCapabilities(walletId: string): Promise<any>
+}
+
+export function createPirateWalletSdk(): PirateWalletSdk