Documentation

Bunny Financial Documentation

Understand the protocol behind the interface.

Explore Bunny Financial architecture, protocol modules, wallet interactions, transaction states, smart-contract concepts, developer workflows and security considerations.

Explore Documentation Bunny on GitHub
Always verify deployed contracts independently from documentation.
Documentation Index
Documentation type Protocol and developer reference
BF Bunny Financial Protocol
  • 01
    Getting Started Core concepts and access
  • 02
    Protocol Architecture Layers and responsibilities
  • 03
    Protocol Modules DEX, pools and token launch
  • 04
    Wallet Interaction Connection and authorization
  • 05
    Security Verification and risk controls
Start with Protocol Basics
01 Protocol users

Understand what occurs before and after wallet authorization.

02 Developers

Review protocol layers, interfaces and integration concepts.

03 Researchers

Examine protocol assumptions, states and technical boundaries.

04 Token teams

Understand token configuration and launch infrastructure.

Documentation purpose

Technical context for every protocol action.

Bunny documentation explains how the visible application, connected wallet, smart-contract logic and blockchain settlement layer relate to one another.

The documentation is intended to help users and developers distinguish interface behavior from wallet authorization and on-chain execution.

Documentation describes intended functionality, but deployed contract addresses, network conditions and external dependencies should always be verified independently.

Documentation sections

Choose the technical area you need.

Use the protocol overview for architecture, module pages for function-specific details and GitHub for open-source resources.

01 / OVERVIEW

Protocol Overview

Review Bunny architecture, protocol boundaries, wallet-based access and blockchain settlement.

Architecture Protocol layers Settlement
↗
02 / EXCHANGE

Decentralized Exchange

Understand swap preparation, liquidity routing, price impact, slippage and wallet authorization.

Swap Routing Slippage
↗
03 / LIQUIDITY

Liquidity Pools

Review pool reserves, liquidity positions, trading fees, changing asset composition and impermanent loss.

Pools LP positions Fees
↗
04 / TOKEN LAUNCH

Token Infrastructure

Explore token supply, contract permissions, deployment, distribution and initial liquidity preparation.

Supply Contracts Deployment
↗
05 / SECURITY

Security Model

Review domain verification, token approvals, wallet prompts, contract addresses and responsible disclosure.

Wallet safety Approvals Verification
↗
06 / SOURCE

GitHub and Development

Explore open-source components, repository structure, version history and contribution guidance.

Source code Versioning Contributions
↗
User access layer Interaction
Wallet
Bunny App
Knowledge Base
Application layer Preparation
Swap Interface
Pool Interface
Token Builder
Protocol layer Execution logic
Smart Contracts
Token Logic
Liquidity Logic
Blockchain layer Settlement
Transactions
Network Fees
Public Records

Protocol architecture

Each layer has a separate responsibility.

Bunny separates visible application behavior from wallet authorization, protocol execution and blockchain settlement.

  • 01
    Access layer

    The wallet represents the user’s public blockchain identity and controls transaction authorization.

  • 02
    Application layer

    The interface organizes supported protocol actions and prepares information for review.

  • 03
    Protocol layer

    Smart contracts define executable rules for supported on-chain interactions.

  • 04
    Settlement layer

    The blockchain validates signed transactions and records the final result.

Getting started

Understand the transaction before using the application.

01

Select the intended module

Choose decentralized exchange, liquidity, token launch or another documented protocol function.

02

Confirm the network

Verify the selected blockchain and ensure the wallet holds the native asset required for network fees.

03

Connect a compatible wallet

Initiate the wallet connection through the official Bunny interface without disclosing private credentials.

04

Configure the action

Enter token amounts, pool information, contract parameters or other settings required by the selected module.

05

Review the prepared request

Check assets, addresses, permissions, estimated results, slippage and network fees.

06

Authorize through the wallet

The wallet presents the final request. The user decides whether to sign, reject or modify the intended action.

Protocol modules

Core Bunny functionality.

Each module prepares a different type of blockchain interaction and exposes users to a different combination of technical and market risk.

01 / DEX

Token exchange

Prepares decentralized swaps using compatible liquidity, estimated routes and user-defined transaction settings.

DEX Documentation
02 / POOLS

Liquidity provision

Supports wallet-authorized liquidity positions involving pool shares, changing reserves and protocol fees.

Liquidity Documentation
03 / TOKEN

Token configuration

Organizes token identity, supply, permissions, deployment and initial liquidity preparation.

Token Documentation
04 / WALLET

Wallet interaction

Connects the user-facing application with the wallet used to review and authorize blockchain requests.

Wallet Guide
05 / SECURITY

Verification controls

Covers domains, token addresses, contract permissions, wallet prompts and active approvals.

Security Documentation
06 / SOURCE

Open development

Provides repository, contribution and versioning context for technical review.

GitHub Overview

Wallet connection

Connection and authorization are separate actions.

A basic connection allows the interface to identify a public wallet address and selected network. It should not require the user to disclose a recovery phrase or private key.

Token approvals, message signatures and blockchain transactions require additional wallet requests. Each request should be reviewed as a separate security decision.

Review Wallet Security
Wallet interaction Authorization boundary
Current connection Not connected
Application Prepare request
→
Wallet Sign or reject
Public address Visible after connection
Private key Never shared
Transaction request User reviewed
Final authorization Wallet required

Transaction lifecycle

From interface input to blockchain confirmation.

A transaction moves through multiple stages. A prepared request is not complete until it has been signed, submitted and confirmed by the selected blockchain.

01

Configure

The user defines the intended protocol action.

02

Estimate

The interface presents available transaction information.

03

Authorize

The connected wallet requests user approval.

04

Submit

The signed request is sent to the blockchain network.

05

Confirm

The processed result is recorded on-chain.

Transaction states

Understand what each status means.

The application may display temporary states while waiting for wallet authorization or blockchain processing.

01 / PREPARED

Ready for review

The interface has prepared transaction information, but no wallet signature has been provided.

No on-chain action
02 / AWAITING SIGNATURE

Wallet decision required

The wallet is displaying a request that the user may approve, reject or close.

User authorization
03 / PENDING

Submitted to the network

The transaction has been signed and submitted but has not yet received final blockchain confirmation.

Network processing
04 / CONFIRMED

Recorded on-chain

The blockchain has processed the transaction and recorded the resulting state change.

Public transaction record
05 / FAILED

Execution did not complete

The transaction may have failed because of contract conditions, slippage, insufficient fees or another execution issue.

Network fee may still apply
06 / REJECTED

Not authorized by the wallet

The user rejected or closed the wallet request before the transaction was submitted.

No submission
integration.model concept reference
// Bunny protocol interaction wallet.connect(); network.verify(); request.prepare(action); user.review(request); wallet.authorize(request); blockchain.settle();
Authorization User wallet
Execution Smart contract
Settlement Blockchain
Result Public record

Developer integration

Build around verified interfaces and explicit user consent.

Integrations should preserve clear separation between application logic, wallet authorization and smart-contract execution.

  • 01
    Verify supported networks

    Do not assume that contract addresses or token standards are identical across networks.

  • 02
    Handle wallet state clearly

    Distinguish disconnected, connected, unsupported and incorrect-network states.

  • 03
    Present transaction details

    Show relevant assets, amounts, addresses, permissions and estimated costs before signing.

  • 04
    Confirm the on-chain result

    Use the blockchain transaction state rather than assuming that wallet authorization means success.

Explore Open-Source Resources

Versions and deployments

Documentation, source code and live contracts are distinct.

Developers and users should verify that the resources they review match the intended protocol version and blockchain deployment.

01 / DOCUMENTATION

Written reference

Explains intended architecture, protocol behavior, integration concepts and security boundaries.

02 / REPOSITORY

Published source code

May contain released, experimental or development code depending on the selected branch and version.

03 / DEPLOYMENT

Live blockchain contract

The actual contract address processing transactions on the selected blockchain network.

04 / INTERFACE

User application version

The visible application used to prepare and present supported protocol actions.

05 / DEPENDENCY

External infrastructure

Wallets, tokens, pools and services outside Bunny may change independently.

06 / VERIFICATION

Independent comparison

Users and developers should compare documented information with the intended live environment.

Security documentation

Documentation supports verification. It does not eliminate risk.

Users should verify the official website, blockchain network, contract address, token identity, approval amount and wallet request before every transaction.

Open Security Guide Read Risk Disclosure
Technical verification routine
01
Verify the source

Use only official Bunny documentation and repository links.

02
Verify the deployment

Confirm the blockchain network and exact contract address.

03
Verify permissions

Review token approvals and administrative contract controls.

04
Verify the wallet request

Reject any signature or transaction you do not understand.

Documentation boundaries

What technical documentation can and cannot provide.

Documentation is an explanatory resource, not a guarantee of security, compatibility or financial outcome.

Documentation can

Explain intended protocol behavior.

  • Describe protocol layers and responsibilities
  • Explain supported transaction workflows
  • Document wallet and contract interactions
  • Identify relevant security considerations
  • Support technical review and integration planning
  • Clarify terminology and transaction states
Documentation cannot

Guarantee a live system or transaction result.

  • Guarantee that a contract contains no vulnerabilities
  • Guarantee compatibility with every external wallet
  • Guarantee that a transaction will be confirmed
  • Reverse completed blockchain transactions
  • Guarantee token liquidity or financial performance
  • Replace independent legal or security review

Documentation FAQ

Common questions about Bunny technical resources.

Who is Bunny Documentation for?
The documentation is intended for protocol users, developers, researchers, integrators and token teams that need technical context about Bunny Financial.
What is the difference between Documentation and the Knowledge Base?
The Knowledge Base focuses on practical user education and DeFi concepts. Documentation focuses more deeply on protocol architecture, technical workflows and integration boundaries.
Does the documentation contain private wallet information?
No. Private keys, wallet recovery phrases and confidential credentials should never be included in documentation, repositories or support requests.
Does documented code guarantee that a contract is secure?
No. Documentation and published source code support review, but they cannot guarantee that every vulnerability, dependency issue or deployment error has been identified.
How do I verify a Bunny contract?
Confirm the blockchain network and exact contract address through official Bunny resources, then compare that information with the live blockchain deployment.
Is connecting a wallet the same as signing a transaction?
No. A connection generally exposes the public address and selected network to the application. A transaction or signature requires an additional wallet authorization request.
Can external developers integrate Bunny functionality?
Integration depends on available interfaces, network support, licenses, technical compatibility and the security requirements of the relevant protocol component.
Where should a potential vulnerability be reported?
Use the official Bunny contact process and report the issue privately with reproduction steps, potential impact and relevant technical evidence.

Continue exploring

Review the protocol or inspect the open-source structure.

Continue to the protocol overview for architecture or open the Bunny GitHub page for repository and development guidance.

Protocol Overview Bunny on GitHub