diff --git a/pkg/.gitignore b/pkg/.gitignore new file mode 100644 index 0000000..f59ec20 --- /dev/null +++ b/pkg/.gitignore @@ -0,0 +1 @@ +* \ No newline at end of file diff --git a/pkg/README.md b/pkg/README.md new file mode 100644 index 0000000..5154788 --- /dev/null +++ b/pkg/README.md @@ -0,0 +1,347 @@ +# 🚀 4NK Node - Infrastructure Docker ComplĂšte + +Infrastructure Docker complĂšte pour le dĂ©veloppement et le dĂ©ploiement de services 4NK avec support des paiements silencieux (Silent Payments). + +## 📋 Table des MatiĂšres + +- [đŸ—ïž Architecture](#-architecture) +- [🚀 DĂ©marrage Rapide](#-dĂ©marrage-rapide) +- [📚 Documentation](#-documentation) +- [🔧 Configuration](#-configuration) +- [đŸ§Ș Tests et Monitoring](#-tests-et-monitoring) +- [🌐 RĂ©seau de Relais](#-rĂ©seau-de-relais) +- [đŸ› ïž DĂ©veloppement](#-dĂ©veloppement) +- [🚹 DĂ©pannage](#-dĂ©pannage) + +## đŸ—ïž Architecture + +4NK Node est composĂ© de plusieurs services orchestrĂ©s via Docker : + +| Service | Port | Description | Statut | +|---------|------|-------------|---------| +| **Tor** | 9050, 9051 | Proxy anonyme pour Bitcoin Core | ✅ Stable | +| **Bitcoin Core** | 18443 (RPC), 29000 (ZMQ) | NƓud Bitcoin en mode signet | ✅ Stable | +| **Blindbit** | 8000 | Service de filtres pour les paiements silencieux | ✅ Stable | +| **sdk_relay** | 8090-8095 | Services de relais (3 instances) | ✅ Stable | + +### 🔄 Flux de DonnĂ©es + +``` +Client → sdk_relay → Bitcoin Core + ↓ + Blindbit → Bitcoin Core + ↓ + Tor (anonymat) +``` + +## 🚀 DĂ©marrage Rapide + +### PrĂ©requis + +- **Docker** et **Docker Compose** installĂ©s +- **10 Go** d'espace disque minimum +- **Connexion Internet** stable +- **ClĂ© SSH** configurĂ©e pour GitLab (recommandĂ©) + +### Installation + +```bash +# 1. Cloner le repository (SSH recommandĂ©) +git clone git@git.4nkweb.com:4nk/4NK_node.git +cd 4NK_node + +# 2. DĂ©marrer tous les services +./restart_4nk_node.sh + +# 3. VĂ©rifier le statut +docker ps +``` + +### Configuration SSH (RecommandĂ©) + +```bash +# GĂ©nĂ©rer une clĂ© SSH +ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_4nk -C "4nk-automation" + +# Ajouter Ă  l'agent SSH +ssh-add ~/.ssh/id_ed25519_4nk + +# Configurer Git +git config --global core.sshCommand "ssh -i ~/.ssh/id_ed25519_4nk" + +# Ajouter la clĂ© publique Ă  GitLab +cat ~/.ssh/id_ed25519_4nk.pub +``` + +## 📚 Documentation + +### 📖 Guides Principaux + +- **[Guide d'Installation](docs/INSTALLATION.md)** - Installation et configuration complĂšte +- **[Guide d'Utilisation](docs/USAGE.md)** - Utilisation quotidienne et cas d'usage +- **[Guide de Configuration](docs/CONFIGURATION.md)** - Configuration avancĂ©e +- **[Guide de DĂ©veloppement](docs/DEVELOPMENT.md)** - DĂ©veloppement et contribution + +### 🔧 Guides Techniques + +- **[Architecture Technique](docs/ARCHITECTURE.md)** - Architecture dĂ©taillĂ©e +- **[API Reference](docs/API.md)** - Documentation des APIs +- **[SĂ©curitĂ©](docs/SECURITY.md)** - SĂ©curitĂ© et bonnes pratiques +- **[Performance](docs/PERFORMANCE.md)** - Optimisation et monitoring + +### đŸ§Ș Guides de Test + +- **[Tests de Base](docs/TESTING.md)** - Tests de connectivitĂ© et fonctionnalitĂ© +- **[Tests de Synchronisation](docs/SYNC_TESTING.md)** - Tests de synchronisation entre relais +- **[Tests de Performance](docs/PERFORMANCE_TESTING.md)** - Tests de charge et performance + +### 🌐 Guides RĂ©seau + +- **[RĂ©seau de Relais](docs/RELAY_NETWORK.md)** - Configuration du rĂ©seau mesh +- **[NƓuds Externes](docs/EXTERNAL_NODES.md)** - Ajout et gestion de nƓuds externes +- **[Synchronisation](docs/SYNCHRONIZATION.md)** - Protocole de synchronisation + +## 🔧 Configuration + +### Services Disponibles + +| Service | Configuration | Volume | Description | +|---------|---------------|---------|-------------| +| **Bitcoin Core** | `bitcoin/bitcoin.conf` | `bitcoin_data` | NƓud Bitcoin signet avec RPC et ZMQ | +| **Blindbit** | `blindbit/blindbit.toml` | `blindbit_data` | Service de filtres Silent Payments | +| **sdk_relay** | `sdk_relay/.conf.docker.*` | `sdk_relay_*_data` | Relais avec synchronisation mesh | +| **Tor** | `tor/torrc` | - | Proxy anonyme | + +### Variables d'Environnement + +```bash +# Logs +RUST_LOG=debug,bitcoincore_rpc=trace + +# Bitcoin +BITCOIN_COOKIE_PATH=/home/bitcoin/.bitcoin/signet/.cookie + +# Synchronisation +ENABLE_SYNC_TEST=1 +``` + +## đŸ§Ș Tests et Monitoring + +### Tests de Base + +```bash +# Test de connectivitĂ© +./test_final_sync.sh + +# Test de synchronisation +./test_sync_logs.sh + +# Test des messages WebSocket +python3 test_websocket_messages.py +``` + +### Monitoring + +```bash +# Surveillance de la synchronisation +./monitor_sync.sh + +# Logs en temps rĂ©el +docker-compose logs -f + +# Statut des services +docker ps +``` + +### Tests de Performance + +```bash +# Test de charge WebSocket +python3 test_websocket_messages.py --load-test + +# Test de synchronisation +./test_sync_logs.sh continuous +``` + +## 🌐 RĂ©seau de Relais + +### Architecture Mesh + +L'infrastructure supporte un rĂ©seau mesh de relais avec : + +- **3 relais locaux** : `sdk_relay_1`, `sdk_relay_2`, `sdk_relay_3` +- **NƓuds externes** : Configuration via `external_nodes.conf` +- **Synchronisation automatique** : Partage de donnĂ©es entre relais +- **DĂ©couverte automatique** : DĂ©couverte des relais voisins + +### Ajout de NƓuds Externes + +```bash +# Ajouter un nƓud externe +./add_external_node.sh add external-relay-1 external-relay-1.example.com:8090 + +# Lister les nƓuds configurĂ©s +./add_external_node.sh list + +# Tester la connectivitĂ© +./add_external_node.sh test external-relay-1 +``` + +### Configuration Externe + +```toml +# external_nodes.conf +[relays] +external-relay-1 = "external-relay-1.example.com:8090" +dev3-relay = "dev3.4nkweb.com:443" + +[discovery] +auto_discover = true +bootstrap_nodes = [] +``` + +## đŸ› ïž DĂ©veloppement + +### Structure du Projet + +``` +4NK_node/ +├── bitcoin/ # Configuration Bitcoin Core +├── blindbit/ # Configuration Blindbit +├── sdk_relay/ # Configuration des relais +├── tor/ # Configuration Tor +├── specs/ # SpĂ©cifications techniques +├── docs/ # Documentation +├── tests/ # Scripts de test +├── scripts/ # Scripts utilitaires +└── docker-compose.yml +``` + +### Ajout d'un Nouveau Service + +1. CrĂ©er le Dockerfile dans un sous-rĂ©pertoire +2. Ajouter le service dans `docker-compose.yml` +3. Configurer les dĂ©pendances et le rĂ©seau +4. Ajouter les healthchecks si nĂ©cessaire +5. Documenter dans la section appropriĂ©e + +### Modification de la Configuration + +```bash +# Modifier la configuration Bitcoin Core +sudo docker-compose down +# Éditer bitcoin/bitcoin.conf +sudo docker-compose up -d bitcoin + +# Modifier la configuration Blindbit +# Éditer blindbit/blindbit.toml +sudo docker-compose restart blindbit +``` + +## 🚹 DĂ©pannage + +### ProblĂšmes Courants + +#### 1. Ports DĂ©jĂ  UtilisĂ©s + +```bash +# VĂ©rifier les ports utilisĂ©s +sudo netstat -tlnp | grep -E "(18443|8000|9050|8090)" + +# ArrĂȘter les services conflictuels +sudo docker-compose down +``` + +#### 2. ProblĂšmes de Synchronisation Bitcoin + +```bash +# VĂ©rifier les logs Bitcoin Core +sudo docker-compose logs bitcoin + +# RedĂ©marrer Bitcoin Core +sudo docker-compose restart bitcoin +``` + +#### 3. ProblĂšmes de ConnectivitĂ© sdk_relay + +```bash +# Tester la connectivitĂ© +cd sdk_relay +./test_final.sh + +# VĂ©rifier la configuration +./debug_container.sh +``` + +### Logs DĂ©taillĂ©s + +```bash +# Logs avec timestamps +sudo docker-compose logs -t + +# Logs des 100 derniĂšres lignes +sudo docker-compose logs --tail=100 + +# Logs depuis une date +sudo docker-compose logs --since="2024-01-01T00:00:00" +``` + +### Healthchecks + +```bash +# VĂ©rifier l'Ă©tat des healthchecks +sudo docker-compose ps + +# Logs des healthchecks +sudo docker-compose logs | grep health + +# Test manuel du healthcheck sdk_relay +sudo docker exec sdk_relay /usr/local/bin/healthcheck.sh +``` + +## 📈 Performance + +### Ressources RecommandĂ©es + +- **CPU** : 2 cƓurs minimum, 4 cƓurs recommandĂ©s +- **RAM** : 4 Go minimum, 8 Go recommandĂ©s +- **Stockage** : 20 Go minimum pour la blockchain signet +- **RĂ©seau** : Connexion stable pour la synchronisation + +### Optimisations + +```bash +# Limiter l'utilisation CPU +sudo docker-compose up -d --scale bitcoin=1 + +# Surveiller l'utilisation des ressources +sudo docker stats + +# Optimiser l'espace disque +sudo docker system prune -f +``` + +## đŸ€ Contribution + +1. Fork le repository +2. CrĂ©er une branche feature (`git checkout -b feature/nouvelle-fonctionnalite`) +3. Commit les changements (`git commit -am 'Ajout de nouvelle fonctionnalitĂ©'`) +4. Push la branche (`git push origin feature/nouvelle-fonctionnalite`) +5. CrĂ©er une Pull Request + +## 📄 Licence + +Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de dĂ©tails. + +## 🆘 Support + +Pour obtenir de l'aide : + +1. Consulter la [documentation](docs/) +2. VĂ©rifier les [issues existantes](https://git.4nkweb.com/4nk/4NK_node/issues) +3. CrĂ©er une nouvelle issue avec les dĂ©tails du problĂšme +4. Inclure les logs et la configuration utilisĂ©e + +--- + +**✹ Infrastructure 4NK Node - PrĂȘte pour la production !** diff --git a/pkg/package.json b/pkg/package.json new file mode 100644 index 0000000..6d2d710 --- /dev/null +++ b/pkg/package.json @@ -0,0 +1,17 @@ +{ + "name": "sdk_client", + "type": "module", + "version": "0.1.0", + "files": [ + "sdk_client_bg.wasm", + "sdk_client.js", + "sdk_client_bg.js", + "sdk_client.d.ts" + ], + "main": "sdk_client.js", + "types": "sdk_client.d.ts", + "sideEffects": [ + "./sdk_client.js", + "./snippets/*" + ] +} \ No newline at end of file diff --git a/pkg/sdk_client.d.ts b/pkg/sdk_client.d.ts new file mode 100644 index 0000000..31a4d1a --- /dev/null +++ b/pkg/sdk_client.d.ts @@ -0,0 +1,355 @@ +/* tslint:disable */ +/* eslint-disable */ +export function setup(): void; +export function get_address(): string; +export function get_member(): Member; +export function restore_device(device: any): void; +export function create_device_from_sp_wallet(sp_wallet: string): string; +export function create_new_device(birthday: number, network_str: string): string; +export function is_paired(): boolean; +export function pair_device(process_id: string, sp_addresses: string[]): void; +export function unpair_device(): void; +export function dump_wallet(): string; +export function reset_process_cache(): void; +export function dump_process_cache(): string; +export function set_process_cache(processes: any): void; +export function add_to_process_cache(process_id: string, process: string): void; +export function reset_shared_secrets(): void; +export function set_shared_secrets(secrets: string): void; +export function get_pairing_process_id(): string; +export function dump_device(): Device; +export function dump_neutered_device(): Device; +export function reset_device(): void; +export function get_txid(transaction: string): string; +export function parse_new_tx(new_tx_msg: string, block_height: number, members_list: OutPointMemberMap): ApiReturn; +export function parse_cipher(cipher_msg: string, members_list: OutPointMemberMap): ApiReturn; +export function get_outputs(): any; +export function get_available_amount(): bigint; +/** + * We send a transaction that pays at least one output to each address + * The goal can be to establish a shared_secret to be used as an encryption key for further communication + * or if the recipient is a relay it can be the init transaction for a new process + */ +export function create_transaction(addresses: string[], fee_rate: number): ApiReturn; +export function sign_transaction(partial_tx: TsUnsignedTransaction): ApiReturn; +export function create_new_process(private_data: Pcd, roles: Roles, public_data: Pcd, relay_address: string, fee_rate: number, members_list: OutPointMemberMap): ApiReturn; +export function update_process(process: Process, new_attributes: Pcd, roles: Roles, new_public_data: Pcd, members_list: OutPointMemberMap): ApiReturn; +export function request_data(process_id: string, state_ids_str: string[], roles: any, members_list: OutPointMemberMap): ApiReturn; +export function create_update_message(process: Process, state_id: string, members_list: OutPointMemberMap): ApiReturn; +export function validate_state(process: Process, state_id: string, members_list: OutPointMemberMap): ApiReturn; +export function refuse_state(process: Process, state_id: string, members_list: OutPointMemberMap): ApiReturn; +export function evaluate_state(process: Process, state_id: string, members_list: OutPointMemberMap): ApiReturn; +export function create_response_prd(process: Process, state_id: string, members_list: OutPointMemberMap): ApiReturn; +export function create_faucet_msg(): string; +export function get_storages(process_outpoint: string): string[]; +export function is_child_role(parent_roles: string, child_roles: string): void; +export function decrypt_data(key: Uint8Array, data: Uint8Array): Uint8Array; +export function encode_binary(data: any): Pcd; +export function encode_json(json_data: any): Pcd; +export function decode_value(value: Uint8Array): any; +export function hash_value(value: any, commited_in: string, label: string): string; +/** + * Generate a merkle proof for a specific attribute in a process state. + * + * This function creates a merkle proof that proves the existence of a specific attribute + * in a given state of a process. The proof can be used to verify that the attribute + * was indeed part of the state without revealing the entire state. + * + * # Arguments + * * `process_state` - The process state object as a JavaScript value + * * `attribute_name` - The name of the attribute to generate a proof for + * + * # Returns + * A MerkleProofResult object containing: + * * `proof` - The merkle proof as a hex string + * * `root` - The merkle root (state_id) as a hex string + * * `attribute` - The attribute name that was proven + * * `attribute_index` - The index of the attribute in the merkle tree + * * `total_leaves_count` - The total number of leaves in the merkle tree + * + * # Errors + * * "Failed to deserialize process state" - If the process state cannot be deserialized from JsValue + * * "Attribute not found in state" - If the attribute doesn't exist in the state + */ +export function get_merkle_proof(process_state: any, attribute_name: string): MerkleProofResult; +/** + * Validate a merkle proof for a specific attribute. + * + * This function verifies that a merkle proof is valid and proves the existence + * of a specific attribute in a given state. It checks that the proof correctly + * leads to the claimed root when combined with the attribute hash. + * + * # Arguments + * * `proof_result` - a JsValue expected to contain a MerkleProofResult with the proof and metadata + * * `hash` - The hash of the attribute data as a hex string (the leaf value) + * + * # Returns + * A boolean indicating whether the proof is valid + * + * # Errors + * * "serde_wasm_bindgen deserialization error" - If the proof is not a valid MerkleProofResult + * * "Invalid proof format" - If the proof cannot be parsed + * * "Invalid hash format" - If the hash is not a valid 32-byte hex string + * * "Invalid root format" - If the root is not a valid 32-byte hex string + */ +export function validate_merkle_proof(proof_result: any, hash: string): boolean; +export type DiffStatus = "None" | "Rejected" | "Validated"; + +export interface UserDiff { + process_id: string; + state_id: string; + value_commitment: string; + field: string; + roles: Roles; + description: string | null; + notify_user: boolean; + need_validation: boolean; + validation_status: DiffStatus; +} + +export interface UpdatedProcess { + process_id: OutPoint; + current_process: Process; + diffs: UserDiff[]; + encrypted_data: Record; + validated_state: number[] | null; +} + +export interface ApiReturn { + secrets: SecretsStore | null; + updated_process: UpdatedProcess | null; + new_tx_to_send: NewTxMessage | null; + ciphers_to_send: string[]; + commit_to_send: CommitMessage | null; + push_to_storage: string[]; + partial_tx: TsUnsignedTransaction | null; +} + +export interface encryptWithNewKeyResult { + cipher: string; + key: string; +} + +export interface MerkleProofResult { + proof: string; + root: string; + attribute: string; + attribute_index: number; + total_leaves_count: number; +} + +export interface Device { + sp_wallet: SpWallet; + pairing_process_commitment: OutPoint | null; + paired_member: Member; +} + +export interface Prd { + prd_type: PrdType; + process_id: OutPoint; + sender: Member; + keys: Record; + pcd_commitments: PcdCommitments; + validation_tokens: Proof[]; + roles: Roles; + public_data: Pcd; + payload: string; + proof: Proof | null; +} + +export type PrdType = "None" | "Connect" | "Message" | "Update" | "List" | "Response" | "Confirm" | "TxProposal" | "Request"; + +/** + * RĂ©ponse de synchronisation + */ +export interface SyncResponse { + request_id: string; + relay_id: string; + success: boolean; + messages: SyncMessage[]; + error: string | null; +} + +/** + * RequĂȘte de synchronisation + */ +export interface SyncRequest { + request_id: string; + relay_id: string; + sync_types: SyncType[]; + since_timestamp: number | null; + max_items: number | null; +} + +/** + * CapacitĂ© d\'un relais + */ +export interface Capability { + name: string; + version: string; + enabled: boolean; + parameters: Record; +} + +/** + * Connexion mesh entre relais + */ +export interface MeshConnection { + from_relay: string; + to_relay: string; + latency: number; + bandwidth: number; + last_heartbeat: number; +} + +/** + * Topologie du rĂ©seau + */ +export interface NetworkTopology { + total_relays: number; + connected_relays: number; + mesh_connections: MeshConnection[]; + network_diameter: number; + avg_latency: number; +} + +/** + * Statut de santĂ© d\'un relais + */ +export type HealthStatus = "Healthy" | "Warning" | "Critical" | "Offline"; + +/** + * Informations sur un relais + */ +export interface RelayInfo { + relay_id: string; + address: string; + sp_address: string; + version: string; + uptime: number; + last_seen: number; + capabilities: string[]; + health_status: HealthStatus; +} + +/** + * Informations sur un pair + */ +export interface PeerInfo { + address: string; + sp_address: string; + connected_since: number; + last_activity: number; + message_count: number; + capabilities: string[]; +} + +/** + * Contenu des messages de synchronisation + */ +export type SyncPayload = { StateData: { chain_tip: number; wallet_balance: number; active_processes: number; connected_peers: number } } | { ProcessData: { processes: OutPointProcessMap; last_update: number } } | { MemberData: { members: OutPointMemberMap; last_update: number } } | { TransactionData: { txid: string; height: number | null; confirmed: boolean; sp_outputs: string[] } } | { BlockData: { height: number; hash: string; timestamp: number; tx_count: number } } | { PeerData: { peers: PeerInfo[]; last_seen: number } } | { RelayData: { relays: RelayInfo[]; network_topology: NetworkTopology } } | { HealthData: { uptime: number; memory_usage: number; cpu_usage: number; active_connections: number; last_block_time: number } } | { MetricsData: { messages_processed: number; transactions_broadcast: number; blocks_scanned: number; errors_count: number; avg_response_time: number } } | { ConfigData: { config_hash: string; features: string[]; version: string } } | { CapabilityData: { capabilities: Capability[]; supported_networks: string[] } }; + +/** + * Types de synchronisation + */ +export type SyncType = "StateSync" | "ProcessSync" | "MemberSync" | "TxSync" | "BlockSync" | "PeerSync" | "RelaySync" | "HealthSync" | "MetricsSync" | "ConfigSync" | "CapabilitySync"; + +/** + * Message de synchronisation pour le rĂ©seau mesh des relais + */ +export interface SyncMessage { + sync_type: SyncType; + relay_id: string; + timestamp: number; + sequence_number: number; + payload: SyncPayload; + signature: string | null; +} + +export interface HandshakeMessage { + sp_address: string; + peers_list: OutPointMemberMap; + processes_list: OutPointProcessMap; + chain_tip: number; +} + +export interface NewTxMessage { + transaction: string; + tweak_data: string | null; + error: AnkError | null; +} + +export interface FaucetMessage { + sp_address: string; + commitment: string; + error: AnkError | null; +} + +/** + * Message sent to the server to commit some state in a transaction + * Client must first send a commit message with empty validation_tokens + * Relay will ignore a commit message for an update he\'s not aware of that also bears validation_tokens + */ +export interface CommitMessage { + process_id: OutPoint; + pcd_commitment: PcdCommitments; + roles: Roles; + public_data: Pcd; + validation_tokens: Proof[]; + error: AnkError | null; +} + +export type AnkFlag = "NewTx" | "Faucet" | "Cipher" | "Commit" | "Handshake" | "Sync" | "Unknown"; + +export type OutPointProcessMap = Record; + +export type OutPointMemberMap = Record; + +/** + * A process is basically a succession of states + * The latest state MUST be an empty state with only the commited_in field set at the last unspent outpoint + * Commiting this last empty state in a transaction is called obliterating a process, basically terminating it + */ +export interface Process { + states: ProcessState[]; +} + +export interface ProcessState { + commited_in: OutPoint; + pcd_commitment: Record; + state_id: string; + keys: Record; + validation_tokens: Proof[]; + public_data: Pcd; + roles: Record; +} + +export type TsUnsignedTransaction = SilentPaymentUnsignedTransaction; + +export interface SecretsStore { + shared_secrets: Record; + unconfirmed_secrets: AnkSharedSecretHash[]; +} + +export type Roles = Record; + +export interface RoleDefinition { + members: OutPoint[]; + validation_rules: ValidationRule[]; + storages: string[]; +} + +export interface ValidationRule { + quorum: number; + fields: string[]; + min_sig_member: number; +} + +export type PcdCommitments = Record; + +export type Pcd = Record; + +export interface Member { + sp_addresses: string[]; +} + diff --git a/pkg/sdk_client.js b/pkg/sdk_client.js new file mode 100644 index 0000000..e3c7dd7 --- /dev/null +++ b/pkg/sdk_client.js @@ -0,0 +1,5 @@ +import * as wasm from "./sdk_client_bg.wasm"; +export * from "./sdk_client_bg.js"; +import { __wbg_set_wasm } from "./sdk_client_bg.js"; +__wbg_set_wasm(wasm); +wasm.__wbindgen_start(); diff --git a/pkg/sdk_client_bg.js b/pkg/sdk_client_bg.js new file mode 100644 index 0000000..b779473 --- /dev/null +++ b/pkg/sdk_client_bg.js @@ -0,0 +1,1342 @@ +let wasm; +export function __wbg_set_wasm(val) { + wasm = val; +} + + +let WASM_VECTOR_LEN = 0; + +let cachedUint8ArrayMemory0 = null; + +function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; +} + +const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder; + +let cachedTextEncoder = new lTextEncoder('utf-8'); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8ArrayMemory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +let cachedDataViewMemory0 = null; + +function getDataViewMemory0() { + if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) { + cachedDataViewMemory0 = new DataView(wasm.memory.buffer); + } + return cachedDataViewMemory0; +} + +function addToExternrefTable0(obj) { + const idx = wasm.__externref_table_alloc(); + wasm.__wbindgen_export_4.set(idx, obj); + return idx; +} + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + const idx = addToExternrefTable0(e); + wasm.__wbindgen_exn_store(idx); + } +} + +const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder; + +let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches && builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + +export function setup() { + wasm.setup(); +} + +function takeFromExternrefTable0(idx) { + const value = wasm.__wbindgen_export_4.get(idx); + wasm.__externref_table_dealloc(idx); + return value; +} +/** + * @returns {string} + */ +export function get_address() { + let deferred2_0; + let deferred2_1; + try { + const ret = wasm.get_address(); + var ptr1 = ret[0]; + var len1 = ret[1]; + if (ret[3]) { + ptr1 = 0; len1 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred2_0 = ptr1; + deferred2_1 = len1; + return getStringFromWasm0(ptr1, len1); + } finally { + wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); + } +} + +/** + * @returns {Member} + */ +export function get_member() { + const ret = wasm.get_member(); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {any} device + */ +export function restore_device(device) { + const ret = wasm.restore_device(device); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +/** + * @param {string} sp_wallet + * @returns {string} + */ +export function create_device_from_sp_wallet(sp_wallet) { + let deferred3_0; + let deferred3_1; + try { + const ptr0 = passStringToWasm0(sp_wallet, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.create_device_from_sp_wallet(ptr0, len0); + var ptr2 = ret[0]; + var len2 = ret[1]; + if (ret[3]) { + ptr2 = 0; len2 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred3_0 = ptr2; + deferred3_1 = len2; + return getStringFromWasm0(ptr2, len2); + } finally { + wasm.__wbindgen_free(deferred3_0, deferred3_1, 1); + } +} + +/** + * @param {number} birthday + * @param {string} network_str + * @returns {string} + */ +export function create_new_device(birthday, network_str) { + let deferred3_0; + let deferred3_1; + try { + const ptr0 = passStringToWasm0(network_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.create_new_device(birthday, ptr0, len0); + var ptr2 = ret[0]; + var len2 = ret[1]; + if (ret[3]) { + ptr2 = 0; len2 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred3_0 = ptr2; + deferred3_1 = len2; + return getStringFromWasm0(ptr2, len2); + } finally { + wasm.__wbindgen_free(deferred3_0, deferred3_1, 1); + } +} + +/** + * @returns {boolean} + */ +export function is_paired() { + const ret = wasm.is_paired(); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return ret[0] !== 0; +} + +function passArrayJsValueToWasm0(array, malloc) { + const ptr = malloc(array.length * 4, 4) >>> 0; + for (let i = 0; i < array.length; i++) { + const add = addToExternrefTable0(array[i]); + getDataViewMemory0().setUint32(ptr + 4 * i, add, true); + } + WASM_VECTOR_LEN = array.length; + return ptr; +} +/** + * @param {string} process_id + * @param {string[]} sp_addresses + */ +export function pair_device(process_id, sp_addresses) { + const ptr0 = passStringToWasm0(process_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArrayJsValueToWasm0(sp_addresses, wasm.__wbindgen_malloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.pair_device(ptr0, len0, ptr1, len1); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +export function unpair_device() { + const ret = wasm.unpair_device(); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +/** + * @returns {string} + */ +export function dump_wallet() { + let deferred2_0; + let deferred2_1; + try { + const ret = wasm.dump_wallet(); + var ptr1 = ret[0]; + var len1 = ret[1]; + if (ret[3]) { + ptr1 = 0; len1 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred2_0 = ptr1; + deferred2_1 = len1; + return getStringFromWasm0(ptr1, len1); + } finally { + wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); + } +} + +export function reset_process_cache() { + const ret = wasm.reset_process_cache(); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +/** + * @returns {string} + */ +export function dump_process_cache() { + let deferred2_0; + let deferred2_1; + try { + const ret = wasm.dump_process_cache(); + var ptr1 = ret[0]; + var len1 = ret[1]; + if (ret[3]) { + ptr1 = 0; len1 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred2_0 = ptr1; + deferred2_1 = len1; + return getStringFromWasm0(ptr1, len1); + } finally { + wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); + } +} + +/** + * @param {any} processes + */ +export function set_process_cache(processes) { + const ret = wasm.set_process_cache(processes); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +/** + * @param {string} process_id + * @param {string} process + */ +export function add_to_process_cache(process_id, process) { + const ptr0 = passStringToWasm0(process_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(process, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.add_to_process_cache(ptr0, len0, ptr1, len1); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +export function reset_shared_secrets() { + const ret = wasm.reset_shared_secrets(); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +/** + * @param {string} secrets + */ +export function set_shared_secrets(secrets) { + const ptr0 = passStringToWasm0(secrets, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.set_shared_secrets(ptr0, len0); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +/** + * @returns {string} + */ +export function get_pairing_process_id() { + let deferred2_0; + let deferred2_1; + try { + const ret = wasm.get_pairing_process_id(); + var ptr1 = ret[0]; + var len1 = ret[1]; + if (ret[3]) { + ptr1 = 0; len1 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred2_0 = ptr1; + deferred2_1 = len1; + return getStringFromWasm0(ptr1, len1); + } finally { + wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); + } +} + +/** + * @returns {Device} + */ +export function dump_device() { + const ret = wasm.dump_device(); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @returns {Device} + */ +export function dump_neutered_device() { + const ret = wasm.dump_neutered_device(); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +export function reset_device() { + const ret = wasm.reset_device(); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +/** + * @param {string} transaction + * @returns {string} + */ +export function get_txid(transaction) { + let deferred3_0; + let deferred3_1; + try { + const ptr0 = passStringToWasm0(transaction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.get_txid(ptr0, len0); + var ptr2 = ret[0]; + var len2 = ret[1]; + if (ret[3]) { + ptr2 = 0; len2 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred3_0 = ptr2; + deferred3_1 = len2; + return getStringFromWasm0(ptr2, len2); + } finally { + wasm.__wbindgen_free(deferred3_0, deferred3_1, 1); + } +} + +/** + * @param {string} new_tx_msg + * @param {number} block_height + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function parse_new_tx(new_tx_msg, block_height, members_list) { + const ptr0 = passStringToWasm0(new_tx_msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.parse_new_tx(ptr0, len0, block_height, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {string} cipher_msg + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function parse_cipher(cipher_msg, members_list) { + const ptr0 = passStringToWasm0(cipher_msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.parse_cipher(ptr0, len0, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @returns {any} + */ +export function get_outputs() { + const ret = wasm.get_outputs(); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @returns {bigint} + */ +export function get_available_amount() { + const ret = wasm.get_available_amount(); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return BigInt.asUintN(64, ret[0]); +} + +/** + * We send a transaction that pays at least one output to each address + * The goal can be to establish a shared_secret to be used as an encryption key for further communication + * or if the recipient is a relay it can be the init transaction for a new process + * @param {string[]} addresses + * @param {number} fee_rate + * @returns {ApiReturn} + */ +export function create_transaction(addresses, fee_rate) { + const ptr0 = passArrayJsValueToWasm0(addresses, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.create_transaction(ptr0, len0, fee_rate); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {TsUnsignedTransaction} partial_tx + * @returns {ApiReturn} + */ +export function sign_transaction(partial_tx) { + const ret = wasm.sign_transaction(partial_tx); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {Pcd} private_data + * @param {Roles} roles + * @param {Pcd} public_data + * @param {string} relay_address + * @param {number} fee_rate + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function create_new_process(private_data, roles, public_data, relay_address, fee_rate, members_list) { + const ptr0 = passStringToWasm0(relay_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.create_new_process(private_data, roles, public_data, ptr0, len0, fee_rate, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {Process} process + * @param {Pcd} new_attributes + * @param {Roles} roles + * @param {Pcd} new_public_data + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function update_process(process, new_attributes, roles, new_public_data, members_list) { + const ret = wasm.update_process(process, new_attributes, roles, new_public_data, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {string} process_id + * @param {string[]} state_ids_str + * @param {any} roles + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function request_data(process_id, state_ids_str, roles, members_list) { + const ptr0 = passStringToWasm0(process_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArrayJsValueToWasm0(state_ids_str, wasm.__wbindgen_malloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.request_data(ptr0, len0, ptr1, len1, roles, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {Process} process + * @param {string} state_id + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function create_update_message(process, state_id, members_list) { + const ptr0 = passStringToWasm0(state_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.create_update_message(process, ptr0, len0, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {Process} process + * @param {string} state_id + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function validate_state(process, state_id, members_list) { + const ptr0 = passStringToWasm0(state_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.validate_state(process, ptr0, len0, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {Process} process + * @param {string} state_id + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function refuse_state(process, state_id, members_list) { + const ptr0 = passStringToWasm0(state_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.refuse_state(process, ptr0, len0, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {Process} process + * @param {string} state_id + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function evaluate_state(process, state_id, members_list) { + const ptr0 = passStringToWasm0(state_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.evaluate_state(process, ptr0, len0, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {Process} process + * @param {string} state_id + * @param {OutPointMemberMap} members_list + * @returns {ApiReturn} + */ +export function create_response_prd(process, state_id, members_list) { + const ptr0 = passStringToWasm0(state_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.create_response_prd(process, ptr0, len0, members_list); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @returns {string} + */ +export function create_faucet_msg() { + let deferred2_0; + let deferred2_1; + try { + const ret = wasm.create_faucet_msg(); + var ptr1 = ret[0]; + var len1 = ret[1]; + if (ret[3]) { + ptr1 = 0; len1 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred2_0 = ptr1; + deferred2_1 = len1; + return getStringFromWasm0(ptr1, len1); + } finally { + wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); + } +} + +function getArrayJsValueFromWasm0(ptr, len) { + ptr = ptr >>> 0; + const mem = getDataViewMemory0(); + const result = []; + for (let i = ptr; i < ptr + 4 * len; i += 4) { + result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true))); + } + wasm.__externref_drop_slice(ptr, len); + return result; +} +/** + * @param {string} process_outpoint + * @returns {string[]} + */ +export function get_storages(process_outpoint) { + const ptr0 = passStringToWasm0(process_outpoint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.get_storages(ptr0, len0); + if (ret[3]) { + throw takeFromExternrefTable0(ret[2]); + } + var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice(); + wasm.__wbindgen_free(ret[0], ret[1] * 4, 4); + return v2; +} + +/** + * @param {string} parent_roles + * @param {string} child_roles + */ +export function is_child_role(parent_roles, child_roles) { + const ptr0 = passStringToWasm0(parent_roles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(child_roles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.is_child_role(ptr0, len0, ptr1, len1); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +function passArray8ToWasm0(arg, malloc) { + const ptr = malloc(arg.length * 1, 1) >>> 0; + getUint8ArrayMemory0().set(arg, ptr / 1); + WASM_VECTOR_LEN = arg.length; + return ptr; +} + +function getArrayU8FromWasm0(ptr, len) { + ptr = ptr >>> 0; + return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len); +} +/** + * @param {Uint8Array} key + * @param {Uint8Array} data + * @returns {Uint8Array} + */ +export function decrypt_data(key, data) { + const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.decrypt_data(ptr0, len0, ptr1, len1); + if (ret[3]) { + throw takeFromExternrefTable0(ret[2]); + } + var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice(); + wasm.__wbindgen_free(ret[0], ret[1] * 1, 1); + return v3; +} + +/** + * @param {any} data + * @returns {Pcd} + */ +export function encode_binary(data) { + const ret = wasm.encode_binary(data); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {any} json_data + * @returns {Pcd} + */ +export function encode_json(json_data) { + const ret = wasm.encode_json(json_data); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {Uint8Array} value + * @returns {any} + */ +export function decode_value(value) { + const ptr0 = passArray8ToWasm0(value, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.decode_value(ptr0, len0); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * @param {any} value + * @param {string} commited_in + * @param {string} label + * @returns {string} + */ +export function hash_value(value, commited_in, label) { + let deferred4_0; + let deferred4_1; + try { + const ptr0 = passStringToWasm0(commited_in, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.hash_value(value, ptr0, len0, ptr1, len1); + var ptr3 = ret[0]; + var len3 = ret[1]; + if (ret[3]) { + ptr3 = 0; len3 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred4_0 = ptr3; + deferred4_1 = len3; + return getStringFromWasm0(ptr3, len3); + } finally { + wasm.__wbindgen_free(deferred4_0, deferred4_1, 1); + } +} + +/** + * Generate a merkle proof for a specific attribute in a process state. + * + * This function creates a merkle proof that proves the existence of a specific attribute + * in a given state of a process. The proof can be used to verify that the attribute + * was indeed part of the state without revealing the entire state. + * + * # Arguments + * * `process_state` - The process state object as a JavaScript value + * * `attribute_name` - The name of the attribute to generate a proof for + * + * # Returns + * A MerkleProofResult object containing: + * * `proof` - The merkle proof as a hex string + * * `root` - The merkle root (state_id) as a hex string + * * `attribute` - The attribute name that was proven + * * `attribute_index` - The index of the attribute in the merkle tree + * * `total_leaves_count` - The total number of leaves in the merkle tree + * + * # Errors + * * "Failed to deserialize process state" - If the process state cannot be deserialized from JsValue + * * "Attribute not found in state" - If the attribute doesn't exist in the state + * @param {any} process_state + * @param {string} attribute_name + * @returns {MerkleProofResult} + */ +export function get_merkle_proof(process_state, attribute_name) { + const ptr0 = passStringToWasm0(attribute_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.get_merkle_proof(process_state, ptr0, len0); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); +} + +/** + * Validate a merkle proof for a specific attribute. + * + * This function verifies that a merkle proof is valid and proves the existence + * of a specific attribute in a given state. It checks that the proof correctly + * leads to the claimed root when combined with the attribute hash. + * + * # Arguments + * * `proof_result` - a JsValue expected to contain a MerkleProofResult with the proof and metadata + * * `hash` - The hash of the attribute data as a hex string (the leaf value) + * + * # Returns + * A boolean indicating whether the proof is valid + * + * # Errors + * * "serde_wasm_bindgen deserialization error" - If the proof is not a valid MerkleProofResult + * * "Invalid proof format" - If the proof cannot be parsed + * * "Invalid hash format" - If the hash is not a valid 32-byte hex string + * * "Invalid root format" - If the root is not a valid 32-byte hex string + * @param {any} proof_result + * @param {string} hash + * @returns {boolean} + */ +export function validate_merkle_proof(proof_result, hash) { + const ptr0 = passStringToWasm0(hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.validate_merkle_proof(proof_result, ptr0, len0); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return ret[0] !== 0; +} + +export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) { + const ret = String(arg1); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +export function __wbg_buffer_609cc3eee51ed158(arg0) { + const ret = arg0.buffer; + return ret; +}; + +export function __wbg_call_672a4d21634d4a24() { return handleError(function (arg0, arg1) { + const ret = arg0.call(arg1); + return ret; +}, arguments) }; + +export function __wbg_call_7cccdd69e0791ae2() { return handleError(function (arg0, arg1, arg2) { + const ret = arg0.call(arg1, arg2); + return ret; +}, arguments) }; + +export function __wbg_crypto_574e78ad8b13b65f(arg0) { + const ret = arg0.crypto; + return ret; +}; + +export function __wbg_debug_e17b51583ca6a632(arg0, arg1, arg2, arg3) { + console.debug(arg0, arg1, arg2, arg3); +}; + +export function __wbg_done_769e5ede4b31c67b(arg0) { + const ret = arg0.done; + return ret; +}; + +export function __wbg_entries_3265d4158b33e5dc(arg0) { + const ret = Object.entries(arg0); + return ret; +}; + +export function __wbg_error_524f506f44df1645(arg0) { + console.error(arg0); +}; + +export function __wbg_error_80de38b3f7cc3c3c(arg0, arg1, arg2, arg3) { + console.error(arg0, arg1, arg2, arg3); +}; + +export function __wbg_getRandomValues_b8f5dbd5f3995a9e() { return handleError(function (arg0, arg1) { + arg0.getRandomValues(arg1); +}, arguments) }; + +export function __wbg_get_67b2ba62fc30de12() { return handleError(function (arg0, arg1) { + const ret = Reflect.get(arg0, arg1); + return ret; +}, arguments) }; + +export function __wbg_get_b9b93047fe3cf45b(arg0, arg1) { + const ret = arg0[arg1 >>> 0]; + return ret; +}; + +export function __wbg_getwithrefkey_1dc361bd10053bfe(arg0, arg1) { + const ret = arg0[arg1]; + return ret; +}; + +export function __wbg_info_033d8b8a0838f1d3(arg0, arg1, arg2, arg3) { + console.info(arg0, arg1, arg2, arg3); +}; + +export function __wbg_instanceof_ArrayBuffer_e14585432e3737fc(arg0) { + let result; + try { + result = arg0 instanceof ArrayBuffer; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +export function __wbg_instanceof_Map_f3469ce2244d2430(arg0) { + let result; + try { + result = arg0 instanceof Map; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) { + let result; + try { + result = arg0 instanceof Uint8Array; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +export function __wbg_isArray_a1eab7e0d067391b(arg0) { + const ret = Array.isArray(arg0); + return ret; +}; + +export function __wbg_isSafeInteger_343e2beeeece1bb0(arg0) { + const ret = Number.isSafeInteger(arg0); + return ret; +}; + +export function __wbg_iterator_9a24c88df860dc65() { + const ret = Symbol.iterator; + return ret; +}; + +export function __wbg_length_a446193dc22c12f8(arg0) { + const ret = arg0.length; + return ret; +}; + +export function __wbg_length_e2d2a49132c1b256(arg0) { + const ret = arg0.length; + return ret; +}; + +export function __wbg_log_cad59bb680daec67(arg0, arg1, arg2, arg3) { + console.log(arg0, arg1, arg2, arg3); +}; + +export function __wbg_msCrypto_a61aeb35a24c1329(arg0) { + const ret = arg0.msCrypto; + return ret; +}; + +export function __wbg_new_405e22f390576ce2() { + const ret = new Object(); + return ret; +}; + +export function __wbg_new_5e0be73521bc8c17() { + const ret = new Map(); + return ret; +}; + +export function __wbg_new_78feb108b6472713() { + const ret = new Array(); + return ret; +}; + +export function __wbg_new_a12002a7f91c75be(arg0) { + const ret = new Uint8Array(arg0); + return ret; +}; + +export function __wbg_newnoargs_105ed471475aaf50(arg0, arg1) { + const ret = new Function(getStringFromWasm0(arg0, arg1)); + return ret; +}; + +export function __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a(arg0, arg1, arg2) { + const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0); + return ret; +}; + +export function __wbg_newwithlength_a381634e90c276d4(arg0) { + const ret = new Uint8Array(arg0 >>> 0); + return ret; +}; + +export function __wbg_next_25feadfc0913fea9(arg0) { + const ret = arg0.next; + return ret; +}; + +export function __wbg_next_6574e1a8a62d1055() { return handleError(function (arg0) { + const ret = arg0.next(); + return ret; +}, arguments) }; + +export function __wbg_node_905d3e251edff8a2(arg0) { + const ret = arg0.node; + return ret; +}; + +export function __wbg_parse_def2e24ef1252aff() { return handleError(function (arg0, arg1) { + const ret = JSON.parse(getStringFromWasm0(arg0, arg1)); + return ret; +}, arguments) }; + +export function __wbg_process_dc0fbacc7c1c06f7(arg0) { + const ret = arg0.process; + return ret; +}; + +export function __wbg_randomFillSync_ac0988aba3254290() { return handleError(function (arg0, arg1) { + arg0.randomFillSync(arg1); +}, arguments) }; + +export function __wbg_require_60cc747a6bc5215a() { return handleError(function () { + const ret = module.require; + return ret; +}, arguments) }; + +export function __wbg_set_37837023f3d740e8(arg0, arg1, arg2) { + arg0[arg1 >>> 0] = arg2; +}; + +export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) { + arg0[arg1] = arg2; +}; + +export function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) { + arg0.set(arg1, arg2 >>> 0); +}; + +export function __wbg_set_8fc6bf8a5b1071d1(arg0, arg1, arg2) { + const ret = arg0.set(arg1, arg2); + return ret; +}; + +export function __wbg_set_bb8cecf6a62b9f46() { return handleError(function (arg0, arg1, arg2) { + const ret = Reflect.set(arg0, arg1, arg2); + return ret; +}, arguments) }; + +export function __wbg_static_accessor_GLOBAL_88a902d13a557d07() { + const ret = typeof global === 'undefined' ? null : global; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); +}; + +export function __wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0() { + const ret = typeof globalThis === 'undefined' ? null : globalThis; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); +}; + +export function __wbg_static_accessor_SELF_37c5d418e4bf5819() { + const ret = typeof self === 'undefined' ? null : self; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); +}; + +export function __wbg_static_accessor_WINDOW_5de37043a91a9c40() { + const ret = typeof window === 'undefined' ? null : window; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); +}; + +export function __wbg_stringify_f7ed6987935b4a24() { return handleError(function (arg0) { + const ret = JSON.stringify(arg0); + return ret; +}, arguments) }; + +export function __wbg_subarray_aa9065fa9dc5df96(arg0, arg1, arg2) { + const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0); + return ret; +}; + +export function __wbg_value_cd1ffa7b1ab794f1(arg0) { + const ret = arg0.value; + return ret; +}; + +export function __wbg_versions_c01dfd4722a88165(arg0) { + const ret = arg0.versions; + return ret; +}; + +export function __wbg_warn_aaf1f4664a035bd6(arg0, arg1, arg2, arg3) { + console.warn(arg0, arg1, arg2, arg3); +}; + +export function __wbindgen_as_number(arg0) { + const ret = +arg0; + return ret; +}; + +export function __wbindgen_bigint_from_i64(arg0) { + const ret = arg0; + return ret; +}; + +export function __wbindgen_bigint_from_u64(arg0) { + const ret = BigInt.asUintN(64, arg0); + return ret; +}; + +export function __wbindgen_bigint_get_as_i64(arg0, arg1) { + const v = arg1; + const ret = typeof(v) === 'bigint' ? v : undefined; + getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); +}; + +export function __wbindgen_boolean_get(arg0) { + const v = arg0; + const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2; + return ret; +}; + +export function __wbindgen_debug_string(arg0, arg1) { + const ret = debugString(arg1); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +export function __wbindgen_error_new(arg0, arg1) { + const ret = new Error(getStringFromWasm0(arg0, arg1)); + return ret; +}; + +export function __wbindgen_in(arg0, arg1) { + const ret = arg0 in arg1; + return ret; +}; + +export function __wbindgen_init_externref_table() { + const table = wasm.__wbindgen_export_4; + const offset = table.grow(4); + table.set(0, undefined); + table.set(offset + 0, undefined); + table.set(offset + 1, null); + table.set(offset + 2, true); + table.set(offset + 3, false); + ; +}; + +export function __wbindgen_is_bigint(arg0) { + const ret = typeof(arg0) === 'bigint'; + return ret; +}; + +export function __wbindgen_is_function(arg0) { + const ret = typeof(arg0) === 'function'; + return ret; +}; + +export function __wbindgen_is_object(arg0) { + const val = arg0; + const ret = typeof(val) === 'object' && val !== null; + return ret; +}; + +export function __wbindgen_is_string(arg0) { + const ret = typeof(arg0) === 'string'; + return ret; +}; + +export function __wbindgen_is_undefined(arg0) { + const ret = arg0 === undefined; + return ret; +}; + +export function __wbindgen_jsval_eq(arg0, arg1) { + const ret = arg0 === arg1; + return ret; +}; + +export function __wbindgen_jsval_loose_eq(arg0, arg1) { + const ret = arg0 == arg1; + return ret; +}; + +export function __wbindgen_memory() { + const ret = wasm.memory; + return ret; +}; + +export function __wbindgen_number_get(arg0, arg1) { + const obj = arg1; + const ret = typeof(obj) === 'number' ? obj : undefined; + getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); +}; + +export function __wbindgen_number_new(arg0) { + const ret = arg0; + return ret; +}; + +export function __wbindgen_string_get(arg0, arg1) { + const obj = arg1; + const ret = typeof(obj) === 'string' ? obj : undefined; + var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +export function __wbindgen_string_new(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return ret; +}; + +export function __wbindgen_throw(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; + diff --git a/pkg/sdk_client_bg.wasm b/pkg/sdk_client_bg.wasm new file mode 100644 index 0000000..221252e Binary files /dev/null and b/pkg/sdk_client_bg.wasm differ diff --git a/pkg/sdk_client_bg.wasm.d.ts b/pkg/sdk_client_bg.wasm.d.ts new file mode 100644 index 0000000..38b20c0 --- /dev/null +++ b/pkg/sdk_client_bg.wasm.d.ts @@ -0,0 +1,69 @@ +/* tslint:disable */ +/* eslint-disable */ +export const memory: WebAssembly.Memory; +export const get_address: () => [number, number, number, number]; +export const get_member: () => [number, number, number]; +export const restore_device: (a: any) => [number, number]; +export const create_device_from_sp_wallet: (a: number, b: number) => [number, number, number, number]; +export const create_new_device: (a: number, b: number, c: number) => [number, number, number, number]; +export const is_paired: () => [number, number, number]; +export const pair_device: (a: number, b: number, c: number, d: number) => [number, number]; +export const unpair_device: () => [number, number]; +export const dump_wallet: () => [number, number, number, number]; +export const reset_process_cache: () => [number, number]; +export const dump_process_cache: () => [number, number, number, number]; +export const set_process_cache: (a: any) => [number, number]; +export const add_to_process_cache: (a: number, b: number, c: number, d: number) => [number, number]; +export const reset_shared_secrets: () => [number, number]; +export const set_shared_secrets: (a: number, b: number) => [number, number]; +export const get_pairing_process_id: () => [number, number, number, number]; +export const dump_device: () => [number, number, number]; +export const dump_neutered_device: () => [number, number, number]; +export const reset_device: () => [number, number]; +export const get_txid: (a: number, b: number) => [number, number, number, number]; +export const parse_new_tx: (a: number, b: number, c: number, d: any) => [number, number, number]; +export const parse_cipher: (a: number, b: number, c: any) => [number, number, number]; +export const get_outputs: () => [number, number, number]; +export const get_available_amount: () => [bigint, number, number]; +export const create_transaction: (a: number, b: number, c: number) => [number, number, number]; +export const sign_transaction: (a: any) => [number, number, number]; +export const create_new_process: (a: any, b: any, c: any, d: number, e: number, f: number, g: any) => [number, number, number]; +export const update_process: (a: any, b: any, c: any, d: any, e: any) => [number, number, number]; +export const request_data: (a: number, b: number, c: number, d: number, e: any, f: any) => [number, number, number]; +export const create_update_message: (a: any, b: number, c: number, d: any) => [number, number, number]; +export const validate_state: (a: any, b: number, c: number, d: any) => [number, number, number]; +export const refuse_state: (a: any, b: number, c: number, d: any) => [number, number, number]; +export const evaluate_state: (a: any, b: number, c: number, d: any) => [number, number, number]; +export const create_response_prd: (a: any, b: number, c: number, d: any) => [number, number, number]; +export const create_faucet_msg: () => [number, number, number, number]; +export const get_storages: (a: number, b: number) => [number, number, number, number]; +export const is_child_role: (a: number, b: number, c: number, d: number) => [number, number]; +export const decrypt_data: (a: number, b: number, c: number, d: number) => [number, number, number, number]; +export const encode_binary: (a: any) => [number, number, number]; +export const encode_json: (a: any) => [number, number, number]; +export const decode_value: (a: number, b: number) => [number, number, number]; +export const hash_value: (a: any, b: number, c: number, d: number, e: number) => [number, number, number, number]; +export const get_merkle_proof: (a: any, b: number, c: number) => [number, number, number]; +export const validate_merkle_proof: (a: any, b: number, c: number) => [number, number, number]; +export const setup: () => void; +export const rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => void; +export const rust_zstd_wasm_shim_malloc: (a: number) => number; +export const rust_zstd_wasm_shim_memcmp: (a: number, b: number, c: number) => number; +export const rust_zstd_wasm_shim_calloc: (a: number, b: number) => number; +export const rust_zstd_wasm_shim_free: (a: number) => void; +export const rust_zstd_wasm_shim_memcpy: (a: number, b: number, c: number) => number; +export const rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number; +export const rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number; +export const rustsecp256k1_v0_9_2_context_create: (a: number) => number; +export const rustsecp256k1_v0_9_2_context_destroy: (a: number) => void; +export const rustsecp256k1_v0_9_2_default_illegal_callback_fn: (a: number, b: number) => void; +export const rustsecp256k1_v0_9_2_default_error_callback_fn: (a: number, b: number) => void; +export const __wbindgen_malloc: (a: number, b: number) => number; +export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; +export const __wbindgen_exn_store: (a: number) => void; +export const __externref_table_alloc: () => number; +export const __wbindgen_export_4: WebAssembly.Table; +export const __externref_table_dealloc: (a: number) => void; +export const __wbindgen_free: (a: number, b: number, c: number) => void; +export const __externref_drop_slice: (a: number, b: number) => void; +export const __wbindgen_start: () => void; diff --git a/temp-deps/sdk_client/src/api.rs b/temp-deps/sdk_client/src/api.rs index 9e52614..c762cd1 100644 --- a/temp-deps/sdk_client/src/api.rs +++ b/temp-deps/sdk_client/src/api.rs @@ -692,7 +692,7 @@ fn handle_prd_connect(prd: Prd, secret: AnkSharedSecretHash) -> AnyhowResult AnyhowResult ApiResult { } fn get_shared_secrets_in_transaction( - unsigned_transaction: &SilentPaymentUnsignedTransaction, + unsigned_transaction: &SilentPaymentUnsignedTransaction, sp_addresses: &[SilentPaymentAddress] ) -> anyhow::Result> { let mut new_secrets = HashMap::new(); @@ -1036,8 +1036,8 @@ fn get_shared_secrets_in_transaction( fn create_transaction_for_addresses( device: &Device, - freezed_utxos: &HashSet, - sp_addresses: &[SilentPaymentAddress], + freezed_utxos: &HashSet, + sp_addresses: &[SilentPaymentAddress], fee_rate: FeeRate ) -> anyhow::Result { let mut recipients = Vec::with_capacity(sp_addresses.len()); @@ -1080,7 +1080,7 @@ fn create_transaction_for_addresses( /// We send a transaction that pays at least one output to each address /// The goal can be to establish a shared_secret to be used as an encryption key for further communication /// or if the recipient is a relay it can be the init transaction for a new process -pub fn create_transaction(addresses: Vec, fee_rate: u32) -> ApiResult { +pub fn create_transaction(addresses: Vec, fee_rate: u32) -> ApiResult { if addresses.is_empty() { return Err(ApiError::new("No addresses to connect to".to_owned())); } @@ -1207,8 +1207,8 @@ pub fn create_new_process( } let commit_msg = CommitMessage::new( - process_id, - pcd_commitment, + process_id, + pcd_commitment, roles, public_data, vec![], @@ -1250,8 +1250,8 @@ pub fn update_process( } let mut new_state = ProcessState::new( - process.get_process_tip()?, - new_attributes.clone(), + process.get_process_tip()?, + new_attributes.clone(), prev_public_data, roles.clone() )?; @@ -1303,8 +1303,8 @@ pub fn update_process( }; let commit_msg = CommitMessage::new( - process_id, - new_state.pcd_commitment, + process_id, + new_state.pcd_commitment, roles, new_state.public_data, vec![] @@ -1353,8 +1353,8 @@ pub fn request_data(process_id: String, state_ids_str: Vec, roles: JsVal } let prd_request = Prd::new_request( - process_id, - members_list.0.get(&sender_pairing_id).unwrap().clone(), + process_id, + members_list.0.get(&sender_pairing_id).unwrap().clone(), state_ids ); @@ -1409,7 +1409,7 @@ pub fn create_update_message( }; // Check that we have a shared_secret with all members if let Some(no_secret_address) = member.get_addresses().iter() - .find(|a| shared_secrets.get_secret_for_address(a.as_str().try_into().unwrap()).is_none()) + .find(|a| shared_secrets.get_secret_for_address(a.as_str().try_into().unwrap()).is_none()) { // We ignore it if we don't have a secret with ourselves if *no_secret_address != local_address { @@ -1485,8 +1485,8 @@ pub fn evaluate_state(process: Process, state_id: String, members_list: OutPoint // We create a commit msg with the valid state let commit_msg = CommitMessage::new( - process_id, - process_state.pcd_commitment.clone(), + process_id, + process_state.pcd_commitment.clone(), process_state.roles.clone(), process_state.public_data.clone(), vec![] @@ -1518,7 +1518,7 @@ fn add_validation_token(mut process: Process, state_id: String, approval: bool, let mut commit_msg = CommitMessage::new( process_id, - update_state.pcd_commitment.clone(), + update_state.pcd_commitment.clone(), update_state.roles.clone(), update_state.public_data.clone(), update_state.validation_tokens.clone() @@ -1576,7 +1576,7 @@ fn new_response_prd(process_id: OutPoint, update_state: &ProcessState, members_l }; // Check that we have a shared_secret with all members if let Some(no_secret_address) = member.get_addresses().iter() - .find(|a| shared_secrets.get_secret_for_address(a.as_str().try_into().unwrap()).is_none()) + .find(|a| shared_secrets.get_secret_for_address(a.as_str().try_into().unwrap()).is_none()) { // We ignore it if we don't have a secret with ourselves if *no_secret_address != local_address { @@ -1601,7 +1601,7 @@ fn new_response_prd(process_id: OutPoint, update_state: &ProcessState, members_l let response_prd = Prd::new_response( process_id, sender, - vec![*proof], + vec![*proof], update_state.pcd_commitment.clone(), ); let prd_msg = response_prd.to_network_msg(local_device.get_sp_client())?; @@ -1650,7 +1650,7 @@ pub fn create_faucet_msg() -> ApiResult { #[wasm_bindgen] pub fn get_storages(process_outpoint: String) -> ApiResult> { let outpoint = OutPoint::from_str(&process_outpoint)?; - + Ok(vec![]) } @@ -1753,15 +1753,15 @@ pub struct MerkleProofResult { #[wasm_bindgen] /// Generate a merkle proof for a specific attribute in a process state. -/// +/// /// This function creates a merkle proof that proves the existence of a specific attribute /// in a given state of a process. The proof can be used to verify that the attribute /// was indeed part of the state without revealing the entire state. -/// +/// /// # Arguments /// * `process_state` - The process state object as a JavaScript value /// * `attribute_name` - The name of the attribute to generate a proof for -/// +/// /// # Returns /// A MerkleProofResult object containing: /// * `proof` - The merkle proof as a hex string @@ -1769,7 +1769,7 @@ pub struct MerkleProofResult { /// * `attribute` - The attribute name that was proven /// * `attribute_index` - The index of the attribute in the merkle tree /// * `total_leaves_count` - The total number of leaves in the merkle tree -/// +/// /// # Errors /// * "Failed to deserialize process state" - If the process state cannot be deserialized from JsValue /// * "Attribute not found in state" - If the attribute doesn't exist in the state @@ -1777,21 +1777,21 @@ pub fn get_merkle_proof(process_state: JsValue, attribute_name: String) -> ApiRe // Deserialize the process state from JsValue let state: ProcessState = serde_wasm_bindgen::from_value(process_state) .map_err(|_| ApiError::new("Failed to deserialize process state".to_owned()))?; - + // Create merkle tree from the PCD commitments let merkle_tree = state.pcd_commitment.create_merkle_tree()?; - + // Find the index of the attribute in the commitments let attribute_index = state.pcd_commitment.find_index_of(&attribute_name) .ok_or(ApiError::new("Attribute not found in state".to_owned()))?; // Generate the merkle proof for the attribute let proof = merkle_tree.proof(&[attribute_index]); - + // Convert the proof to a format that can be serialized to JavaScript let proof_bytes = proof.to_bytes(); let proof_hex = proof_bytes.to_lower_hex_string(); - + Ok(MerkleProofResult { proof: proof_hex, root: state.state_id.to_lower_hex_string(), @@ -1803,18 +1803,18 @@ pub fn get_merkle_proof(process_state: JsValue, attribute_name: String) -> ApiRe #[wasm_bindgen] /// Validate a merkle proof for a specific attribute. -/// +/// /// This function verifies that a merkle proof is valid and proves the existence /// of a specific attribute in a given state. It checks that the proof correctly /// leads to the claimed root when combined with the attribute hash. -/// +/// /// # Arguments /// * `proof_result` - a JsValue expected to contain a MerkleProofResult with the proof and metadata /// * `hash` - The hash of the attribute data as a hex string (the leaf value) -/// +/// /// # Returns /// A boolean indicating whether the proof is valid -/// +/// /// # Errors /// * "serde_wasm_bindgen deserialization error" - If the proof is not a valid MerkleProofResult /// * "Invalid proof format" - If the proof cannot be parsed @@ -1825,7 +1825,7 @@ pub fn validate_merkle_proof(proof_result: JsValue, hash: String) -> ApiResult ApiResult