@unicitylabs/bridge-plugin 0.2.0-dev.1

package/lib/evm/family.js

@@ -0,0 +1,21 @@
+import { toEvmAddressHex } from '../address.js';
+import { EVM_DEFAULT_CONFIRMATIONS } from './config.js';
+import { EvmJsonRpcClient } from './EvmRpcClient.js';
+import { evmPresentation } from './presentation.js';
+export function evmChainRef(chainId) {
+    return `eip155:${chainId}`;
+}
+export const evmFamily = {
+    family: 'eip155',
+    chainName: 'Ethereum',
+    defaultConfirmations: EVM_DEFAULT_CONFIRMATIONS,
+    blockSeconds: 12,
+    chainRef: evmChainRef,
+    normalizeAddress: toEvmAddressHex,
+    createRpc: ({ rpcUrl }) => {
+        if (!rpcUrl)
+            throw new Error('An Ethereum-family bridge needs an rpcUrl.');
+        return new EvmJsonRpcClient({ rpcUrl });
+    },
+    presentation: evmPresentation,
+};

package/lib/evm/index.d.ts

@@ -0,0 +1,6 @@
+export * from './config.js';
+export * from './EvmRpcClient.js';
+export * from './family.js';
+export * from './presentation.js';
+export * from './providers.js';
+export * from './signer.js';

package/lib/evm/index.js

@@ -0,0 +1,6 @@
+export * from './config.js';
+export * from './EvmRpcClient.js';
+export * from './family.js';
+export * from './presentation.js';
+export * from './providers.js';
+export * from './signer.js';

package/lib/evm/presentation.d.ts

@@ -0,0 +1,4 @@
+import type { BridgePresentation } from '@unicitylabs/bridge-core';
+export declare function evmExplorerTxUrl(chainId: number, txid: string): string;
+export declare function isValidEvmAddress(addr: string): boolean;
+export declare function evmPresentation(chainId: number): BridgePresentation;

package/lib/evm/presentation.js

@@ -0,0 +1,21 @@
+import { ETHEREUM_MAINNET_CHAIN_ID, SEPOLIA_CHAIN_ID } from './config.js';
+const EXPLORERS = {
+    [ETHEREUM_MAINNET_CHAIN_ID]: 'https://etherscan.io',
+    [SEPOLIA_CHAIN_ID]: 'https://sepolia.etherscan.io',
+};
+function with0x(hex) {
+    return hex.startsWith('0x') || hex.startsWith('0X') ? hex : `0x${hex}`;
+}
+export function evmExplorerTxUrl(chainId, txid) {
+    const base = EXPLORERS[chainId] ?? 'https://blockscan.com';
+    return `${base}/tx/${with0x(txid)}`;
+}
+export function isValidEvmAddress(addr) {
+    return /^0x[0-9a-fA-F]{40}$/.test(addr.trim());
+}
+export function evmPresentation(chainId) {
+    return {
+        explorerTxUrl: (txid) => evmExplorerTxUrl(chainId, txid),
+        validateAddress: (addr) => isValidEvmAddress(addr),
+    };
+}

package/lib/evm/providers.d.ts

@@ -0,0 +1,3 @@
+import type { SourceWalletProvider } from '../wallet/signer.js';
+import { type EvmWindow } from './signer.js';
+export declare function injectedEvmProvider(win?: EvmWindow): SourceWalletProvider;

package/lib/evm/providers.js

@@ -0,0 +1,9 @@
+import { InjectedEvmSigner } from './signer.js';
+export function injectedEvmProvider(win = globalThis) {
+    return {
+        id: 'injected-evm',
+        name: 'MetaMask',
+        isAvailable: () => Boolean(win.ethereum),
+        create: (chainId) => new InjectedEvmSigner(win, chainId),
+    };
+}

package/lib/evm/signer.d.ts

@@ -0,0 +1,43 @@
+import { type ContractCall } from '../contract-call.js';
+import type { SourceSigner, WalletChange } from '../wallet/signer.js';
+export interface Eip1193Provider {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on?(event: string, listener: (...args: unknown[]) => void): void;
+    removeListener?(event: string, listener: (...args: unknown[]) => void): void;
+}
+export interface EvmWindow {
+    ethereum?: Eip1193Provider;
+}
+export declare class InjectedEvmSigner implements SourceSigner {
+    private readonly win;
+    private readonly expectedChainId?;
+    constructor(win?: EvmWindow, expectedChainId?: number | undefined);
+    private provider;
+    connect(): Promise<string>;
+    private switchTo;
+    getAddress(): Promise<string>;
+    getNetwork(): Promise<number>;
+    onChange(cb: (e: WalletChange) => void): () => void;
+    sendCall(call: ContractCall): Promise<string>;
+}
+export interface EvmTxSender {
+    getAddress(): Promise<string>;
+    sendTransaction(tx: {
+        to: string;
+        data: string;
+    }): Promise<{
+        hash: string;
+    }>;
+}
+export declare class ManagedEvmSigner implements SourceSigner {
+    private readonly sender;
+    private readonly chainId;
+    constructor(sender: EvmTxSender, chainId: number);
+    connect(): Promise<string>;
+    getAddress(): Promise<string>;
+    getNetwork(): Promise<number>;
+    sendCall(call: ContractCall): Promise<string>;
+}

package/lib/evm/signer.js

@@ -0,0 +1,91 @@
+import { encodeCallData } from '../contract-call.js';
+export class InjectedEvmSigner {
+    win;
+    expectedChainId;
+    constructor(win = globalThis, expectedChainId) {
+        this.win = win;
+        this.expectedChainId = expectedChainId;
+    }
+    provider() {
+        const p = this.win.ethereum;
+        if (!p) {
+            throw new Error('No Ethereum wallet found. Install MetaMask and reload.');
+        }
+        return p;
+    }
+    async connect() {
+        const accounts = (await this.provider().request({ method: 'eth_requestAccounts' }));
+        const address = accounts?.[0];
+        if (!address) {
+            throw new Error('The Ethereum wallet is locked or no account is selected.');
+        }
+        if (this.expectedChainId !== undefined && (await this.getNetwork()) !== this.expectedChainId) {
+            await this.switchTo(this.expectedChainId);
+        }
+        return address;
+    }
+    async switchTo(chainId) {
+        try {
+            await this.provider().request({ method: 'wallet_switchEthereumChain', params: [{ chainId: `0x${chainId.toString(16)}` }] });
+        }
+        catch {
+            return;
+        }
+    }
+    async getAddress() {
+        const accounts = (await this.provider().request({ method: 'eth_accounts' }));
+        return accounts?.[0] ?? this.connect();
+    }
+    async getNetwork() {
+        const id = (await this.provider().request({ method: 'eth_chainId' }));
+        return Number.parseInt(id, 16);
+    }
+    onChange(cb) {
+        const p = this.provider();
+        if (!p.on || !p.removeListener)
+            return () => { };
+        const listeners = [
+            ['accountsChanged', () => cb({ kind: 'accountsChanged' })],
+            ['chainChanged', () => cb({ kind: 'chainChanged' })],
+            ['disconnect', () => cb({ kind: 'disconnect' })],
+        ];
+        for (const [event, listener] of listeners)
+            p.on(event, listener);
+        return () => {
+            for (const [event, listener] of listeners)
+                p.removeListener?.(event, listener);
+        };
+    }
+    async sendCall(call) {
+        const from = await this.getAddress();
+        const hash = (await this.provider().request({
+            method: 'eth_sendTransaction',
+            params: [{ from, to: `0x${call.contractHex}`, data: `0x${encodeCallData(call)}` }],
+        }));
+        if (!hash) {
+            throw new Error(`The wallet returned no transaction hash for ${call.functionSignature}.`);
+        }
+        return hash;
+    }
+}
+export class ManagedEvmSigner {
+    sender;
+    chainId;
+    constructor(sender, chainId) {
+        this.sender = sender;
+        this.chainId = chainId;
+    }
+    connect() {
+        return this.sender.getAddress();
+    }
+    getAddress() {
+        return this.sender.getAddress();
+    }
+    async getNetwork() {
+        return this.chainId;
+    }
+    async sendCall(call) {
+        const tx = await this.sender.sendTransaction({ to: `0x${call.contractHex}`, data: `0x${encodeCallData(call)}` });
+        return tx.hash;
+    }
+}

package/lib/families.d.ts

@@ -0,0 +1,4 @@
+import type { ChainFamily } from '@unicitylabs/bridge-core';
+import type { ChainFamilyAdapter } from './family.js';
+export type { ChainFamilyAdapter, RpcOptions } from './family.js';
+export declare function chainFamily(family: ChainFamily): ChainFamilyAdapter;

package/lib/families.js

@@ -0,0 +1,11 @@
+import { evmFamily } from './evm/family.js';
+import { tronFamily } from './tron/family.js';
+export function chainFamily(family) {
+    switch (family) {
+        case 'tron':
+            return tronFamily;
+        case 'eip155':
+            return evmFamily;
+    }
+    throw new Error(`Unsupported chain family: ${String(family)}`);
+}

package/lib/family.d.ts

@@ -0,0 +1,16 @@
+import type { BridgePresentation, ChainFamily } from '@unicitylabs/bridge-core';
+import type { ConstantCaller, SourceChainRpc } from './source-chain.js';
+export interface RpcOptions {
+    readonly rpcUrl?: string;
+    readonly apiKey?: string;
+}
+export interface ChainFamilyAdapter {
+    readonly family: ChainFamily;
+    readonly chainName: string;
+    readonly defaultConfirmations: number;
+    readonly blockSeconds: number;
+    chainRef(chainId: number): string;
+    normalizeAddress(address: string): string;
+    createRpc(options: RpcOptions): SourceChainRpc & ConstantCaller;
+    presentation(chainId: number): BridgePresentation;
+}

package/lib/family.js

@@ -0,0 +1 @@
+export {};

package/lib/hex.d.ts

@@ -0,0 +1,4 @@
+/** Small hex helpers (lowercase, no `0x`). */
+export declare function toHex(bytes: Uint8Array): string;
+export declare function fromHex(hex: string): Uint8Array;
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;

package/lib/hex.js

@@ -0,0 +1,33 @@
+/** Small hex helpers (lowercase, no `0x`). */
+export function toHex(bytes) {
+    let out = '';
+    for (const b of bytes) {
+        out += b.toString(16).padStart(2, '0');
+    }
+    return out;
+}
+export function fromHex(hex) {
+    let h = hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
+    if (h.length % 2 !== 0) {
+        throw new Error(`Invalid hex length: ${hex}`);
+    }
+    const out = new Uint8Array(h.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        const byte = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+        if (Number.isNaN(byte)) {
+            throw new Error(`Invalid hex: ${hex}`);
+        }
+        out[i] = byte;
+    }
+    return out;
+}
+export function bytesEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    let diff = 0;
+    for (let i = 0; i < a.length; i++) {
+        diff |= a[i] ^ b[i];
+    }
+    return diff === 0;
+}

package/lib/identifiers.d.ts

@@ -0,0 +1,14 @@
+import type { ChainFamily } from '@unicitylabs/bridge-core';
+/**
+ * Deterministic 32-byte Unicity TokenType for a bridged asset, from its source
+ * chain family (CAIP-2 namespace), chain id and asset contract:
+ * `SHA256("unicity-bridge:<family>:<chainId>:<assetEvmHex>")` (interop §2).
+ */
+export declare function deriveTokenType(family: ChainFamily, chainId: number, assetContract: string): Uint8Array;
+/** Deterministic 32-byte Sphere coinId for a bridged asset, same inputs as {deriveTokenType}. */
+export declare function deriveCoinId(family: ChainFamily, chainId: number, assetContract: string): Uint8Array;
+/**
+ * Commitment the Tron lock must carry so the bridged token can only be owned by
+ * the intended recipient: `SHA256(recipient.toCBOR())`.
+ */
+export declare function recipientCommitment(recipientCbor: Uint8Array): Uint8Array;

package/lib/identifiers.js

@@ -0,0 +1,22 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+import { toEvmAddressHex } from './address.js';
+const utf8 = (s) => new TextEncoder().encode(s);
+/**
+ * Deterministic 32-byte Unicity TokenType for a bridged asset, from its source
+ * chain family (CAIP-2 namespace), chain id and asset contract:
+ * `SHA256("unicity-bridge:<family>:<chainId>:<assetEvmHex>")` (interop §2).
+ */
+export function deriveTokenType(family, chainId, assetContract) {
+    return sha256(utf8(`unicity-bridge:${family}:${chainId}:${toEvmAddressHex(assetContract)}`));
+}
+/** Deterministic 32-byte Sphere coinId for a bridged asset, same inputs as {deriveTokenType}. */
+export function deriveCoinId(family, chainId, assetContract) {
+    return sha256(utf8(`unicity-bridge-coin:${family}:${chainId}:${toEvmAddressHex(assetContract)}`));
+}
+/**
+ * Commitment the Tron lock must carry so the bridged token can only be owned by
+ * the intended recipient: `SHA256(recipient.toCBOR())`.
+ */
+export function recipientCommitment(recipientCbor) {
+    return sha256(recipientCbor);
+}

package/lib/index.d.ts

@@ -0,0 +1,48 @@
+import { type BridgeAssetConfig } from './config.js';
+import { LockMintJustificationVerifier, type ResolvedBridgeConfig } from './LockMintJustificationVerifier.js';
+import type { SourceChainRpc } from './source-chain.js';
+import type { BridgedAmountExtractor } from './value.js';
+export * from './address.js';
+export * from './bridge-back/index.js';
+export * from './BridgeLockJustification.js';
+export * from './BridgeMintJustificationVerifier.js';
+export * from './config.js';
+export * from './contract-call.js';
+export * from './evm/config.js';
+export * from './evm/EvmRpcClient.js';
+export * from './evm/family.js';
+export * from './families.js';
+export * from './hex.js';
+export * from './identifiers.js';
+export * from './lock-event.js';
+export * from './LockMintJustificationVerifier.js';
+export * from './source-chain.js';
+export * from './tron/config.js';
+export * from './tron/family.js';
+export * from './tron/TronRpcClient.js';
+export * from './value.js';
+export interface CreateBridgePluginDeps {
+    /** Inject a node client (e.g. a mock). If omitted, the family builds one from `config.rpcUrl`. */
+    readonly rpc?: SourceChainRpc;
+    /** Override the token-value extractor. Defaults to the wallet value format (src/value.ts). */
+    readonly extractAmount?: BridgedAmountExtractor;
+}
+/** A ready-to-register bridge plugin for one bridged asset. */
+export interface BridgePlugin {
+    readonly cborTag: bigint;
+    /** 32-byte Unicity TokenType (hex) for this asset. */
+    readonly tokenTypeHex: string;
+    /** 32-byte Sphere coinId (hex) for this asset. */
+    readonly coinIdHex: string;
+    readonly decimals: number;
+    readonly resolvedConfig: ResolvedBridgeConfig;
+    /** Register this into a MintJustificationVerifierService. */
+    readonly verifier: LockMintJustificationVerifier;
+    readonly rpc: SourceChainRpc;
+}
+/**
+ * Build a bridge plugin from canonical config. Derives the asset's
+ * TokenType/coinId, normalizes trust-anchor addresses through the chain
+ * family, and wires the verifier to the family's node client.
+ */
+export declare function createBridgePlugin(config: BridgeAssetConfig, deps?: CreateBridgePluginDeps): BridgePlugin;

package/lib/index.js

@@ -0,0 +1,55 @@
+import { DEFAULT_DECIMALS } from './config.js';
+import { BRIDGE_LOCK_JUSTIFICATION_TAG } from './BridgeLockJustification.js';
+import { chainFamily } from './families.js';
+import { toHex } from './hex.js';
+import { deriveCoinId, deriveTokenType } from './identifiers.js';
+import { LockMintJustificationVerifier } from './LockMintJustificationVerifier.js';
+export * from './address.js';
+export * from './bridge-back/index.js';
+export * from './BridgeLockJustification.js';
+export * from './BridgeMintJustificationVerifier.js';
+export * from './config.js';
+export * from './contract-call.js';
+export * from './evm/config.js';
+export * from './evm/EvmRpcClient.js';
+export * from './evm/family.js';
+export * from './families.js';
+export * from './hex.js';
+export * from './identifiers.js';
+export * from './lock-event.js';
+export * from './LockMintJustificationVerifier.js';
+export * from './source-chain.js';
+export * from './tron/config.js';
+export * from './tron/family.js';
+export * from './tron/TronRpcClient.js';
+export * from './value.js';
+/**
+ * Build a bridge plugin from canonical config. Derives the asset's
+ * TokenType/coinId, normalizes trust-anchor addresses through the chain
+ * family, and wires the verifier to the family's node client.
+ */
+export function createBridgePlugin(config, deps = {}) {
+    const family = chainFamily(config.family);
+    const tokenType = deriveTokenType(config.family, config.chainId, config.assetContract);
+    const coinId = deriveCoinId(config.family, config.chainId, config.assetContract);
+    const resolvedConfig = {
+        family: config.family,
+        chainId: config.chainId,
+        lockContractHex: family.normalizeAddress(config.lockContract),
+        assetContractHex: family.normalizeAddress(config.assetContract),
+        confirmations: config.confirmations ?? family.defaultConfirmations,
+        tokenType,
+        coinId,
+    };
+    const rpc = deps.rpc ?? family.createRpc({ rpcUrl: config.rpcUrl, apiKey: config.apiKey });
+    const verifier = new LockMintJustificationVerifier(resolvedConfig, { rpc, extractAmount: deps.extractAmount });
+    return {
+        cborTag: BRIDGE_LOCK_JUSTIFICATION_TAG,
+        tokenTypeHex: toHex(tokenType),
+        coinIdHex: toHex(coinId),
+        decimals: config.decimals ?? DEFAULT_DECIMALS,
+        resolvedConfig,
+        verifier,
+        rpc,
+    };
+}

package/lib/lock-event.d.ts

@@ -0,0 +1,28 @@
+import type { SourceLog } from './source-chain.js';
+/** Solidity signature of the UnicityLock `Lock` event. */
+export declare const LOCK_EVENT_SIGNATURE = "Lock(uint256,address,uint256,bytes32,bytes32)";
+/** topic0 of the Lock event = keccak256(signature), lowercase hex (no 0x). */
+export declare const LOCK_EVENT_TOPIC0: string;
+/** Decoded fields of a `Lock(nonce, from, amount, unicityTokenId, recipientCommitment)` event. */
+export interface DecodedLockEvent {
+    readonly nonce: bigint;
+    /** 20-byte EVM-form address that called lock(), lowercase hex. */
+    readonly from: string;
+    readonly amount: bigint;
+    /** 32-byte Unicity tokenId the deposit is bound to. */
+    readonly unicityTokenId: Uint8Array;
+    /** 32-byte recipient commitment the deposit is bound to. */
+    readonly recipientCommitment: Uint8Array;
+}
+/**
+ * Decode a Lock event log. Returns null if the log is not a well-formed Lock
+ * event (wrong topic0, wrong arity, or short data) — callers treat that as
+ * "no matching lock event".
+ *
+ * Event layout (indexed nonce, indexed from; non-indexed in data):
+ *   topics[0] = keccak256(signature)
+ *   topics[1] = nonce        (uint256)
+ *   topics[2] = from         (address, left-padded to 32 bytes)
+ *   data      = amount ‖ unicityTokenId ‖ recipientCommitment  (3 × 32 bytes)
+ */
+export declare function decodeLockEvent(log: SourceLog): DecodedLockEvent | null;

package/lib/lock-event.js

@@ -0,0 +1,48 @@
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { fromHex, toHex } from './hex.js';
+/** Solidity signature of the UnicityLock `Lock` event. */
+export const LOCK_EVENT_SIGNATURE = 'Lock(uint256,address,uint256,bytes32,bytes32)';
+const utf8 = (s) => new TextEncoder().encode(s);
+/** topic0 of the Lock event = keccak256(signature), lowercase hex (no 0x). */
+export const LOCK_EVENT_TOPIC0 = toHex(keccak_256(utf8(LOCK_EVENT_SIGNATURE)));
+function strip0x(h) {
+    return h.startsWith('0x') || h.startsWith('0X') ? h.slice(2) : h;
+}
+function wordToBigInt(word) {
+    let v = 0n;
+    for (const b of word) {
+        v = (v << 8n) | BigInt(b);
+    }
+    return v;
+}
+/**
+ * Decode a Lock event log. Returns null if the log is not a well-formed Lock
+ * event (wrong topic0, wrong arity, or short data) — callers treat that as
+ * "no matching lock event".
+ *
+ * Event layout (indexed nonce, indexed from; non-indexed in data):
+ *   topics[0] = keccak256(signature)
+ *   topics[1] = nonce        (uint256)
+ *   topics[2] = from         (address, left-padded to 32 bytes)
+ *   data      = amount ‖ unicityTokenId ‖ recipientCommitment  (3 × 32 bytes)
+ */
+export function decodeLockEvent(log) {
+    const topics = log.topics.map(strip0x).map((t) => t.toLowerCase());
+    if (topics.length !== 3 || topics[0] !== LOCK_EVENT_TOPIC0) {
+        return null;
+    }
+    const data = fromHex(strip0x(log.data));
+    if (data.length < 96) {
+        return null;
+    }
+    const nonce = wordToBigInt(fromHex(topics[1]));
+    // address occupies the low 20 bytes of the 32-byte topic word.
+    const from = topics[2].slice(24);
+    return {
+        nonce,
+        from,
+        amount: wordToBigInt(data.subarray(0, 32)),
+        unicityTokenId: data.subarray(32, 64),
+        recipientCommitment: data.subarray(64, 96),
+    };
+}

package/lib/source-chain.d.ts

@@ -0,0 +1,29 @@
+export interface SourceLog {
+    readonly address: string;
+    /** Indexed topics (topic0 = event signature hash). */
+    readonly topics: string[];
+    /** ABI-encoded non-indexed args. */
+    readonly data: string;
+}
+export interface SourceTxInfo {
+    readonly blockNumber: bigint;
+    readonly success: boolean;
+    readonly logs: SourceLog[];
+}
+export interface ConstantCallInput {
+    readonly ownerHex: string;
+    readonly contractHex: string;
+    /** Solidity function signature, e.g. `allowance(address,address)`. */
+    readonly functionSignature: string;
+    /** ABI-encoded arguments, hex (no `0x`); empty for no-arg calls. */
+    readonly parameterHex?: string;
+}
+export interface SourceChainRpc {
+    /** Returns null when the transaction is unknown to the node. */
+    getTransactionInfo(txidHex: string): Promise<SourceTxInfo | null>;
+    /** Current chain tip block number. */
+    getNowBlockNumber(): Promise<bigint>;
+}
+export interface ConstantCaller {
+    constantCall(input: ConstantCallInput): Promise<string>;
+}

package/lib/source-chain.js

@@ -0,0 +1 @@
+export {};

package/lib/tron/TronRpcClient.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Tron full-node HTTP API client (plain JSON, no tronweb dependency) behind the
+ * family-neutral {SourceChainRpc} and {ConstantCaller}.
+ */
+import type { ConstantCallInput, ConstantCaller, SourceChainRpc, SourceTxInfo } from '../source-chain.js';
+type FetchLike = (input: string, init?: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+}>;
+export interface TronHttpRpcClientOptions {
+    /** Base URL, e.g. https://api.trongrid.io or https://nile.trongrid.io */
+    readonly baseUrl: string;
+    /** TronGrid API key (optional; sent as TRON-PRO-API-KEY). */
+    readonly apiKey?: string;
+    /** Injectable fetch (defaults to globalThis.fetch). */
+    readonly fetchFn?: FetchLike;
+}
+export declare class TronHttpRpcClient implements SourceChainRpc, ConstantCaller {
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly fetchFn;
+    constructor(options: TronHttpRpcClientOptions);
+    private post;
+    getTransactionInfo(txidHex: string): Promise<SourceTxInfo | null>;
+    getNowBlockNumber(): Promise<bigint>;
+    /**
+     * Read-only (constant) contract call — used for `allowance(owner, spender)` so
+     * bridge-in can skip a redundant `approve`. Addresses go over the wire in the
+     * hex `41…` form (visible:false). Throws if the node reports the call reverted
+     * or returns no result word.
+     */
+    constantCall(input: ConstantCallInput): Promise<string>;
+}
+export {};