Skip to main content

Other Projects

Overview​

In 2024, we conducted a deep evaluation of decentralized protocols for key management, transaction signing, and secure storage to inform the development of our innovative wallet solution. This report highlights projects with compelling solutions that, while not closely aligned with our conceptual design, offer valuable perspectives to enhance our system. We found their approaches inspiring, yet distinct from our project’s framework, and aim to incorporate selective cryptographic and interoperability techniques to meet our unique requirements for a secure, scalable, and future-ready decentralized wallet ecosystem.

Throttled Identity Protocol (TIP)​

Throttled Identity Protocol (TIP) makes it possible for cryptographic keys to be created from a minimal passphrase, such as a six-digit PIN, to be both secure and accessible. There are three independent components of the protocol:

  • Decentralized Network: Authenticates the integrity of requests by a distributed signer network to avoid any central point of control.

  • Trusted Account Manager: Authenticates the user identity through methods like email verification or authentication codes, straddling in between to bridge user identity and the network.

  • User: Combines their PIN with data provided by the trusted account manager to derive the ultimate key.

TIP employs a Distributed Key Generation (DKG) protocol with Boneh-Lynn-Shacham (BLS) signatures. By using the DKG protocol, the key is created in a distributed manner with the shares split across multiple parties, and BLS signatures provide compact, aggregatable, and secure verifiability. By using these together, threshold-based signing becomes feasible, where only a subset of participants need to sign for actions to be approved, enhancing security and usability.

Delegated Key Management System (DKMS)​

Delegated Key Management System (DKMS) by Magic provides a system for handling encrypted private keys. DKMS delegates critical cryptographic operations to trusted services, in this instance utilizing AWS Key Management Service (KMS) and AWS Cognito. The process functions as follows:

  • Key Generation and Sharing: Encrypted private keys are shared with the user during successful authentication. Time-limited tokens are used to generate corresponding public and private key pairs to grant temporary and controlled access.

  • Passwordless Authentication: DKMS leverages the W3C Decentralized Identifiers (DID) standard for passwordless authentication and authorization without the need for traditional passwords. Security is enhanced through the use of cryptographic identity rather than vulnerable credentials.

  • Key Decryption: Upon successful verification, the user receives his encrypted private key, which can be decrypted using a user master key. The master key is an HSM-supported key and is stored in a Hardware Security Module (HSM) for added security.

  • Service Integration: Magic orchestrates encryption and decryption operations through AWS KMS, where cryptographic keys are protected in FIPS-validated HSMs. User authentication is handled through AWS Cognito for simple and secure access management.

DKMS architecture transfers sensitive operations to AWS services without ever deviating from security, eliminating the burden from the user. HSM-protected master keys make sure that key crypto material stays secure against unauthorized use, even in the event of a breach in any other part of the system.

Silence Labs​

Silence Labs is a security company specialized in cryptography offering MPC solutions that focus on easy-to-use and secure key management for digital assets. They offer a low-level Rust library, integration tools, and decentralized network management software plans, which makes them a key player in the MPC wallet ecosystem.

Low-Level Rust Library for 2-2 MPC Wallets​

  • Overview: Silence Labs developed a low-level Rust library implementing a 2-out-of-2 TSS for MPC wallets. The library, named Silent Shard, facilitates secure key generation and transaction signing via the split of the private key into two shares, held by the user and another party.

  • Technical Details: The library is written in Rust and leverages the performance and memory safety guarantees of the language to ensure the cryptographic operations are safe and efficient. It supports ECDSA signatures and uses advanced MPC techniques to prevent any single party from knowing the whole key.

  • Bindings: The library has extensibility as a design principle, and bindings for JavaScript and TypeScript can be created.

Silence Labs offers a sound MPC solution set, starting with low-level 2-2 MPC wallets Rust library with JavaScript/TypeScript bindings and powering a Flutter SDK for cross-apps. Their Silent Shard tech supports secure, non-custodial key handling with a 2FA-like user experience, already in production applications. In development, their software for decentralized network management promises to extend this model into a completely distributed system by employing DKG and threshold cryptography to manage MPC wallets at scale. This places Silence Labs as an innovative player in the decentralized security space, balancing usability and cutting-edge cryptography.

Nillion​

Nillion is a decentralized platform that introduces a novel MPC protocol, extending the capabilities of Linear Secret-Sharing Schemes (LSSS) to enable secure computation on encrypted data. Nillion eliminates the conventional cycle of decryption, computation, and re-encryption, offering a groundbreaking approach to data privacy and security.

MPC Protocol and LSSS Extension​

  • Invention: Nillion's MPC protocol extends LSSS. The extension of LSSS by the protocol allows computations, specifically non-linear ones like SoP, to be performed on encrypted data directly, without decrypting at any step.

  • Non-Interactive Computation: Highlighted in their technical report "Evaluation of Sum-of-Products Expressions in Linear Secret Sharing Schemes with a Non-Interactive Computation Phase," Nillion's approach introduces a two-phase approach:

    • Pre-Processing Phase: Generates and distributes secret shares (masks) of terms and factors of a computation, independent of the true input values. The pre-processing utilizes basic MPC techniques (e.g., SPDZ protocol) to ensure security.

    • Computation Phase: Performs the computation on private inputs internally between nodes, without incurring communication overhead throughout the computation. This non-interactivity enhances efficiency and allows for asynchronous processes.

  • Security: The protocol benefits from the information-theoretic security (ITS) of LSSS, i.e., it is secure against any adversary trying to compromise it, no matter how powerful, as long as the number of colluding parties stays below a defined threshold.

Key Features​

  • Computation Without Decryption: By enabling computations to be performed on data encrypted inside it, Nillion removes the need for exposing sensitive information while processing. This obliterates vulnerabilities inherent in the conventional decrypt-compute-re-encrypt process, preserving important information confidential throughout.

  • Secure Storage and Computation: Nillion enables the storage and processing of valuable data in a way that it is kept secret from all parties, including the computation nodes. Data is shared to nodes in the network in a way that no node gets the complete dataset.

  • Decentralized Architecture: The platform operates on a network of nodes that collectively perform Blind Computation, a PETs-powered computation

Technical Advantages​

  • Efficiency: The non-interactive computation phase reduces latency and communication costs, allowing it to be optimized for use in real-world scenarios where fast, secure processing is required

  • Privacy: Because it never reconstructs the entire data or key during computation, Nillion asserts that sensitive inputs remain concealed, even from the network itself.

  • Scalability: Decentralized architecture and preprocessing design allow Nillion to scale computation in a distributed network of nodes, supporting complicated operations without compromising security.

Nillion introduces a revolutionary MPC protocol that extends Linear Secret-Sharing Schemes to enable secure computation over encrypted data without decrypting it, avoiding the usual decrypt-compute-re-encrypt paradigm. It allows for secure storage and processing of sensitive information without compromising it, with the support of a decentralized architecture that enhances security and trust. Through the combination of efficiency, privacy, and scalability, Nillion is a foundation for privacy-preserving Web3 and all future applications, with its continued innovation guaranteeing even more secure, decentralized computation.

ContinuumDAO​

ContinuumDAO aims to create a decentralized cross-chain communication protocol based on Secure Multi-Party Computation (SMPC). Aiming to act as a bridge between various blockchain ecosystems, it provides seamless interoperability between Ethereum Virtual Machine (EVM)-based and non-EVM blockchain networks and maintains high security and transparency via an open-source protocol.

Core Technology​

  • P2P Network with SMPC: ContinuumDAO incorporates a peer-to-peer (P2P) network of nodes that relies on an SMPC-based threshold scheme. This implies that cryptographic actions such as key generation and transaction signing are spread across multiple participants, increasing the security and eliminating single points of trust.

  • Cross-Chain Connectivity: The protocol connects both EVM-based blockchains as well as non-EVM blockchains and promotes interoperability among heterogeneous networks.

  • Evolution into a Blockchain: The network will evolve into an independent blockchain with a block reward scheme.

  • Open Source and Transparent: ContinuumDAO believes in being transparent by releasing its code as open-source, allowing it to be scrutinized by the community and contributed to in an effort to establish trust and dependability.

Cryptographic Foundation​

  • Cross-Chain Token Transfer Router: The first application will be a cross-chain token transfer router. This application will utilize the protocol's SMPC capabilities to securely move assets between blockchains without custodians or centralized bridges.

  • GG20 Algorithm: The protocol employs a distributed key management system of GG20 TSS, an improvement over the GG18 protocol designed by Gennaro and Goldfeder.

  • Signer Privacy: Identities of participating signers remain anonymous, ensuring maximum privacy and reduced chances of targeted attacks.

  • Single On-Chain Signature: Despite multi-node participation, only a single combined signature is kept on-chain, minimizing data footprint and gas costs.

  • Selective Signer Selection: The protocol offers dynamic selection among accessible signers from the node pool, ensuring maximum availability and fault tolerance.

  • Key Security: The private key is never reconstructed entirely, even during signing time, since SMPC maintains key shares distributed and incomplete in the process.

Security and Resilience Features​

  • Trusted Execution Environment (TEE): Nodes utilize TEEs to execute cryptographic computations within secure, tamper-resistant enclaves, isolating key shares and computations from external tampering.

  • Malicious Actor Detection: The ECDSA-signature-based TSS has functionality to detect rogue nodes during the signing process, enabling the network to block them and maintain integrity.

  • Asynchronous Approval: Asynchronous transaction approval is implemented in the protocol, allowing nodes to deal with requests independently and asynchronously, leading to improved performance and tolerance in a distributed system.

Decentralized Governance and Flexibility​

  • Decentralized Management: Nodes are managed by organizations, ensuring no organization has a majority influence over the network and fostering decentralization.

  • Operational Thresholds: The protocol supports multiple threshold settings (e.g., 9/15, 15/21, 21/31), allowing configuration according to the needs of the use case, i.e., larger thresholds to provide higher security or lower thresholds to provide faster consensus.

ContinuumDAO is developing a cross-chain communication protocol that is decentralized and runs on a P2P node network that is SMPC-enabled, based on the GG20 Threshold Signature Scheme. It connects EVM and non-EVM blockchains and seeks to be a blockchain offering block rewards down the line. Its first dApp, a cross-chain token transfer router, is a sign of its interoperability intention. With features like threshold signing, TEEs, malicious actor identification, and programmable signer choice, accessible via open-source code, ContinuumDAO offers a secure, expandable, and transparent option for the Web3 space, revolutionizing cross-chain infrastructure with institutional-level MPC technology.

Arpa Network​

ARPA Network is a decentralized computing network to provide tamper-evident and verifiable randomness with a Boneh-Lynn-Shacham Threshold Signature Scheme (BLS-TSS). ARPA makes use of advanced cryptographic techniques to supply tamper-evident randomness to decentralized applications (dApps), satisfying important use cases in gaming, lotteries, and probabilistic outcome scenarios.

Core Mechanism: BLS-TSS and Decentralized Randomness​

  • BLS Threshold System (BLS-TSS): ARPA employs the BLS signature scheme with an additional threshold mechanism to generate randomness. The private key, in BLS-TSS, is split into shares among network nodes using DKG. A minimum number of nodes should be used to generate a correct BLS signature such that no node can impact the outcome. The generated signature is a cryptographically secure source of entropy for random numbers.

  • Node Grouping: Nodes in the ARPA Network autonomously create groups that are controlled by smart contracts.

  • Signature Generation: When asked for randomness, nodes in a set receive task assignments from the Adapter contract, generate partial signatures, and forward them to assigned committer nodes. Committers merge the partial signatures into a single BLS signature that is verified on-chain and utilized to derive a random number. It becomes verifiable and eliminates reconstructing the whole private key.

Technical Workflow​

  • DKG Phase: Nodes are grouped by a multi-phase DKG process that is initiated by the Controller contract and governed by the Coordinator contract. When completed (up to four phases), the group posts its public key onto the blockchain.

  • Randomness Request: A dApp requests randomness through the Adapter contract, initiating a BLS-TSS task.

  • Signature Generation: Nodes within the group generate partial signatures, which committers join into a single BLS signature.

  • Verification and Delivery: The Adapter smart contract verifies the signature, re-maps it to the target type of randomness and calls back the dApp with the result. A RandomnessRequestResult event is emitted for transparency.

Benefits​

  • Decentralization: Authorized nodes are executed in a variety of regions to reduce reliance on a single point of trust and enhance physical tamper resilience.

  • Verifiability: Each random number is paired with a BLS signature, so independent on-chain verification of its correctness and fairness can be done.

  • Scalability: Parallel signature generation and dynamic grouping improve throughput, reducing the latency experienced in other TSS networks.

  • Flexibility: Modular Randcast architecture and SDK support customization to meet diverse dApp requirements.

The ARPA Network is a distributed network that generates verifiable random numbers using BLS-TSS, with groups of nodes structured to perform DKG and collaboratively form BLS signatures. Its Randcast service offers randomness to dApps for gaming, lotteries, and probability outcomes securely, ensuring fairness with on-chain verifiability. With a scalable, open-source architecture, ARPA combines cryptographic innovation and practical Web3 utility, setting a new standard for decentralized randomness.

Arch network​

The Arch Network is an execution layer that seamlessly brings smart contract capability onto the Bitcoin blockchain, natively executing on its base layer (Layer 1). Unlike Layer 2 solutions or metaprotocols, which would isolate liquidity into side chains or rely on bridges, Arch is natively integrated with the core infrastructure of Bitcoin, preserving its security and liquidity without requiring protocol updates or new opcodes.

Core Technology: FROST + ROAST Signature System​

  • Dual Signature Scheme: Arch uses a blend of the FROST and ROAST (Robust Asynchronous Schnorr Threshold Signatures) protocols. The hybrid integrates secure, programmable multisig transactions with network resilience.

    • FROST: It optimizes Schnorr threshold signatures for performance efficiency, requiring only a subset of participants to sign, with reduced communication overhead, and maintaining privacy over more traditional multisig models like MuSig. However, FROST alone does not confer robustness in adversarial or asynchronous settings.

    • ROAST: Augments FROST by introducing resilience so that even with the failure of some nodes or malicious attacks, there is transaction finality. As long as 51% of the validators remain honest, it is safe for the network to finalize transactions, achieving both security and liveness.

  • Outcome: This union allows trustless execution of advanced operations such as multi-party computation and programmable multisigs on Bitcoin's Layer 1.

Platform Components​

  • Arch Virtual Machine (Arch VM)

    • Technology: Built with eBPF (extended Berkeley Packet Filter), a sandboxed high-performance domain originally designed to build the Linux kernel. Ported onto Arch, eBPF supports Turing-complete computation, with the potential to execute complex logic and state transitions off-chain.

    • Functionality: Arch VM executes smart contracts ("programs") in Rust, performing all state updates and computations. It is scaled by running independently of the block time limit of Bitcoin, with definitive values anchored in the blockchain.

  • Decentralized Validator Network

    • Structure: A permissionless validators network employs a delegated Proof-of-Stake (PoS) consensus algorithm, quality signals like uptime and signature activity to ensure reliability.

    • Operation: Validators perform transactions in parallel, and a rotating leader node is responsible for aggregating results and proposing the ultimate signed transaction to the Bitcoin blockchain. This leadership rotation enhances decentralization and fault tolerance.

    • Verification: The network utilizes FROST + ROAST to create one aggregate signature for each transaction, minimizing on-chain information while being cryptographically verifiable.

The Arch Network is a groundbreaking execution platform that introduces Turing-complete smart contract functionality to Bitcoin's base layer with a FROST + ROAST signature scheme and an eBPF-based Arch VM. Supported by a permissionless validator network, it makes programmable transactions non-disruptive to Bitcoin's protocol, bridgeless, and secure. By enabling Bitcoin DeFi uses such as AMMs and stablecoins natively on Layer 1, Arch maintains the security, liquidity, and decentralization of Bitcoin while providing a strong base for next-generation decentralized finance on the planet's most secure blockchain.

Polygon Unified Bridge - AggLayer​

AggLayer is a decentralized network built by Polygon Labs, different from a regular blockchain. It acts as an interface layer between Polygon SDK-based blockchains, bridging their states using Zero-Knowledge (ZK) proofs. Rather than being a distinct ledger, the AggLayer is an interoperability protocol that aggregates state changes from multiple chains and proves consistency between them through cryptographic proof, ultimately settling on Ethereum. The design reduces user and liquidity fragmentation on independent blockchains, resulting in an interoperable Web3 environment.

System Components​

The AggLayer architecture comprises three primary components, each with distinct roles:

  • Main Smart Contract on Ethereum

    • Role: Acts as the settlement layer, verifying ZK proofs submitted by the AggLayer to confirm assets were correctly locked on source chains.

    • Functionality: Maintains a global state root that is representative of the combined state of all supported blockchains, being responsible for cryptographic safety and finality for cross-chain transactions.

  • Bridge Smart Contracts on Individual Blockchains

    • Purpose: Manage asset locking and unlocking on their own chains.

    • Functionality: Lock assets when transferring, buffer local state updates, and unlock or mint assets on receiving instructions backed by verified ZK proofs from the primary Ethereum contract. All bridge contracts are independent but keep pace with the AggLayer's global state.

  • AggLayer Network

    • Purpose: Decentralized network of validators that are responsible for aggregating state updates and generating ZK proofs.

    • Functionality: Collects state changes from all the bridge contracts, constructs ZK proofs to verify cross-chain transactions and forwards them to the Ethereum main contract for proof verification. It produces near-instant atomic interoperability without requiring each chain to settle individually to Ethereum.

Key Design Principles​

  • Not a Blockchain of the Past: The AggLayer is not a ledger but a protocol layer that leverages validators for state synchronizing. It leverages Polygon SDK blockchains to perform transactions and offer data availability but focuses exclusively on aggregation and proof generation.

  • Security Powered by ZK: With ZK proofs, the AggLayer allows none of the chains to withdraw assets more than it deposited, preventing fraud and offering chain-level accounting in the ecosystem.

  • Unified User Experience and Liquidity: The AggLayer reduces fragmentation by providing native asset transfers directly without wrapping or bridging delay, creating an experience analogous to that of one chain. This aligns with the vision of Polygon 2.0 for an aggregated blockchain network.

Technical Benefits​

  • Interoperability: Interoperates sovereign Polygon SDK blockchains (e.g., zkEVM rollups) without compromising their sovereignty, using a bridge to Ethereum once for settlement.

  • Scalability: Aggregates proofs of many chains into a single ZK proof, reducing gas costs and latency compared to single chain settlements.

  • Security: Leverages Ethereum security via ZK verification with pessimistic proofs to ensure correctness even when certain chains are dishonest.

  • Removal of Fragmentation: By connecting and aggregating liquidity, the AggLayer prevents the silos that plague modular blockchain ecosystems and brings them closer to users and developers.

Polygon AggLayer is a decentralized network of Polygon SDK blockchains, bringing their states into sync using ZK proofs to enable secure, virtually instant cross-chain asset transfers. It operates on a main Ethereum smart contract for verification, bridge contracts on every chain for asset management, and a validator network that calculates aggregates and generates proofs. Unlike a standard blockchain, the AggLayer focuses on interoperability and aggregation, reducing fragmentation and delivering a seamless Web3 experience without trading in the sovereignty of chains. This positions it as a cornerstone of Polygon 2.0's vision for a scalable, inter-connected blockchain ecosystem.

Phala Network​

Phala Network leverages Trusted Execution Environments (TEEs) to execute smart contract operations securely, with one added capability: the integration of AI agents into smart contracts. Executing AI operations in TEEs, Phala ensures privacy, security, and trustless automation, offering a decentralized alternative to centralized cloud providers for wallet and asset management.

TEE and AI Agent Integration​

  • Execution Environment: Phala utilizes TEEs (e.g., Intel SGX) to create secure, isolated platforms on which smart contracts are run. Within these TEEs, AI agents, are coded applications with the capacity to act independently, can perform complex operations like asset management, trading, and staking on behalf of the users.

  • User Key Delegation: The basic idea is that the user delegates their private key (or a derivative of it) to an AI agent running inside a TEE. The TEE prevents the key from being exposed and used only according to the prewritten logic of the AI agent. This enables the AI to:

    • Control Assets: Automate trades, stake tokens, or rebalance portfolios based on market conditions or as instructed by the user.

    • Decentralized Automation: In comparison with centralized cloud providers (such as AWS-managed wallet services), which are based on trust in a third party, Phala's TEE-based approach ensures that the AI will execute in a trustless, decentralized manner, with no single entity being able to access or monetize the key.

  • AI Operations in TEE: AI agent's computation, such as market research or prediction modeling, occurs fully within the TEE. This protects sensitive data (e.g., user balances, trading strategy) from exposure, even to the node operator which hosts the TEE.

Key Management in TEE​

  • Salt and Key Derivation: The "salt" is expected to be a high-entropy input (i.e., the user's input, e.g., seed phrase, mnemonic, or random value) used to deterministically derive a private key. In cryptology, a salt is most typically blended with other inputs (i.e., in a key derivation function like PBKDF2 or Argon2) to produce a secure key. Here:

    • The user supplies the salt (i.e., mnemonic phrase) to the AI agent running inside the TEE.

    • The AI agent uses the salt to construct the private key, likely following a standard like BIP-39 (for mnemonic-to-seed conversion) and BIP-32 (for hierarchical deterministic key derivation).

  • Key Storage in Memory: Once created, the private key is retained in memory within the TEE during the AI agent's active session. The TEE's hardware-enforced isolation ensures that this key will not be exposed to external processes, the node operator, or even to other processes executing on the same host.

    • Security Impact: The key is stored in memory for a temporary time only when the AI agent is present, limiting risks from storage vulnerabilities. When the agent no longer exists or the TEE is reset, the key is deleted from memory, adhering to best practices of secure key handling.

    • Security Proof: As the diagram in the X post would suggest, the TEE generates a proof whenever the wallet (or key) is queried, verifying the integrity of the environment and demonstrating that the key remains secure.

  • Comparison to Alternatives: Unlike cloud providers that are centralized, where a user's private key might be stored on a server with less stringent security guarantees and thus become susceptible to possible breaches or insider attacks, Phala's TEE never allows the key to exist anywhere outside of the secure enclave even when being used actively.

Technical Advantages​

  • Privacy and Security: The TEE ensures that the logic of neither the AI agent nor the user's private key is exposed to any external party, providing confidential computation. It is crucial for sensitive operations like trading or staking, where one's plan and balance need to be hidden.

  • Decentralized Automation: By delegating asset management to an AI agent within a TEE, users can automate high-level tasks (like rebalancing a DeFi portfolio based on market signals) without needing to trust a central custodian, as dictated by Web3's trustless ideology.

  • Scalability: Phala's architecture, with nodes hosted on TEEs, can scale computation off-chain and keep results tethered to the blockchain (via Phala's Phat Contract), reducing on-chain overhead and enabling AI-driven workloads.

Potential Risks and Considerations​

  • TEE Weaknesses: While TEEs like Intel SGX provide strong isolation, they are far from attack-proof (e.g., side-channel attacks like Spectre or SGX-specific attacks). Phala mitigates this by having strict node attestation and regular security audits.

  • Private Key in Memory: Keeping the private key in memory while the AI agent runs creates a risk window. If the TEE was breached within this time window, the key would be compromised. Phala's design, however, makes breaching hardware-level security necessary for such an attack, which is an unreasonably high requirement for attackers.

  • User Trust: Users must have faith that the reasoning of the AI agent (e.g., the trading algorithm) is working as intended. Phala addresses this by supporting open code audits and utilizing immutable Phat Contracts for execution.

Phala Network leverages TEEs to execute smart contracts and host AI agents, facilitating secure, decentralized asset management. Users bind a salt (e.g., mnemonic) to an AI agent within a TEE, which calculates and holds the private key in memory during execution, using it to manage assets, trade, or stake for them. This contrasts with trusted centralized cloud providers by offering trustless automation, with the TEE ensuring confidentiality of the key and generating proofs of secure execution. While threats such as TEE vulnerabilities do exist, Phala's solution makes possible a scalable and privacy-preserving system for its AI-driven Web3 applications.

Summary​

The explored projects, Throttled Identity Protocol (TIP), Delegated Key Management System (DKMS), Silence Labs, Nillion, ContinuumDAO, ARPA Network, Arch Network, Polygon Unified Bridge (AggLayer), and Phala Network, offer complementary technologies that share touchpoints with our project while providing unique approaches to decentralized key management and secure computation. TIP and ARPA Network both leverage Distributed Key Generation (DKG) combined with Boneh-Lynn-Shacham (BLS) Threshold Signature Schemes (BLS-TSS), with ARPA’s node grouping mechanism enhancing scalability and verifiability for randomness generation, aligning with our interest in efficient, secure cryptographic protocols. DKMS utilizes W3C Decentralized Identifiers (DID) for passwordless authentication, providing a standardized approach to secure identity management that complements our authentication goals. Silence Labs’ use of Threshold Signature Schemes (TSS) and Multi-Party Computation (MPC) in its Silent Shard library ensures secure, non-custodial key handling, offering a robust model for our MPC-based wallet solutions. Nillion’s extension of Linear Secret-Sharing Schemes (LSSS) enables secure computation on encrypted data without decryption, supporting our aim for privacy-preserving operations. ContinuumDAO’s GG20 TSS and Cross-Chain Token Transfer Router provide secure key management and interoperability across EVM and non-EVM blockchains, aligning with our cross-chain ambitions. Arch Network’s integration of FROST and ROAST with a decentralized validator network enables efficient, resilient transaction signing on Bitcoin’s Layer 1, offering insights for our transaction processing needs. Polygon’s AggLayer employs Zero-Knowledge proofs to aggregate state changes across blockchains, enhancing interoperability and scalability, which informs our cross-chain synchronization strategies. Phala Network’s use of Trusted Execution Environments (TEEs) for key management and user key delegation to AI agents provides a trustless, privacy-focused model for automated asset management, relevant to our automation objectives. Collectively, these projects inspire our development by demonstrating scalable, secure, and interoperable solutions for decentralized key management, computation, and cross-chain functionality, guiding our project toward a robust, privacy-preserving, and efficient Web3 ecosystem.