Introducing BYOABI

We’re introducing Bring Your Own ABI (BYOABI), a new capability that allows Dfns clients to import smart contracts schemas and interact with them directly from Dfns as a central operating system for onchain activity. An ABI (Application Binary Interface) is the contract’s public interface: it describes which functions exist, what parameters they take, and how to encode calls so wallets or apps can interact with the contract correctly.

With BYOABI, wallets managed in Dfns can call smart contract functions natively. This includes actions such as minting, burning, pausing, transferring tokens, and managing the full lifecycle of onchain assets, as well as any other function exposed by a contract’s ABI. The management and registration of contract schemas is handled in the Dashboard, while invoking smart contract functions using the ABI can already be done via API today. All interactions inherit the same security model, governance controls, and auditability that apply to every transaction within a Dfns organization.

This capability upgrades Dfns from a system that primarily managed wallets and transactions to one that now operates smart contracts, safely and at scale.

BYOABI is extending wallets to token operations

Smart contracts define how blockchains work. They control how tokens behave, how assets are issued and settled, and how onchain governance is enforced. Yet for most organizations, using those contracts is still complex and limited to a small group of engineers.

Today, teams rely on a mix of tools: block explorers for one-off actions, custom scripts built on blockchain libraries, ABIs copied by hand, and calldata encoded manually. Engineers execute transactions, while operations, treasury, risk, and compliance teams remain outside the process. Approvals and governance happen offchain, disconnected from execution. This creates blind spots, friction, and operational risk. As more financial institutions move onchain, this approach does not scale.

BYOABI exists to close that gap and to bring Dfns to feature parity with tokenization engines offered by other custody and infrastructure providers. It allows Dfns wallets to interact with smart contracts in a structured, governed, and auditable way, without requiring customers to build custom tooling or rely on external interfaces. However, BYOABI is intentionally limited in scope.

Dfns remains agnostic to the smart contract itself. BYOABI simply enables wallets to safely perform explicit contract actions (e.g., mint, burn, pause, calls functions) under strong security and governance controls. Contract logic stays external and remains owned by the customer or their tokenization provider. In this way, BYOABI reinforces Dfns’ role as the secure execution and control layer. It brings smart contract interactions into the same governance and audit model as wallets and transactions, while leaving business logic and managed services to the platforms best positioned to deliver them.

The new smart contract interactions BYOABI enables

BYOABI lets customers register a smart contract in Dfns using its onchain address and ABI. Once registered, the contract becomes a first-class object in the organization, just like a wallet or a policy. In practice, BYOABI allows teams to:

• Import and name smart contracts using their ABI and address
• Automatically discover the contract’s supported functions
• Run read-only calls and state-changing transactions from Dfns wallets
• Operate contracts through a native dashboard (API coming up)
• [Soon] Apply policies, approvals, and permissions to specific contract actions

The first release supports Ethereum and EVM-compatible networks. BYOABI is designed to be chain-agnostic, and any smart contract platform with a structured interface definition can be supported over time. We don’t pick chains. We support how customers build.

Onchain, a smart contract is deployed as bytecode at a public address. The ABI describes how to interact with that bytecode by defining the contract’s functions and parameters in a human-readable way. With BYOABI, customers provide an ABI in JSON format through the Dfns UI or API. Dfns parses the ABI and generates a structured interaction model that is used consistently across the UI and APIs. Inputs are typed, validated server-side, and safely converted into onchain calls.

BYOABI supports two interaction modes:

1. Read-only calls: These calls read the onchain state without changing it. They do not require signing, are not broadcast to the network, and do not consume gas. They are typically used to read balances, ownership, configuration values, or contract metadata.
2. State-changing transactions: These calls modify contract state. They are signed by a Dfns wallet, evaluated by the policy engine, broadcast to the network, and tracked through execution and confirmation. This is how teams mint tokens, pause contracts, update parameters, or trigger protocol logic.

In both cases, teams no longer need to manually encode calldata or rely on external tools.

Uses cases that require token lifecycle management

BYOABI enables teams to manage the full lifecycle of a token from a single control plane. Instead of relying on custom scripts or external tools, contract operations can be executed directly from Dfns, under the same policies and approval flows as any other transaction. Examples:

• Minting and burning supply: Issuers can mint new tokens for issuance, redemption, or rebalancing, and burn tokens during redemptions or supply reductions. These actions are signed by Dfns wallets and governed by approval policies.
• Pausing and resuming transfers: For tokens that support emergency controls, teams can pause transfers during incidents and resume them once resolved, with each action logged and auditable.
• Administrative and governance actions: Contract owners can update parameters such as fees, limits, allowlists, or roles by calling the corresponding contract functions, without manually crafting transactions.
• Protocol-specific operations: BYOABI exposes custom functions defined by the contract, such as upgrading modules, settling batches, distributing rewards, or triggering scheduled logic.

These capabilities are especially important for stablecoins, tokenized assets, and internal settlement instruments, where execution must be controlled, traceable, and compliant. For example, a stablecoin issuer can restrict minting to a specific approval group, require multi-step validation for pauses, and keep a full audit trail of all administrative actions.

Beyond tokens, the same model applies to broader smart contract operations. Teams can use BYOABI for protocol administration, treasury management, participation in onchain governance, and the day-to-day operation of complex contract-based systems, all from within Dfns.

Security and governance built into execution

A central design principle of BYOABI is that smart contract calls should be governed in the same way as transactions. Contract registration, updates, and function invocations integrate directly with Dfns’ policies and authorization model. This allows organizations to enforce rules such as:

• Approval requirements for importing or deleting contracts
• Multi-party approvals for sensitive or high-risk operations
• Full audit trails for every interaction

Next up: Restrictions on which wallets, roles, or environments can call specific functions thanks to ABI-aware policies and permissions.

Smart contracts and their ABIs are managed through the same change-request model used across Dfns, ensuring visibility, traceability, and operational control. Over time, this will expand to include more granular permissions, function-level policies, and dedicated smart contract security controls.

Next: More networks, more security, more compliance 

The first BYOABI release focuses on Ethereum and EVM-compatible networks. The underlying design is built to support other smart-contract platforms over time, including ecosystems such as Solana, Stellar, Canton, and similar networks. Many non-EVM chains expose comparable contract or program interfaces, and BYOABI is designed to support them through appropriate abstractions and security models.

Future versions will extend the feature set, including support for more complex contract and program types, stronger policy controls, and deeper security and permissioning capabilities. Smart contracts are now production infrastructure. With BYOABI, Dfns brings wallets, smart contracts, governance, and security into a single system. It allows organizations to move beyond simply signing transactions and toward operating and governing onchain systems in a controlled and reliable way. This is a foundational step toward making Dfns the operating system for institutional onchain activity.

Learn more about BYOABI and get started: app.dfns.io/get-started