Zend It!

Zend It is a developer tool designed to provide secure and transparent blockchain transactions, especially when using Ledger hardware wallets. It enhances user confidence by offering a preview and then a transaction verification before signing, using a multi-step process that ensures accuracy and safety.

Key Features: -Transaction Verification: When a user initiates a transaction, such as a swap on Polygon or Unichain, Zend It introduces a verification step before signing. This prevents accidental or malicious transactions from proceeding without scrutiny.

-Ledger Integration: For users with a Ledger wallet, Zend It uses Ledger's clear signing feature. If the smart contract is pre-approved by Ledger, the transaction details are displayed directly on the Ledger device, allowing the user to review every aspect before approval.

• EIP-712 For Everyone: Zend It uses the EIP-712 standard to handle off-chain to on-chain communication securely using a zero knowledge virtual machine. This proof is returned to the user along with a clear message explaining the transaction’s intent. The smart contract's data is formatted in JSON, verified, and then presented in a clear, understandable format for the user.

-Polygon zkApp: Built as a zkApp on the Polygon blockchain, Zend It leverages the speed, scalability, and security of Polygon’s layer-2 solution, integrating zero-knowledge proofs directly into the transaction’s execution trace. We prove the transaction would occur on chain in a safe and private manner, off chain, using zkm.

-We utilize a Claude API integration that allows users to input a contract address and ABI and automatically returns a formatted ERC 7730 and EIP 712 formatting standard for their contract

ZendIt is a Developer’s Tool for allowing users to verify any contract with or without ledger but you still get that strong EIP 712 Experience for any transaction your users interact with.

Frontend:

-React & Typescript -Ledger API Integration: We integrated Ledger’s API to enable clear signing for smart contracts. This allows users to verify transaction details directly on their Ledger hardware wallet, ensuring that users can review the transaction securely before signing.

Backend:

–Node.js & Express: The backend API is built with Node.js and Express to handle incoming requests from the frontend and perform critical transaction verifications.

–Ethers.js: For blockchain interactions, we used Ethers.js to communicate with smart contracts on Polygon and Unichain. This library simplifies contract calls, allowing us to fetch the contract’s ABI and decode input data.

-Zero-Knowledge Proofs (ZKP): We used ZKM, to generate ZKPs, which ensures the transaction simulation results can be trusted and verified EIP712’s as well as their provable execution trace for all preceding transactions if the execution were to have taken place. For contracts that aren’t pre-approved by Ledger, Zend It will allow any contract to be both verifiable and clear!

-Claude AI API: intakes contract and ABI for formatting for the EIP 712 and ERC 7730 standards, allowing a seamless user experience by ingesting the raw contract data behind the scenes and passing along the relevant information for these standards so that developers can easily transition to this better framework, increasing adoption with an additional dev tool

-Transaction Simulation: For non-approved contracts, the backend simulates the transaction by recreating it in a safe environment. This simulation helps ensure the transaction will execute as expected without any unexpected consequences. We use Temper.rs to simulate the results and then the Polygon RPC for simulating the chain’s real time data utilizing an off chain ZKM.

Blockchain:

-Polygon zkApp: Zend It was built as a zkApp on the Polygon blockchain, taking full advantage of Polygon’s fast and scalable infrastructure. Building on Polygon allowed us to integrate zero-knowledge proofs (ZKP) natively within the blockchain, reducing transaction costs while ensuring security.

-EIP-712 Standard: We used the EIP-712 standard to securely handle and format the transaction data. This allows for easy verification of off-chain messages before they are signed and sent on-chain. In the Backend, using the ABI, we generate the 7730 Schema and are able to get the ledger live to verify an off chain generated clear sign.

Partner Technologies:

-Ledger Hardware Wallet: By integrating Ledger’s API, Zend It provides users with a hardware-secured environment for signing transactions for any smart contract they want to interact with before signing. This hardware integration benefits the project by enhancing trust and security for users, allowing them to verify all transaction details on a trusted device.

-Etherscan: We rely on Etherscan to retrieve verified contract ABIs for decoding transaction data. This ensures that our backend can properly analyze the functions and inputs of any smart contract before it is signed.

How It All Fits Together: When a user initiates a transaction, Zend It kicks in to offer verification before signing. The frontend sends transaction data like the ABI and 712 payload to the zkm backend, where it’s processed for Ledger’s clear signing and simulates transactions ahead of time in a verifiable manner. If the contract is approved by Ledger, users see the transaction details on their Ledger wallet screen. If not, the backend simulates the transaction, fetches the contract ABI from Etherscan, and decodes the transaction’s data. A ZKP is generated to prove the simulation was correct without revealing sensitive information. This information is then sent back to the frontend, where the user can review all details before deciding to sign the transaction, by instead plainly understanding the transaction using the Clear Messaging Standard detailed in the JSON response that is formatted for the user to see the clear text version of their contract in readable format.

Benefits of Partner Technologies:

-Ledger: By leveraging Ledger’s hardware-based security, we ensured that users could interact with blockchain networks in a secure and transparent way. By making it easy for devs to use EIP712, we can increase adoption of this standard and promote the adoption of ERC7730 as the next logical step.

-Polygon zkApp: Building on Polygon allowed us to scale our application and take advantage of the network’s ZKP capabilities, reducing gas fees and increasing transaction throughput. By applying ZKM to polygon for formal proof verification of our off chain prover process of user’s transaction details, we can use Polygon’s to verify the prover’s intent was fulfilled correctly and was properly indexed from polygon’s list of possible smart contract. We binded the POST request as the input from the EIP712 Message we formatted including the Contract’s ABI and address and Chain ID including all other relevant information. The Chain can verify that the proof does in fact match the clear sign that was returned from the user’s request to verify the smart contract before signing.

-PolygonScan and Etherscan: For Both POL Mumbai and ETH Sepolia testnet, for contract verification we ensured that we could pull accurate contract data, enabling smooth transaction simulations and verifications.

Notable mentions during the hack: We discovered the lack of transparency in the auditability of transactions on all chains, and became deeply committed to building tooling that addresses a problem user’s in any ecosystem may face. To succeed, we had to be able to push the same project across multiple ecosystems while maintaining consistency across the 5 members of our team. We discovered that, we can allow a ledger device to interact with unverified EIP 712 standard contacts that do not implement the 7730- this essentially funnels users into 7730 compliance

With 712 you take the necessary info you need, we generate a trace of what the execution looks like (like Tenderly). Now this returns a zkp to the ledger user, that if they interact with this unverified contract, that the user (blindsign they see in the ledger CAN be trusted because Zent it meant it when it proved that the message that was Zent matches the ZKP’s execution Trace, which is returned by our service. Now every ledger user can, can simulate, verify, and transact in a state of zen- stress free sending send with zen, send with zend it.

We are adapting and scaling the adoption of EIP 712 by giving developers a tool for building out ERC 7730s for their own contracts, using a Claude AI integration that does the heavy lifting for them