forked from MrCyjaneK/monero.dart
-
Notifications
You must be signed in to change notification settings - Fork 1
/
wownero_wallet2_api_c.h
1017 lines (988 loc) · 62.4 KB
/
wownero_wallet2_api_c.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
#include <android/log.h>
#define LOG_TAG "[NDK]"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
*/
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <unistd.h>
#ifdef __cplusplus
extern "C"
{
#endif
#ifdef __MINGW32__
#define ADDAPI __declspec(dllexport)
#else
#define ADDAPI __attribute__((__visibility__("default")))
#endif
// namespace Monero {
// enum NetworkType : uint8_t {
// MAINNET = 0,
const int NetworkType_MAINNET = 0;
// TESTNET,
const int NetworkType_TESTNET = 1;
// STAGENET
const int NetworkType_STAGENET = 2;
// };
// namespace Utils {
// bool isAddressLocal(const std::string &hostaddr);
// void onStartup();
// }
// template<typename T>
// class optional {
// public:
// optional(): set(false) {}
// optional(const T &t): t(t), set(true) {}
// const T &operator*() const { return t; }
// T &operator*() { return t; }
// operator bool() const { return set; }
// private:
// T t;
// bool set;
// };
// struct PendingTransaction
// {
// enum Status {
// Status_Ok,
const int PendingTransactionStatus_Ok = 0;
// Status_Error,
const int PendingTransactionStatus_Error = 1;
// Status_Critical
const int PendingTransactionStatus_Critical = 2;
// };
// enum Priority {
// Priority_Default = 0,
const int Priority_Default = 0;
// Priority_Low = 1,
const int Priority_Low = 1;
// Priority_Medium = 2,
const int Priority_Medium = 2;
// Priority_High = 3,
const int Priority_High = 3;
// Priority_Last
const int Priority_Last = 4;
// };
// virtual ~PendingTransaction() = 0;
// virtual int status() const = 0;
extern ADDAPI int WOWNERO_PendingTransaction_status(void* pendingTx_ptr);
// virtual std::string errorString() const = 0;
extern ADDAPI const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr);
// virtual bool commit(const std::string &filename = "", bool overwrite = false) = 0;
extern ADDAPI bool WOWNERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite);
// virtual uint64_t amount() const = 0;
extern ADDAPI uint64_t WOWNERO_PendingTransaction_amount(void* pendingTx_ptr);
// virtual uint64_t dust() const = 0;
extern ADDAPI uint64_t WOWNERO_PendingTransaction_dust(void* pendingTx_ptr);
// virtual uint64_t fee() const = 0;
extern ADDAPI uint64_t WOWNERO_PendingTransaction_fee(void* pendingTx_ptr);
// virtual std::vector<std::string> txid() const = 0;
extern ADDAPI const char* WOWNERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator);
// virtual uint64_t txCount() const = 0;
extern ADDAPI uint64_t WOWNERO_PendingTransaction_txCount(void* pendingTx_ptr);
// virtual std::vector<uint32_t> subaddrAccount() const = 0;
extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator);
// virtual std::vector<std::set<uint32_t>> subaddrIndices() const = 0;
extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator);
// virtual std::string multisigSignData() = 0;
extern ADDAPI const char* WOWNERO_PendingTransaction_multisigSignData(void* pendingTx_ptr);
// virtual void signMultisigTx() = 0;
extern ADDAPI void WOWNERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr);
// virtual std::vector<std::string> signersKeys() const = 0;
extern ADDAPI const char* WOWNERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator);
// virtual std::vector<std::string> hex() const = 0;
extern ADDAPI const char* WOWNERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator);
// virtual std::vector<std::string> txKey() const = 0;
extern ADDAPI const char* WOWNERO_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator);
// };
// struct UnsignedTransaction
// {
// enum Status {
// Status_Ok,
const int UnsignedTransactionStatus_Ok = 0;
// Status_Error,
const int UnsignedTransactionStatus_Error = 1;
// Status_Critical
const int UnsignedTransactionStatus_Critical = 2;
// };
// virtual ~UnsignedTransaction() = 0;
// virtual int status() const = 0;
extern ADDAPI int WOWNERO_UnsignedTransaction_status(void* unsignedTx_ptr);
// virtual std::string errorString() const = 0;
extern ADDAPI const char* WOWNERO_UnsignedTransaction_errorString(void* unsignedTx_ptr);
// virtual std::vector<uint64_t> amount() const = 0;
extern ADDAPI const char* WOWNERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator);
// virtual std::vector<uint64_t> fee() const = 0;
extern ADDAPI const char* WOWNERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator);
// virtual std::vector<uint64_t> mixin() const = 0;
extern ADDAPI const char* WOWNERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator);
// virtual std::string confirmationMessage() const = 0;
extern ADDAPI const char* WOWNERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr);
// virtual std::vector<std::string> paymentId() const = 0;
extern ADDAPI const char* WOWNERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator);
// virtual std::vector<std::string> recipientAddress() const = 0;
extern ADDAPI const char* WOWNERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator);
// virtual uint64_t minMixinCount() const = 0;
extern ADDAPI uint64_t WOWNERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr);
// virtual uint64_t txCount() const = 0;
extern ADDAPI uint64_t WOWNERO_UnsignedTransaction_txCount(void* unsignedTx_ptr);
// virtual bool sign(const std::string &signedFileName) = 0;
extern ADDAPI bool WOWNERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName);
// };
// struct TransactionInfo
// {
// enum Direction {
// Direction_In,
const int TransactionInfoDirection_In = 0;
// Direction_Out
const int TransactionInfoDirection_Out = 1;
// };
// struct Transfer {
// Transfer(uint64_t _amount, const std::string &address);
// const uint64_t amount;
// const std::string address;
// };
// virtual ~TransactionInfo() = 0;
// virtual int direction() const = 0;
extern ADDAPI int WOWNERO_TransactionInfo_direction(void* txInfo_ptr);
// virtual bool isPending() const = 0;
extern ADDAPI bool WOWNERO_TransactionInfo_isPending(void* txInfo_ptr);
// virtual bool isFailed() const = 0;
extern ADDAPI bool WOWNERO_TransactionInfo_isFailed(void* txInfo_ptr);
// virtual bool isCoinbase() const = 0;
extern ADDAPI bool WOWNERO_TransactionInfo_isCoinbase(void* txInfo_ptr);
// virtual uint64_t amount() const = 0;
extern ADDAPI uint64_t WOWNERO_TransactionInfo_amount(void* txInfo_ptr);
// virtual uint64_t fee() const = 0;
extern ADDAPI uint64_t WOWNERO_TransactionInfo_fee(void* txInfo_ptr);
// virtual uint64_t blockHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_TransactionInfo_blockHeight(void* txInfo_ptr);
// virtual std::string description() const = 0;
extern ADDAPI const char* WOWNERO_TransactionInfo_description(void* txInfo_ptr);
// virtual std::set<uint32_t> subaddrIndex() const = 0;
extern ADDAPI const char* WOWNERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator);
// virtual uint32_t subaddrAccount() const = 0;
extern ADDAPI uint32_t WOWNERO_TransactionInfo_subaddrAccount(void* txInfo_ptr);
// virtual std::string label() const = 0;
extern ADDAPI const char* WOWNERO_TransactionInfo_label(void* txInfo_ptr);
// virtual uint64_t confirmations() const = 0;
extern ADDAPI uint64_t WOWNERO_TransactionInfo_confirmations(void* txInfo_ptr);
// virtual uint64_t unlockTime() const = 0;
extern ADDAPI uint64_t WOWNERO_TransactionInfo_unlockTime(void* txInfo_ptr);
// virtual std::string hash() const = 0;
extern ADDAPI const char* WOWNERO_TransactionInfo_hash(void* txInfo_ptr);
// virtual std::time_t timestamp() const = 0;
extern ADDAPI uint64_t WOWNERO_TransactionInfo_timestamp(void* txInfo_ptr);
// virtual std::string paymentId() const = 0;
extern ADDAPI const char* WOWNERO_TransactionInfo_paymentId(void* txInfo_ptr);
// virtual const std::vector<Transfer> & transfers() const = 0;
extern ADDAPI int WOWNERO_TransactionInfo_transfers_count(void* txInfo_ptr);
extern ADDAPI uint64_t WOWNERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index);
extern ADDAPI const char* WOWNERO_TransactionInfo_transfers_address(void* txInfo_ptr, int address);
// };
// struct TransactionHistory
// {
// virtual ~TransactionHistory() = 0;
// virtual int count() const = 0;
extern ADDAPI int WOWNERO_TransactionHistory_count(void* txHistory_ptr);
// virtual TransactionInfo * transaction(int index) const = 0;
extern ADDAPI void* WOWNERO_TransactionHistory_transaction(void* txHistory_ptr, int index);
// virtual TransactionInfo * transaction(const std::string &id) const = 0;
extern ADDAPI void* WOWNERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id);
// virtual std::vector<TransactionInfo*> getAll() const = 0;
// virtual void refresh() = 0;
extern ADDAPI void WOWNERO_TransactionHistory_refresh(void* txHistory_ptr);
// virtual void setTxNote(const std::string &txid, const std::string ¬e) = 0;
extern ADDAPI void WOWNERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note);
// };
// struct AddressBookRow {
// public:
// AddressBookRow(std::size_t _rowId, const std::string &_address, const std::string &_paymentId, const std::string &_description):
// m_rowId(_rowId),
// m_address(_address),
// m_paymentId(_paymentId),
// m_description(_description) {}
// private:
// std::size_t m_rowId;
// std::string m_address;
// std::string m_paymentId;
// std::string m_description;
// public:
// std::string extra;
extern ADDAPI const char* WOWNERO_AddressBookRow_extra(void* addressBookRow_ptr);
// std::string getAddress() const {return m_address;}
extern ADDAPI const char* WOWNERO_AddressBookRow_getAddress(void* addressBookRow_ptr);
// std::string getDescription() const {return m_description;}
extern ADDAPI const char* WOWNERO_AddressBookRow_getDescription(void* addressBookRow_ptr);
// std::string getPaymentId() const {return m_paymentId;}
extern ADDAPI const char* WOWNERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr);
// std::size_t getRowId() const {return m_rowId;}
extern ADDAPI size_t WOWNERO_AddressBookRow_getRowId(void* addressBookRow_ptr);
// };
// struct AddressBook
// {
// enum ErrorCode {
// Status_Ok,
const int AddressBookErrorCodeStatus_Ok = 0;
// General_Error,
const int AddressBookErrorCodeGeneral_Error = 1;
// Invalid_Address,
const int AddressBookErrorCodeInvalid_Address = 2;
// Invalid_Payment_Id
const int AddressBookErrorCodeInvalidPaymentId = 3;
// };
// virtual ~AddressBook() = 0;
// virtual std::vector<AddressBookRow*> getAll() const = 0;
extern ADDAPI int WOWNERO_AddressBook_getAll_size(void* addressBook_ptr);
extern ADDAPI void* WOWNERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index);
// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0;
extern ADDAPI bool WOWNERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description);
// virtual bool deleteRow(std::size_t rowId) = 0;
extern ADDAPI bool WOWNERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId);
// virtual bool setDescription(std::size_t index, const std::string &description) = 0;
extern ADDAPI bool WOWNERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description);
// virtual void refresh() = 0;
extern ADDAPI void WOWNERO_AddressBook_refresh(void* addressBook_ptr);
// virtual std::string errorString() const = 0;
extern ADDAPI const char* WOWNERO_AddressBook_errorString(void* addressBook_ptr);
// virtual int errorCode() const = 0;
extern ADDAPI int WOWNERO_AddressBook_errorCode(void* addressBook_ptr);
// virtual int lookupPaymentID(const std::string &payment_id) const = 0;
extern ADDAPI int WOWNERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id);
// };
// struct CoinsInfo
// {
// virtual ~CoinsInfo() = 0;
// virtual uint64_t blockHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_CoinsInfo_blockHeight(void* coinsInfo_ptr);
// virtual std::string hash() const = 0;
extern ADDAPI const char* WOWNERO_CoinsInfo_hash(void* coinsInfo_ptr);
// virtual size_t internalOutputIndex() const = 0;
extern ADDAPI size_t WOWNERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr);
// virtual uint64_t globalOutputIndex() const = 0;
extern ADDAPI uint64_t WOWNERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr);
// virtual bool spent() const = 0;
extern ADDAPI bool WOWNERO_CoinsInfo_spent(void* coinsInfo_ptr);
// virtual bool frozen() const = 0;
extern ADDAPI bool WOWNERO_CoinsInfo_frozen(void* coinsInfo_ptr);
// virtual uint64_t spentHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_CoinsInfo_spentHeight(void* coinsInfo_ptr);
// virtual uint64_t amount() const = 0;
extern ADDAPI uint64_t WOWNERO_CoinsInfo_amount(void* coinsInfo_ptr);
// virtual bool rct() const = 0;
extern ADDAPI bool WOWNERO_CoinsInfo_rct(void* coinsInfo_ptr);
// virtual bool keyImageKnown() const = 0;
extern ADDAPI bool WOWNERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr);
// virtual size_t pkIndex() const = 0;
extern ADDAPI size_t WOWNERO_CoinsInfo_pkIndex(void* coinsInfo_ptr);
// virtual uint32_t subaddrIndex() const = 0;
extern ADDAPI uint32_t WOWNERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr);
// virtual uint32_t subaddrAccount() const = 0;
extern ADDAPI uint32_t WOWNERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr);
// virtual std::string address() const = 0;
extern ADDAPI const char* WOWNERO_CoinsInfo_address(void* coinsInfo_ptr);
// virtual std::string addressLabel() const = 0;
extern ADDAPI const char* WOWNERO_CoinsInfo_addressLabel(void* coinsInfo_ptr);
// virtual std::string keyImage() const = 0;
extern ADDAPI const char* WOWNERO_CoinsInfo_keyImage(void* coinsInfo_ptr);
// virtual uint64_t unlockTime() const = 0;
extern ADDAPI uint64_t WOWNERO_CoinsInfo_unlockTime(void* coinsInfo_ptr);
// virtual bool unlocked() const = 0;
extern ADDAPI bool WOWNERO_CoinsInfo_unlocked(void* coinsInfo_ptr);
// virtual std::string pubKey() const = 0;
extern ADDAPI const char* WOWNERO_CoinsInfo_pubKey(void* coinsInfo_ptr);
// virtual bool coinbase() const = 0;
extern ADDAPI bool WOWNERO_CoinsInfo_coinbase(void* coinsInfo_ptr);
// virtual std::string description() const = 0;
extern ADDAPI const char* WOWNERO_CoinsInfo_description(void* coinsInfo_ptr);
// };
// struct Coins
// {
// virtual ~Coins() = 0;
// virtual int count() const = 0;
extern ADDAPI int WOWNERO_Coins_count(void* coins_ptr);
// virtual CoinsInfo * coin(int index) const = 0;
extern ADDAPI void* WOWNERO_Coins_coin(void* coins_ptr, int index);
// virtual std::vector<CoinsInfo*> getAll() const = 0;
extern ADDAPI int WOWNERO_Coins_getAll_size(void* coins_ptr);
extern ADDAPI void* WOWNERO_Coins_getAll_byIndex(void* coins_ptr, int index);
// virtual void refresh() = 0;
extern ADDAPI void WOWNERO_Coins_refresh(void* coins_ptr);
// virtual void setFrozen(std::string public_key) = 0;
extern ADDAPI void WOWNERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key);
// virtual void setFrozen(int index) = 0;
extern ADDAPI void WOWNERO_Coins_setFrozen(void* coins_ptr, int index);
// virtual void thaw(int index) = 0;
extern ADDAPI void WOWNERO_Coins_thaw(void* coins_ptr, int index);
// virtual void thaw(std::string public_key) = 0;
extern ADDAPI void WOWNERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key);
// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0;
extern ADDAPI bool WOWNERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight);
// virtual void setDescription(const std::string &public_key, const std::string &description) = 0;
extern ADDAPI void WOWNERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description);
// };
// struct SubaddressRow {
// public:
// SubaddressRow(std::size_t _rowId, const std::string &_address, const std::string &_label):
// m_rowId(_rowId),
// m_address(_address),
// m_label(_label) {}
// private:
// std::size_t m_rowId;
// std::string m_address;
// std::string m_label;
// public:
// std::string extra;
extern ADDAPI const char* WOWNERO_SubaddressRow_extra(void* subaddressRow_ptr);
// std::string getAddress() const {return m_address;}
extern ADDAPI const char* WOWNERO_SubaddressRow_getAddress(void* subaddressRow_ptr);
// std::string getLabel() const {return m_label;}
extern ADDAPI const char* WOWNERO_SubaddressRow_getLabel(void* subaddressRow_ptr);
// std::size_t getRowId() const {return m_rowId;}
extern ADDAPI size_t WOWNERO_SubaddressRow_getRowId(void* subaddressRow_ptr);
// };
// struct Subaddress
// {
// virtual ~Subaddress() = 0;
// virtual std::vector<SubaddressRow*> getAll() const = 0;
extern ADDAPI int WOWNERO_Subaddress_getAll_size(void* subaddress_ptr);
extern ADDAPI void* WOWNERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index);
// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0;
extern ADDAPI void WOWNERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label);
// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0;
extern ADDAPI void WOWNERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label);
// virtual void refresh(uint32_t accountIndex) = 0;
extern ADDAPI void WOWNERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex);
// };
// struct SubaddressAccountRow {
// public:
// SubaddressAccountRow(std::size_t _rowId, const std::string &_address, const std::string &_label, const std::string &_balance, const std::string &_unlockedBalance):
// m_rowId(_rowId),
// m_address(_address),
// m_label(_label),
// m_balance(_balance),
// m_unlockedBalance(_unlockedBalance) {}
// private:
// std::size_t m_rowId;
// std::string m_address;
// std::string m_label;
// std::string m_balance;
// std::string m_unlockedBalance;
// public:
// std::string extra;
extern ADDAPI const char* WOWNERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr);
// std::string getAddress() const {return m_address;}
extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr);
// std::string getLabel() const {return m_label;}
extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr);
// std::string getBalance() const {return m_balance;}
extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr);
// std::string getUnlockedBalance() const {return m_unlockedBalance;}
extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr);
// std::size_t getRowId() const {return m_rowId;}
extern ADDAPI size_t WOWNERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr);
// };
// struct SubaddressAccount
// {
// virtual ~SubaddressAccount() = 0;
// virtual std::vector<SubaddressAccountRow*> getAll() const = 0;
extern ADDAPI int WOWNERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr);
extern ADDAPI void* WOWNERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index);
// virtual void addRow(const std::string &label) = 0;
extern ADDAPI void WOWNERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label);
// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0;
extern ADDAPI void WOWNERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label);
// virtual void refresh() = 0;
extern ADDAPI void WOWNERO_SubaddressAccount_refresh(void* subaddressAccount_ptr);
// };
// struct MultisigState {
// MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {}
// bool isMultisig;
extern ADDAPI bool WOWNERO_MultisigState_isMultisig(void* multisigState_ptr);
// bool isReady;
extern ADDAPI bool WOWNERO_MultisigState_isReady(void* multisigState_ptr);
// uint32_t threshold;
extern ADDAPI uint32_t WOWNERO_MultisigState_threshold(void* multisigState_ptr);
// uint32_t total;
extern ADDAPI uint32_t WOWNERO_MultisigState_total(void* multisigState_ptr);
// };
// struct DeviceProgress {
// DeviceProgress(): m_progress(0), m_indeterminate(false) {}
// DeviceProgress(double progress, bool indeterminate=false): m_progress(progress), m_indeterminate(indeterminate) {}
// virtual double progress() const { return m_progress; }
extern ADDAPI bool WOWNERO_DeviceProgress_progress(void* deviceProgress_ptr);
// virtual bool indeterminate() const { return m_indeterminate; }
extern ADDAPI bool WOWNERO_DeviceProgress_indeterminate(void* deviceProgress_ptr);
// protected:
// double m_progress;
// bool m_indeterminate;
// };
// struct Wallet;
// struct WalletListener
// {
// virtual ~WalletListener() = 0;
// virtual void moneySpent(const std::string &txId, uint64_t amount) = 0;
// virtual void moneyReceived(const std::string &txId, uint64_t amount) = 0;
// virtual void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) = 0;
// virtual void newBlock(uint64_t height) = 0;
// virtual void updated() = 0;
// virtual void refreshed() = 0;
// virtual void onDeviceButtonRequest(uint64_t code) { (void)code; }
// virtual void onDeviceButtonPressed() { }
// virtual optional<std::string> onDevicePinRequest() {
// throw std::runtime_error("Not supported");
// }
// virtual optional<std::string> onDevicePassphraseRequest(bool & on_device) {
// on_device = true;
// return optional<std::string>();
// }
// virtual void onDeviceProgress(const DeviceProgress & event) { (void)event; };
// virtual void onSetWallet(Wallet * wallet) { (void)wallet; };
// };
// struct Wallet
// {
// enum Device {
// Device_Software = 0,
const int WalletDevice_Software = 0;
// Device_Ledger = 1,
const int WalletDevice_Ledger = 1;
// Device_Trezor = 2
const int WalletDevice_Trezor = 2;
// };
// enum Status {
// Status_Ok,
const int WalletStatus_Ok = 0;
// Status_Error,
const int WalletStatus_Error = 1;
// Status_Critical
const int WalletStatus_Critical = 2;
// };
// enum ConnectionStatus {
// ConnectionStatus_Disconnected,
const int WalletConnectionStatus_Disconnected = 0;
// ConnectionStatus_Connected,
const int WalletConnectionStatus_Connected = 1;
// ConnectionStatus_WrongVersion
const int WalletConnectionStatus_WrongVersion = 2;
// };
// enum BackgroundSyncType {
// BackgroundSync_Off = 0,
const int WalletBackgroundSync_Off = 0;
// BackgroundSync_ReusePassword = 1,
const int WalletBackgroundSync_ReusePassword = 1;
// BackgroundSync_CustomPassword = 2
const int BackgroundSync_CustomPassword = 2;
// };
// virtual ~Wallet() = 0;
// virtual std::string seed(const std::string& seed_offset = "") const = 0;
extern ADDAPI const char* WOWNERO_Wallet_seed(void* wallet_ptr, const char* seed_offset);
// virtual std::string getSeedLanguage() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_getSeedLanguage(void* wallet_ptr);
// virtual void setSeedLanguage(const std::string &arg) = 0;
extern ADDAPI void WOWNERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg);
// virtual int status() const = 0;
extern ADDAPI int WOWNERO_Wallet_status(void* wallet_ptr);
// virtual std::string errorString() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_errorString(void* wallet_ptr);
// virtual void statusWithErrorString(int& status, std::string& errorString) const = 0;
// virtual bool setPassword(const std::string &password) = 0;
extern ADDAPI bool WOWNERO_Wallet_setPassword(void* wallet_ptr, const char* password);
// virtual const std::string& getPassword() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_getPassword(void* wallet_ptr);
// virtual bool setDevicePin(const std::string &pin) { (void)pin; return false; };
extern ADDAPI bool WOWNERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin);
// virtual bool setDevicePassphrase(const std::string &passphrase) { (void)passphrase; return false; };
extern ADDAPI bool WOWNERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase);
// virtual std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const = 0;
extern ADDAPI const char* WOWNERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex);
// std::string mainAddress() const { return address(0, 0); }
// virtual std::string path() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_path(void* wallet_ptr);
// virtual NetworkType nettype() const = 0;
extern ADDAPI int WOWNERO_Wallet_nettype(void* wallet_ptr);
// bool mainnet() const { return nettype() == MAINNET; }
// bool testnet() const { return nettype() == TESTNET; }
// bool stagenet() const { return nettype() == STAGENET; }
// virtual void hardForkInfo(uint8_t &version, uint64_t &earliest_height) const = 0;
// virtual bool useForkRules(uint8_t version, int64_t early_blocks) const = 0;
extern ADDAPI uint8_t WOWNERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks);
// virtual std::string integratedAddress(const std::string &payment_id) const = 0;
extern ADDAPI const char* WOWNERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id);
// virtual std::string secretViewKey() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_secretViewKey(void* wallet_ptr);
// virtual std::string publicViewKey() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_publicViewKey(void* wallet_ptr);
// virtual std::string secretSpendKey() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_secretSpendKey(void* wallet_ptr);
// virtual std::string publicSpendKey() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_publicSpendKey(void* wallet_ptr);
// virtual std::string publicMultisigSignerKey() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_publicMultisigSignerKey(void* wallet_ptr);
// virtual void stop() = 0;
extern ADDAPI void WOWNERO_Wallet_stop(void* wallet_ptr);
// virtual bool store(const std::string &path) = 0;
extern ADDAPI bool WOWNERO_Wallet_store(void* wallet_ptr, const char* path);
// virtual std::string filename() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_filename(void* wallet_ptr);
// virtual std::string keysFilename() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_keysFilename(void* wallet_ptr);
// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0;
extern ADDAPI bool WOWNERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address);
// virtual bool createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const = 0;
extern ADDAPI bool WOWNERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language);
// virtual void setRefreshFromBlockHeight(uint64_t refresh_from_block_height) = 0;
extern ADDAPI void WOWNERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height);
// virtual uint64_t getRefreshFromBlockHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr);
// virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0;
extern ADDAPI void WOWNERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed);
// virtual void setRecoveringFromDevice(bool recoveringFromDevice) = 0;
extern ADDAPI void WOWNERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice);
// virtual void setSubaddressLookahead(uint32_t major, uint32_t minor) = 0;
extern ADDAPI void WOWNERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor);
// virtual bool connectToDaemon() = 0;
extern ADDAPI bool WOWNERO_Wallet_connectToDaemon(void* wallet_ptr);
// virtual ConnectionStatus connected() const = 0;
extern ADDAPI int WOWNERO_Wallet_connected(void* wallet_ptr);
// virtual void setTrustedDaemon(bool arg) = 0;
extern ADDAPI void WOWNERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg);
// virtual bool trustedDaemon() const = 0;
extern ADDAPI bool WOWNERO_Wallet_trustedDaemon(void* wallet_ptr);
// virtual bool setProxy(const std::string &address) = 0;
extern ADDAPI bool WOWNERO_Wallet_setProxy(void* wallet_ptr, const char* address);
// virtual uint64_t balance(uint32_t accountIndex = 0) const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex);
// uint64_t balanceAll() const {
// uint64_t result = 0;
// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i)
// result += balance(i);
// return result;
// }
// virtual uint64_t unlockedBalance(uint32_t accountIndex = 0) const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex);
// uint64_t unlockedBalanceAll() const {
// uint64_t result = 0;
// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i)
// result += unlockedBalance(i);
// return result;
// }
// virtual bool watchOnly() const = 0;
// virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector<std::string> &key_images = {}) const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex);
extern ADDAPI bool WOWNERO_Wallet_watchOnly(void* wallet_ptr);
// virtual bool isDeterministic() const = 0;
extern ADDAPI bool WOWNERO_Wallet_isDeterministic(void* wallet_ptr);
// virtual uint64_t blockChainHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_blockChainHeight(void* wallet_ptr);
// virtual uint64_t approximateBlockChainHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_approximateBlockChainHeight(void* wallet_ptr);
// virtual uint64_t estimateBlockChainHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_estimateBlockChainHeight(void* wallet_ptr);
// virtual uint64_t daemonBlockChainHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainHeight(void* wallet_ptr);
extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainHeight_cached(void* wallet_ptr);
extern ADDAPI void WOWNERO_Wallet_daemonBlockChainHeight_runThread(void* wallet_ptr, int seconds);
// virtual uint64_t daemonBlockChainTargetHeight() const = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr);
// virtual bool synchronized() const = 0;
extern ADDAPI bool WOWNERO_Wallet_synchronized(void* wallet_ptr);
// static std::string displayAmount(uint64_t amount);
extern ADDAPI const char* WOWNERO_Wallet_displayAmount(uint64_t amount);
// static uint64_t amountFromString(const std::string &amount);
extern ADDAPI uint64_t WOWNERO_Wallet_amountFromString(const char* amount);
// static uint64_t amountFromDouble(double amount);
extern ADDAPI uint64_t WOWNERO_Wallet_amountFromDouble(double amount);
// static std::string genPaymentId();
extern ADDAPI const char* WOWNERO_Wallet_genPaymentId();
// static bool paymentIdValid(const std::string &paiment_id);
extern ADDAPI bool WOWNERO_Wallet_paymentIdValid(const char* paiment_id);
// static bool addressValid(const std::string &str, NetworkType nettype);
extern ADDAPI bool WOWNERO_Wallet_addressValid(const char* str, int nettype);
// static bool addressValid(const std::string &str, bool testnet) // deprecated
// {
// return addressValid(str, testnet ? TESTNET : MAINNET);
// }
extern ADDAPI bool WOWNERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype);
extern ADDAPI const char* WOWNERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype);
// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, NetworkType nettype, std::string &error);
// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, bool testnet, std::string &error) // deprecated
// {
// return keyValid(secret_key_string, address_string, isViewKey, testnet ? TESTNET : MAINNET, error);
// }
// static std::string paymentIdFromAddress(const std::string &str, NetworkType nettype);
extern ADDAPI const char* WOWNERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype);
// static std::string paymentIdFromAddress(const std::string &str, bool testnet) // deprecated
// {
// return paymentIdFromAddress(str, testnet ? TESTNET : MAINNET);
// }
// static uint64_t maximumAllowedAmount();
extern ADDAPI uint64_t WOWNERO_Wallet_maximumAllowedAmount();
// static void init(const char *argv0, const char *default_log_base_name) { init(argv0, default_log_base_name, "", true); }
// static void init(const char *argv0, const char *default_log_base_name, const std::string &log_path, bool console);
extern ADDAPI void WOWNERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console);
// static void debug(const std::string &category, const std::string &str);
// static void info(const std::string &category, const std::string &str);
// static void warning(const std::string &category, const std::string &str);
// static void error(const std::string &category, const std::string &str);
// virtual void startRefresh() = 0;
// virtual bool getPolyseed(std::string &seed, std::string &passphrase) const = 0;
extern ADDAPI const char* WOWNERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase);
// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English");
extern ADDAPI const char* WOWNERO_Wallet_createPolyseed(const char* language);
extern ADDAPI void WOWNERO_Wallet_startRefresh(void* wallet_ptr);
// virtual void pauseRefresh() = 0;
extern ADDAPI void WOWNERO_Wallet_pauseRefresh(void* wallet_ptr);
// virtual bool refresh() = 0;
extern ADDAPI bool WOWNERO_Wallet_refresh(void* wallet_ptr);
// virtual void refreshAsync() = 0;
extern ADDAPI void WOWNERO_Wallet_refreshAsync(void* wallet_ptr);
// virtual bool rescanBlockchain() = 0;
extern ADDAPI bool WOWNERO_Wallet_rescanBlockchain(void* wallet_ptr);
// virtual void rescanBlockchainAsync() = 0;
extern ADDAPI void WOWNERO_Wallet_rescanBlockchainAsync(void* wallet_ptr);
// virtual void setAutoRefreshInterval(int millis) = 0;
extern ADDAPI void WOWNERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis);
// virtual int autoRefreshInterval() const = 0;
extern ADDAPI int WOWNERO_Wallet_autoRefreshInterval(void* wallet_ptr);
// virtual void addSubaddressAccount(const std::string& label) = 0;
extern ADDAPI void WOWNERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label);
// virtual size_t numSubaddressAccounts() const = 0;
extern ADDAPI size_t WOWNERO_Wallet_numSubaddressAccounts(void* wallet_ptr);
// virtual size_t numSubaddresses(uint32_t accountIndex) const = 0;
extern ADDAPI size_t WOWNERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex);
// virtual void addSubaddress(uint32_t accountIndex, const std::string& label) = 0;
extern ADDAPI void WOWNERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label);
// virtual std::string getSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex) const = 0;
extern ADDAPI const char* WOWNERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex);
// virtual void setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0;
extern ADDAPI void WOWNERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label);
// virtual MultisigState multisig() const = 0;
// virtual std::string getMultisigInfo() const = 0;
extern ADDAPI const char* WOWNERO_Wallet_getMultisigInfo(void* wallet_ptr);
// virtual std::string makeMultisig(const std::vector<std::string>& info, uint32_t threshold) = 0;
// virtual std::string exchangeMultisigKeys(const std::vector<std::string> &info, const bool force_update_use_with_caution) = 0;
// virtual bool exportMultisigImages(std::string& images) = 0;
// virtual size_t importMultisigImages(const std::vector<std::string>& images) = 0;
// virtual bool hasMultisigPartialKeyImages() const = 0;
// virtual PendingTransaction* restoreMultisigTransaction(const std::string& signData) = 0;
// virtual PendingTransaction * createTransactionMultDest(const std::vector<std::string> &dst_addr, const std::string &payment_id,
// optional<std::vector<uint64_t>> amount, uint32_t mixin_count,
// PendingTransaction::Priority = PendingTransaction::Priority_Low,
// uint32_t subaddr_account = 0,
// std::set<uint32_t> subaddr_indices = {}) = 0;
extern ADDAPI void* WOWNERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id,
bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count,
int pendingTransactionPriority,
uint32_t subaddr_account,
const char* preferredInputs, const char* preferredInputs_separator);
// virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id,
// optional<uint64_t> amount, uint32_t mixin_count,
// PendingTransaction::Priority = PendingTransaction::Priority_Low,
// uint32_t subaddr_account = 0,
// std::set<uint32_t> subaddr_indices = {},
// const std::set<std::string> &preferred_inputs = {) = 0;
extern ADDAPI void* WOWNERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id,
uint64_t amount, uint32_t mixin_count,
int pendingTransactionPriority,
uint32_t subaddr_account,
const char* preferredInputs, const char* separator);
// virtual PendingTransaction * createSweepUnmixableTransaction() = 0;
// virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0;
extern ADDAPI void* WOWNERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename);
// virtual bool submitTransaction(const std::string &fileName) = 0;
extern ADDAPI bool WOWNERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName);
// virtual void disposeTransaction(PendingTransaction * t) = 0;
// virtual uint64_t estimateTransactionFee(const std::vector<std::pair<std::string, uint64_t>> &destinations,
// PendingTransaction::Priority priority) const = 0;
// virtual bool hasUnknownKeyImages() const = 0;
extern ADDAPI bool WOWNERO_Wallet_hasUnknownKeyImages(void* wallet_ptr);
// virtual bool exportKeyImages(const std::string &filename, bool all = false) = 0;
extern ADDAPI bool WOWNERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all);
// virtual bool importKeyImages(const std::string &filename) = 0;
extern ADDAPI bool WOWNERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename);
// virtual bool exportOutputs(const std::string &filename, bool all = false) = 0;
extern ADDAPI bool WOWNERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all);
// virtual bool importOutputs(const std::string &filename) = 0;
extern ADDAPI bool WOWNERO_Wallet_importOutputs(void* wallet_ptr, const char* filename);
// virtual bool scanTransactions(const std::vector<std::string> &txids) = 0;
// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional<std::string> &background_cache_password) = 0;
extern ADDAPI bool WOWNERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password);
// virtual BackgroundSyncType getBackgroundSyncType() const = 0;
extern ADDAPI int WOWNERO_Wallet_getBackgroundSyncType(void* wallet_ptr);
// virtual bool startBackgroundSync() = 0;
extern ADDAPI bool WOWNERO_Wallet_startBackgroundSync(void* wallet_ptr);
// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0;
extern ADDAPI bool WOWNERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password);
// virtual bool isBackgroundSyncing() const = 0;
extern ADDAPI bool WOWNERO_Wallet_isBackgroundSyncing(void* wallet_ptr);
// virtual bool isBackgroundWallet() const = 0;
extern ADDAPI bool WOWNERO_Wallet_isBackgroundWallet(void* wallet_ptr);
// virtual TransactionHistory * history() = 0;
extern ADDAPI void* WOWNERO_Wallet_history(void* wallet_ptr);
// virtual AddressBook * addressBook() = 0;
extern ADDAPI void* WOWNERO_Wallet_addressBook(void* wallet_ptr);
// virtual Coins * coins() = 0;
extern ADDAPI void* WOWNERO_Wallet_coins(void* wallet_ptr);
// virtual Subaddress * subaddress() = 0;
extern ADDAPI void* WOWNERO_Wallet_subaddress(void* wallet_ptr);
// virtual SubaddressAccount * subaddressAccount() = 0;
extern ADDAPI void* WOWNERO_Wallet_subaddressAccount(void* wallet_ptr);
// virtual void setListener(WalletListener *) = 0;
// virtual uint32_t defaultMixin() const = 0;
extern ADDAPI uint32_t WOWNERO_Wallet_defaultMixin(void* wallet_ptr);
// virtual void setDefaultMixin(uint32_t arg) = 0;
extern ADDAPI void WOWNERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg);
// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0;
extern ADDAPI bool WOWNERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val);
// virtual std::string getCacheAttribute(const std::string &key) const = 0;
extern ADDAPI const char* WOWNERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key);
// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0;
extern ADDAPI bool WOWNERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note);
// virtual std::string getUserNote(const std::string &txid) const = 0;
extern ADDAPI const char* WOWNERO_Wallet_getUserNote(void* wallet_ptr, const char* txid);
// virtual std::string getTxKey(const std::string &txid) const = 0;
extern ADDAPI const char* WOWNERO_Wallet_getTxKey(void* wallet_ptr, const char* txid);
// virtual bool checkTxKey(const std::string &txid, std::string tx_key, const std::string &address, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0;
// virtual std::string getTxProof(const std::string &txid, const std::string &address, const std::string &message) const = 0;
// virtual bool checkTxProof(const std::string &txid, const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0;
// virtual std::string getSpendProof(const std::string &txid, const std::string &message) const = 0;
// virtual bool checkSpendProof(const std::string &txid, const std::string &message, const std::string &signature, bool &good) const = 0;
// virtual std::string getReserveProof(bool all, uint32_t account_index, uint64_t amount, const std::string &message) const = 0;
// virtual bool checkReserveProof(const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const = 0;
// virtual std::string signMessage(const std::string &message, const std::string &address = "") = 0;
extern ADDAPI const char* WOWNERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address);
// virtual bool verifySignedMessage(const std::string &message, const std::string &addres, const std::string &signature) const = 0;
extern ADDAPI bool WOWNERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature);
// virtual std::string signMultisigParticipant(const std::string &message) const = 0;
// virtual bool verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const = 0;
// virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector<std::string> &unknown_parameters, std::string &error) = 0;
// virtual std::string make_uri(const std::string &address, const std::string &payment_id, uint64_t amount, const std::string &tx_description, const std::string &recipient_name, std::string &error) const = 0;
// virtual std::string getDefaultDataDir() const = 0;
// virtual bool rescanSpent() = 0;
extern ADDAPI bool WOWNERO_Wallet_rescanSpent(void* wallet_ptr);
// virtual void setOffline(bool offline) = 0;
extern ADDAPI void WOWNERO_Wallet_setOffline(void* wallet_ptr, bool offline);
// virtual bool isOffline() const = 0;
extern ADDAPI bool WOWNERO_Wallet_isOffline(void* wallet_ptr);
// virtual bool blackballOutputs(const std::vector<std::string> &outputs, bool add) = 0;
// virtual bool blackballOutput(const std::string &amount, const std::string &offset) = 0;
// virtual bool unblackballOutput(const std::string &amount, const std::string &offset) = 0;
// virtual bool getRing(const std::string &key_image, std::vector<uint64_t> &ring) const = 0;
// virtual bool getRings(const std::string &txid, std::vector<std::pair<std::string, std::vector<uint64_t>>> &rings) const = 0;
// virtual bool setRing(const std::string &key_image, const std::vector<uint64_t> &ring, bool relative) = 0;
// virtual void segregatePreForkOutputs(bool segregate) = 0;
extern ADDAPI void WOWNERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate);
// virtual void segregationHeight(uint64_t height) = 0;
extern ADDAPI void WOWNERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height);
// virtual void keyReuseMitigation2(bool mitigation) = 0;
extern ADDAPI void WOWNERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation);
// virtual bool lightWalletLogin(bool &isNewWallet) const = 0;
// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0;
// virtual bool lockKeysFile() = 0;
extern ADDAPI bool WOWNERO_Wallet_lockKeysFile(void* wallet_ptr);
// virtual bool unlockKeysFile() = 0;
extern ADDAPI bool WOWNERO_Wallet_unlockKeysFile(void* wallet_ptr);
// virtual bool isKeysFileLocked() = 0;
extern ADDAPI bool WOWNERO_Wallet_isKeysFileLocked(void* wallet_ptr);
// virtual Device getDeviceType() const = 0;
extern ADDAPI int WOWNERO_Wallet_getDeviceType(void* wallet_ptr);
// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent);
// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0;
extern ADDAPI const char* WOWNERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex);
// virtual bool reconnectDevice() = 0;
extern ADDAPI bool WOWNERO_Wallet_reconnectDevice(void* wallet_ptr);
// virtual uint64_t getBytesReceived() = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_getBytesReceived(void* wallet_ptr);
// virtual uint64_t getBytesSent() = 0;
extern ADDAPI uint64_t WOWNERO_Wallet_getBytesSent(void* wallet_ptr);
// };
// struct WalletManager
// {
// virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, NetworkType nettype, uint64_t kdf_rounds = 1) = 0;
extern ADDAPI void* WOWNERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType);
// Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, bool testnet = false) // deprecated
// {
// return createWallet(path, password, language, testnet ? TESTNET : MAINNET);
// }
// virtual Wallet * openWallet(const std::string &path, const std::string &password, NetworkType nettype, uint64_t kdf_rounds = 1, WalletListener * listener = nullptr) = 0;
extern ADDAPI void* WOWNERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType);
// Wallet * openWallet(const std::string &path, const std::string &password, bool testnet = false) // deprecated
// {
// return openWallet(path, password, testnet ? TESTNET : MAINNET);
// }
// virtual Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic,
// NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1,
// const std::string &seed_offset = {}) = 0;
extern ADDAPI void* WOWNERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset);
// Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic,
// bool testnet = false, uint64_t restoreHeight = 0) // deprecated
// {
// return recoveryWallet(path, password, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight);
// }
// virtual Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, NetworkType nettype, uint64_t restoreHeight = 0) = 0;
// Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, bool testnet = false, uint64_t restoreHeight = 0) // deprecated
// {
// return recoveryWallet(path, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight);
// }
// virtual Wallet * createWalletFromKeys(const std::string &path,
// const std::string &password,
// const std::string &language,
// NetworkType nettype,
// uint64_t restoreHeight,
// const std::string &addressString,
// const std::string &viewKeyString,
// const std::string &spendKeyString = "",
// uint64_t kdf_rounds = 1) = 0;
extern ADDAPI void* WOWNERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds);
// Wallet * createWalletFromKeys(const std::string &path,
// const std::string &password,
// const std::string &language,
// bool testnet,
// uint64_t restoreHeight,
// const std::string &addressString,
// const std::string &viewKeyString,
// const std::string &spendKeyString = "") // deprecated
// {
// return createWalletFromKeys(path, password, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString);
// }
// virtual Wallet * createWalletFromKeys(const std::string &path,
// const std::string &language,
// NetworkType nettype,
// uint64_t restoreHeight,
// const std::string &addressString,
// const std::string &viewKeyString,
// const std::string &spendKeyString = "") = 0;
// Wallet * createWalletFromKeys(const std::string &path,
// const std::string &language,
// bool testnet,
// uint64_t restoreHeight,
// const std::string &addressString,
// const std::string &viewKeyString,
// const std::string &spendKeyString = "") // deprecated
// {
// return createWalletFromKeys(path, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString);
// }
// virtual Wallet * createDeterministicWalletFromSpendKey(const std::string &path,
// const std::string &password,
// const std::string &language,
// NetworkType nettype,
// uint64_t restoreHeight,
// const std::string &spendKeyString,
// uint64_t kdf_rounds = 1) = 0;
extern ADDAPI void* WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password,
const char* language, int nettype, uint64_t restoreHeight,
const char* spendKeyString, uint64_t kdf_rounds);
// virtual Wallet * createWalletFromDevice(const std::string &path,
// const std::string &password,
// NetworkType nettype,
// const std::string &deviceName,
// uint64_t restoreHeight = 0,
// const std::string &subaddressLookahead = "",
// uint64_t kdf_rounds = 1,
// WalletListener * listener = nullptr) = 0;
// virtual Wallet * createWalletFromPolyseed(const std::string &path,
// const std::string &password,
// NetworkType nettype,
// const std::string &mnemonic,
// const std::string &passphrase = "",
// bool newWallet = true,
// uint64_t restore_height = 0,
// uint64_t kdf_rounds = 1) = 0;
extern ADDAPI void* WOWNERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password,
int nettype, const char* mnemonic, const char* passphrase,
bool newWallet, uint64_t restore_height, uint64_t kdf_rounds);
// virtual bool closeWallet(Wallet *wallet, bool store = true) = 0;
extern ADDAPI bool WOWNERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store);
// virtual bool walletExists(const std::string &path) = 0;
extern ADDAPI bool WOWNERO_WalletManager_walletExists(void* wm_ptr, const char* path);
// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0;
extern ADDAPI bool WOWNERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds);
// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0;
extern ADDAPI bool WOWNERO_WalletManager_queryWalletDevice(int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds);
// virtual std::vector<std::string> findWallets(const std::string &path) = 0;
extern ADDAPI const char* WOWNERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator);
// virtual std::string errorString() const = 0;
extern ADDAPI const char* WOWNERO_WalletManager_errorString(void* wm_ptr);
// virtual void setDaemonAddress(const std::string &address) = 0;
extern ADDAPI void WOWNERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address);
// virtual bool connected(uint32_t *version = NULL) = 0;
// virtual uint64_t blockchainHeight() = 0;
extern ADDAPI uint64_t WOWNERO_WalletManager_blockchainHeight(void* wm_ptr);
// virtual uint64_t blockchainTargetHeight() = 0;
extern ADDAPI uint64_t WOWNERO_WalletManager_blockchainTargetHeight(void* wm_ptr);
// virtual uint64_t networkDifficulty() = 0;
extern ADDAPI uint64_t WOWNERO_WalletManager_networkDifficulty(void* wm_ptr);
// virtual double miningHashRate() = 0;
extern ADDAPI double WOWNERO_WalletManager_miningHashRate(void* wm_ptr);
// virtual uint64_t blockTarget() = 0;
extern ADDAPI uint64_t WOWNERO_WalletManager_blockTarget(void* wm_ptr);
// virtual bool isMining() = 0;
extern ADDAPI bool WOWNERO_WalletManager_isMining(void* wm_ptr);
// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0;
extern ADDAPI bool WOWNERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery);
// virtual bool stopMining() = 0;
extern ADDAPI bool WOWNERO_WalletManager_stopMining(void* wm_ptr, const char* address);
// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0;
extern ADDAPI const char* WOWNERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid);
// static std::tuple<bool, std::string, std::string, std::string, std::string> checkUpdates(
// const std::string &software,
// std::string subdir,
// const char *buildtag = nullptr,
// const char *current_version = nullptr);
// virtual bool setProxy(const std::string &address) = 0;
extern ADDAPI bool WOWNERO_WalletManager_setProxy(void* wm_ptr, const char* address);
// };
int LogLevel_Silent = -1;
int LogLevel_0 = 0;
int LogLevel_1 = 1;
int LogLevel_2 = 2;
int LogLevel_3 = 3;
int LogLevel_4 = 4;
int LogLevel_Min = -1;
int LogLevel_Max = 4;
// struct WalletManagerFactory
// {
// enum LogLevel {
// LogLevel_Silent = -1,
// LogLevel_0 = 0,
// LogLevel_1 = 1,
// LogLevel_2 = 2,
// LogLevel_3 = 3,
// LogLevel_4 = 4,
// LogLevel_Min = LogLevel_Silent,
// LogLevel_Max = LogLevel_4
// };
// static WalletManager * getWalletManager();
extern ADDAPI void* WOWNERO_WalletManagerFactory_getWalletManager();
// static void setLogLevel(int level);
extern ADDAPI void WOWNERO_WalletManagerFactory_setLogLevel(int level);
// static void setLogCategories(const std::string &categories);
extern ADDAPI void WOWNERO_WalletManagerFactory_setLogCategories(const char* categories);
// };
// }
extern ADDAPI void WOWNERO_DEBUG_test0();
extern ADDAPI bool WOWNERO_DEBUG_test1(bool x);
extern ADDAPI int WOWNERO_DEBUG_test2(int x);
extern ADDAPI uint64_t WOWNERO_DEBUG_test3(uint64_t x);
extern ADDAPI void* WOWNERO_DEBUG_test4(uint64_t x);
extern ADDAPI const char* WOWNERO_DEBUG_test5();
extern ADDAPI const char* WOWNERO_DEBUG_test5_std();
extern ADDAPI bool WOWNERO_DEBUG_isPointerNull(void* wallet_ptr);
// cake world
extern ADDAPI void* WOWNERO_cw_getWalletListener(void* wallet_ptr);