alkanesjs 1.1.9 → 1.2.1

package/dist/index.d.ts

@@ -0,0 +1,1516 @@
+import * as bitcoin from 'bitcoinjs-lib';
+import { Network, Psbt, Transaction } from 'bitcoinjs-lib';
+import { BorshSchema, Infer } from 'borsher';
+import { z } from 'zod';
+import * as ecpair from 'ecpair';
+import { ECPairInterface } from 'ecpair';
+
+/** Represents just the error shape (status: false) */
+interface IBoxedError<E extends string | number> {
+    status: false;
+    errorType: E;
+    message?: string;
+}
+/** Represents just the success shape (status: true) */
+interface IBoxedSuccess<T> {
+    status: true;
+    data: T;
+}
+/** A union that can be either an error or a success */
+type BoxedResponse<T, E extends string | number> = IBoxedError<E> | IBoxedSuccess<T>;
+/** A class implementing the error shape */
+declare class BoxedError<E extends string | number> implements IBoxedError<E> {
+    status: false;
+    errorType: E;
+    message?: string;
+    constructor(errorType: E, message?: string);
+}
+/** A class implementing the success shape */
+declare class BoxedSuccess<T> implements IBoxedSuccess<T> {
+    status: true;
+    data: T;
+    constructor(data: T);
+}
+
+declare enum EsploraFetchError {
+    UnknownError = "UnknownError"
+}
+type EsploraAddressStats = {
+    funded_txo_count: number;
+    funded_txo_sum: number;
+    spent_txo_count: number;
+    spent_txo_sum: number;
+    tx_count: number;
+};
+interface IEsploraBlockHeader {
+    /** block height you asked for */
+    height: number;
+    /** 32‑byte block‑hash (hex, lowercase, no “0x”) */
+    hash: string;
+    /** 80‑byte raw header, hex‑encoded (160 chars) */
+    headerHex: string;
+}
+type EsploraAddressResponse = {
+    address: string;
+    chain_stats: EsploraAddressStats;
+    mempool_stats: EsploraAddressStats;
+};
+type EsploraUtxo = {
+    txid: string;
+    vout: number;
+    value: number;
+    status: {
+        confirmed: boolean;
+        block_height?: number;
+        block_hash?: string;
+        block_time?: number;
+    };
+};
+type IEsploraTransactionStatus = {
+    confirmed: boolean;
+    block_height?: number;
+    block_hash?: string;
+    block_time?: number;
+};
+type IEsploraPrevout = {
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_type: string;
+    scriptpubkey_address: string;
+    value: number;
+};
+type IEsploraVin = {
+    txid: string;
+    vout: number;
+    prevout?: IEsploraPrevout;
+    scriptsig: string;
+    scriptsig_asm: string;
+    witness: string[];
+    is_coinbase: boolean;
+    sequence: number;
+};
+type IEsploraVout = {
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_type: string;
+    scriptpubkey_address: string;
+    value: number;
+};
+type IEsploraTransaction = {
+    txid: string;
+    version: number;
+    locktime: number;
+    vin: IEsploraVin[];
+    vout: IEsploraVout[];
+    size: number;
+    weight: number;
+    fee: number;
+    status: IEsploraTransactionStatus;
+};
+type IEsploraSpendableUtxo = {
+    txid: string;
+    vout: number;
+    value: number;
+    prevTx: IEsploraTransaction & {
+        hex: string;
+    };
+};
+
+declare enum RpcError {
+    UnknownError = "UnknownError",
+    InternalError = "InternalError"
+}
+type RpcTuple = [string, unknown[]];
+type RpcResponse<T> = {
+    jsonrpc: "2.0";
+    id: number;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+interface RpcCall<T> {
+    payload: RpcTuple;
+    call: () => Promise<BoxedResponse<T, RpcError>>;
+}
+declare function buildRpcCall<T, E = unknown>(method: string, params: unknown[] | undefined, url: string): RpcCall<T>;
+
+declare class WaitPacer {
+    private maxPerInterval;
+    private intervalMs;
+    private minGapMs;
+    private starts;
+    private lastStart;
+    private tail;
+    constructor(opts: {
+        maxPerInterval: number;
+        intervalMs: number;
+    });
+    setRate(maxPerInterval: number, intervalMs: number): void;
+    private now;
+    private sleep;
+    private pruneWindow;
+    /** Await this immediately before the call that could rate-limit */
+    waitForPacer(): Promise<void>;
+}
+
+interface ProviderConfig {
+    sandshrewUrl: string;
+    electrumApiUrl: string;
+    network: Network;
+    explorerUrl: string;
+    defaultFeeRate?: number;
+    btcTicker?: string;
+    pacerSettings?: PacerSettings;
+}
+declare enum AlkanesPollError {
+    UnknownError = "UnknownError"
+}
+type PacerSettings = {
+    intervalMs: number;
+    maxPerInterval: number;
+};
+type AlkanesParsedTraceResult = {
+    create?: AlkanesTraceCreateEvent["data"];
+    invoke?: AlkanesTraceInvokeEvent["data"];
+    return: AlkanesTraceReturnEvent["data"];
+};
+declare class Provider {
+    readonly sandshrewUrl: string;
+    readonly electrumApiUrl: string;
+    readonly network: Network;
+    readonly explorerUrl: string;
+    readonly pacerSettings: PacerSettings;
+    readonly btcTicker: string;
+    readonly jitterMs = 1000;
+    readonly rpc: BaseRpcProvider;
+    readonly defaultFeeRate: number;
+    private readonly TIMEOUT_MS;
+    private readonly INTERVAL_MS;
+    pacer: WaitPacer;
+    constructor(config: ProviderConfig);
+    protected txUrl(txid: string): string;
+    protected addressUrl(address: string): string;
+    buildRpcCall<T>(method: string, params?: unknown[]): RpcCall<T>;
+    execute(config: Omit<Parameters<typeof execute>[0], "provider">): ReturnType<typeof execute>;
+    simulate(request: Parameters<typeof simulate>[1]): ReturnType<typeof simulate>;
+    trace(...args: Parameters<typeof AlkanesRpcProvider.prototype.alkanes_trace>): ReturnType<ReturnType<typeof AlkanesRpcProvider.prototype.alkanes_trace>["call"]>;
+    waitForBlocks: (amount: number) => Promise<BoxedResponse<boolean, AlkanesPollError>>;
+    waitForTraceResult: (txid: string) => Promise<BoxedResponse<AlkanesParsedTraceResult, AlkanesTraceError>>;
+    waitForConfirmation: (txid: string) => Promise<BoxedResponse<boolean, AlkanesPollError>>;
+}
+
+declare class ElectrumApiProvider {
+    private readonly provider;
+    constructor(provider: Provider);
+    private get electrumApiUrl();
+    esplora_getaddress(address: string): Promise<BoxedResponse<EsploraAddressResponse, EsploraFetchError>>;
+    esplora_getaddressbalance(address: string): Promise<BoxedResponse<number, EsploraFetchError>>;
+    esplora_getutxos(address: string): Promise<BoxedResponse<EsploraUtxo[], EsploraFetchError>>;
+    esplora_getfee(): Promise<BoxedResponse<number, EsploraFetchError>>;
+    esplora_broadcastTx(rawTransactionHex: string, customElectrumUrl?: string): Promise<BoxedResponse<string, EsploraFetchError>>;
+    esplora_getaddresstxs(address: string, lastSeenTransactionId?: string): Promise<BoxedResponse<IEsploraTransaction[], EsploraFetchError>>;
+    esplora_getbulktransactions(transactionIds: string[]): Promise<BoxedResponse<IEsploraTransaction[], EsploraFetchError>>;
+    esplora_getblocktiphash(): Promise<BoxedResponse<string, EsploraFetchError>>;
+    _esplora_getrawblock(blockHash: string): Promise<BoxedResponse<string, EsploraFetchError>>;
+    esplora_getrawblocktip(): Promise<BoxedResponse<string, EsploraFetchError>>;
+    esplora_gettransaction(transactionId: string): Promise<BoxedResponse<IEsploraTransaction, EsploraFetchError>>;
+    esplora_getrawtransaction(transactionId: string): Promise<BoxedResponse<string, EsploraFetchError>>;
+    esplora_getspendableinputs(utxoList: EsploraUtxo[]): Promise<BoxedResponse<IEsploraSpendableUtxo[], EsploraFetchError>>;
+    esplora_getutxofromparenttx(transaction: IEsploraTransaction, voutIndex: number): BoxedResponse<EsploraUtxo, EsploraFetchError>;
+    esplora_getutxo(utxoString: string): Promise<BoxedResponse<EsploraUtxo, EsploraFetchError>>;
+}
+
+type RuneName = string;
+interface OrdPaginatedIds {
+    ids: string[];
+    more: boolean;
+    page?: number;
+    page_index?: number;
+}
+interface OrdInscription {
+    address: string;
+    children: string[];
+    content_length: number;
+    content_type: string;
+    genesis_fee: number;
+    genesis_height: number;
+    inscription_id: string;
+    inscription_number: number;
+    next: string | null;
+    output_value: number;
+    parent: string | null;
+    previous: string | null;
+    rune: string | null;
+    sat: number;
+    satpoint: string;
+    timestamp: number;
+}
+type OrdOutputRune = {
+    amount: number;
+    divisibility: number;
+};
+interface OrdOutput {
+    value: number;
+    script_pubkey: string;
+    address: string;
+    transaction: string;
+    sat_ranges: number[][];
+    inscriptions: string[];
+    runes: Record<RuneName, OrdOutputRune>;
+    indexed?: boolean;
+    spent?: boolean;
+    output?: string;
+}
+interface OrdBlock {
+    hash: string;
+    target: string;
+    best_height: number;
+    height: number;
+    inscriptions: string[];
+}
+interface OrdSat {
+    number: number;
+    decimal: string;
+    degree: string;
+    name: string;
+    block: number;
+    cycle: number;
+    epoch: number;
+    period: number;
+    offset: number;
+    rarity: string;
+    percentile: string;
+    satpoint: string | null;
+    timestamp: number;
+    inscriptions: string[];
+}
+type DecodedCBORValue = string | number | boolean | null | undefined | DecodedCBOR | DecodedCBORValue[];
+interface DecodedCBOR {
+    [key: string]: DecodedCBORValue;
+}
+
+declare function decodeCBOR(hex: string): DecodedCBOR;
+
+declare enum OrdFetchError {
+    UnknownError = "UnknownError",
+    RpcError = "RpcError"
+}
+declare class OrdRpcProvider {
+    private readonly provider;
+    constructor(provider: Provider);
+    private get rpc();
+    ord_getInscriptions(startingNumber?: string): RpcCall<OrdPaginatedIds>;
+    ord_getInscriptionsByBlockHash(blockHash: string): RpcCall<OrdBlock>;
+    ord_getInscriptionsByBlockHeight(blockHeight: string, page?: string): RpcCall<OrdBlock>;
+    ord_getInscriptionById(inscriptionId: string): RpcCall<OrdInscription>;
+    ord_getInscriptionByNumber(inscriptionNumber: string): RpcCall<OrdInscription>;
+    ord_getInscriptionContent(inscriptionId: string): RpcCall<string>;
+    ord_getInscriptionPreview(inscriptionId: string): RpcCall<string>;
+    ord_getInscriptionChildren(inscriptionId: string, page?: string): RpcCall<OrdPaginatedIds>;
+    ord_getTxOutput(txidAndVout: string): RpcCall<OrdOutput>;
+    ord_getSatByNumber(satoshiNumber: string): RpcCall<OrdSat>;
+    ord_getSatByDecimal(decimalNotation: string): RpcCall<OrdSat>;
+    ord_getSatByDegree(degreeNotation: string): RpcCall<OrdSat>;
+    ord_getSatByName(satoshiName: string): RpcCall<OrdSat>;
+    ord_getSatByPercentile(percentileString: string): RpcCall<OrdSat>;
+    ord_getInscriptionIdsBySat(satoshiNumber: string, page?: string): RpcCall<OrdPaginatedIds>;
+    ord_getInscriptionIdBySatAt(satoshiNumber: string, index?: string): RpcCall<{
+        id: string;
+    }>;
+    ord_getRuneByName(runeName: string): RpcCall<unknown>;
+    ord_getRuneById(runeId: string): RpcCall<unknown>;
+    ord_getRunes(): RpcCall<unknown>;
+    ord_getAddressData(address: string): RpcCall<unknown>;
+    ord_getInscriptionMetadata(inscriptionId: string): Promise<BoxedResponse<unknown, string>>;
+}
+
+interface EncodedAlkaneId {
+    block: string;
+    tx: string;
+}
+type AlkaneEncoded = {
+    value: string;
+} & EncodedAlkaneId;
+type AlkaneId = {
+    block: bigint;
+    tx: bigint;
+};
+type Alkane = {
+    value: bigint;
+} & AlkaneId;
+interface AlkaneRune {
+    rune: {
+        id: EncodedAlkaneId;
+        name: string;
+        spacedName: string;
+        divisibility: number;
+        spacers: number;
+        symbol: string;
+    };
+    balance: string;
+}
+interface ProtoRunesToken {
+    id: EncodedAlkaneId;
+    name: string;
+    symbol: string;
+}
+type AlkaneReadableId = string;
+type AlkanesUtxoEntry = {
+    value: string;
+    name: string;
+    symbol: string;
+    id: string;
+};
+type AlkanesOutpoint = {
+    token: {
+        id: {
+            block: string;
+            tx: string;
+        };
+        name: string;
+        symbol: string;
+    };
+    value: string;
+};
+type AlkanesOutpointExtended = AlkanesOutpoint & {
+    outpoint: string;
+};
+type AlkanesOutpoints = AlkanesOutpoint[];
+type AlkanesOutpointsExtended = AlkanesOutpointExtended[];
+type AlkanesByAddressResponse = {
+    outpoints: AlkanesByAddressOutpoint[];
+};
+type AlkanesByAddressOutpoint = {
+    runes: AlkanesByAddressRuneBalance[];
+    outpoint: {
+        txid: string;
+        vout: number;
+    };
+    output: {
+        value: number;
+        script: string;
+    };
+    height: number;
+    txindex: number;
+};
+type AlkanesByAddressRuneBalance = {
+    rune: {
+        id: {
+            block: string;
+            tx: string;
+        };
+        name: string;
+        spacedName: string;
+        divisibility: number;
+        spacers: number;
+        symbol: string;
+    };
+    balance: string;
+};
+interface AlkaneSimulateRequest {
+    alkanes?: any[];
+    transaction?: string;
+    height?: string;
+    txindex?: number;
+    target: AlkaneId;
+    callData: bigint[];
+    pointer?: number;
+    refundPointer?: number;
+    vout?: number;
+}
+type AlkaneEncodedSimulationRequest = {
+    alkanes: any[];
+    transaction: string;
+    block: string;
+    height: string;
+    txindex: number;
+    target: EncodedAlkaneId;
+    inputs: string[];
+    pointer: number;
+    refundPointer: number;
+    vout: number;
+};
+interface AlkaneToken {
+    name: string;
+    symbol: string;
+    totalSupply: number;
+    cap: number;
+    minted: number;
+    mintActive: boolean;
+    percentageMinted: number;
+    mintAmount: number;
+}
+interface AlkanesParsedSimulationResult {
+    string: string;
+    bytes: string;
+    le: string;
+    be: string;
+}
+interface AlkanesRawSimulationResponse {
+    status: number;
+    gasUsed: number;
+    execution: {
+        alkanes: unknown[];
+        storage: unknown[];
+        data: string;
+        error?: string;
+    };
+    parsed: unknown;
+}
+type AlkanesSimulationResult = {
+    raw: AlkanesRawSimulationResponse;
+    parsed: AlkanesParsedSimulationResult | undefined;
+};
+interface AlkanesTraceEncodedCreateEvent {
+    event: "create";
+    data: EncodedAlkaneId;
+}
+interface AlkanesTraceEncodedInvokeEvent {
+    event: "invoke";
+    data: {
+        type: "call";
+        context: {
+            myself: EncodedAlkaneId;
+            caller: EncodedAlkaneId;
+            inputs: string[];
+            incomingAlkanes: AlkaneEncoded[];
+            vout: number;
+        };
+        fuel: number;
+    };
+}
+interface AlkanesTraceEncodedReturnEvent {
+    event: "return";
+    data: {
+        status: "success";
+        response: {
+            alkanes: AlkaneEncoded[];
+            data: string;
+            storage: {
+                key: string;
+                value: string;
+            }[];
+        };
+    };
+}
+type AlkanesTraceEncodedEvent = AlkanesTraceEncodedCreateEvent | AlkanesTraceEncodedInvokeEvent | AlkanesTraceEncodedReturnEvent;
+type AlkanesTraceEncodedResult = AlkanesTraceEncodedEvent[];
+interface AlkanesTraceCreateEvent {
+    event: "create";
+    data: AlkaneId;
+}
+interface AlkanesTraceInvokeEvent {
+    event: "invoke";
+    data: {
+        type: "call";
+        context: {
+            myself: AlkaneId;
+            caller: AlkaneId;
+            inputs: bigint[];
+            incomingAlkanes: Alkane[];
+            vout: number;
+        };
+        fuel: number;
+    };
+}
+interface AlkanesTraceReturnEvent {
+    event: "return";
+    data: {
+        status: "success" | "revert";
+        response: {
+            alkanes: Alkane[];
+            data: string;
+            storage: {
+                key: string;
+                value: bigint;
+            }[];
+        };
+    };
+}
+type AlkanesTraceEvent = AlkanesTraceCreateEvent | AlkanesTraceInvokeEvent | AlkanesTraceReturnEvent;
+type AlkanesTraceResult = AlkanesTraceEvent[];
+
+type FormattedUtxo = {
+    txId: string;
+    outputIndex: number;
+    satoshis: number;
+    scriptPk: string;
+    address: string;
+    inscriptions: string[];
+    runes: Record<RuneName, OrdOutputRune>;
+    alkanes: Record<AlkaneReadableId, AlkanesUtxoEntry>;
+    confirmations: number;
+    indexed: boolean;
+    prevTx: IEsploraTransaction;
+    prevTxHex: string;
+};
+
+declare enum SandshrewFetchError {
+    UnknownError = "UnknownError",
+    InternalError = "InternalError"
+}
+declare class SandshrewRpcProvider {
+    private readonly provider;
+    private readonly electrumApiProvider;
+    private readonly ordRpcProvider;
+    private readonly alkanesRpcProvider;
+    constructor(provider: Provider, electrumApiProvider: ElectrumApiProvider, ordRpcProvider: OrdRpcProvider, alkanesRpcProvider: AlkanesRpcProvider);
+    sandshrew_multcall<T>(rpcCalls: RpcCall<T>[]): Promise<BoxedResponse<T[], SandshrewFetchError>>;
+    sandshrew_getFormattedUtxosForAddress(address: string): Promise<BoxedResponse<FormattedUtxo[], SandshrewFetchError>>;
+}
+
+interface Rune {
+    id: string;
+    name: string;
+    spacedName: string;
+    divisibility: number;
+    spacers: number;
+    symbol: string;
+}
+interface RuneBalance {
+    rune: Rune;
+    balance: string;
+}
+interface RunesOutpoint {
+    runes: RuneBalance[];
+    outpoint: {
+        txid: string;
+        vout: number;
+    };
+    output: {
+        value: string;
+        script: string;
+    };
+    height: number;
+    txindex: number;
+}
+interface RunesAddressResult {
+    outpoints: RunesOutpoint[];
+    balanceSheet: RuneBalance[];
+}
+type RunesOutpointResult = RunesOutpoint;
+
+declare enum RunesFetchError {
+    UnknownError = "UnknownError",
+    RpcError = "RpcError"
+}
+declare class RunesRpcProvider {
+    private readonly provider;
+    constructor(provider: Provider);
+    private get rpc();
+    runes_getAddress(address: string, blockHeight?: string): RpcCall<RunesAddressResult>;
+    runes_getOutpoint(txidAndVout: string, blockHeight?: string): RpcCall<RunesOutpoint>;
+}
+
+declare class BaseRpcProvider {
+    readonly electrum: ElectrumApiProvider;
+    readonly ord: OrdRpcProvider;
+    readonly alkanes: AlkanesRpcProvider;
+    readonly sandshrew: SandshrewRpcProvider;
+    readonly runes: RunesRpcProvider;
+    constructor(coreProvider: Provider);
+}
+
+declare const stripHex: (s: string) => string;
+declare function toU64LittleEndianHex(numStr: string): string;
+declare function makeFakeBlock(height: number | bigint): string;
+declare function toU64BigEndianHex(numStr: string): string;
+declare function toU128LittleEndianHex(numStr: string): string;
+declare function mapToPrimitives(v: any): any;
+declare function unmapFromPrimitives(v: any): any;
+declare function parseSimulateReturn(v: string): AlkanesParsedSimulationResult | undefined;
+declare function decodeAlkanesTrace(encoded: AlkanesTraceEncodedResult): AlkanesTraceResult;
+declare function extractAbiErrorMessage(data: string): string | null;
+
+declare enum AlkanesFetchError {
+    UnknownError = "UnknownError",
+    RpcError = "RpcError"
+}
+declare enum AlkanesTraceError {
+    DecodeError = "DecodeError",
+    NoTraceFound = "NoTraceFound",
+    TransactionReverted = "TransactionReverted"
+}
+declare class AlkanesRpcProvider {
+    private readonly provider;
+    constructor(provider: Provider);
+    private get rpc();
+    alkanes_metashrewHeight(): RpcCall<string>;
+    alkanes_getAlkanesByAddress(address: string, protocolTag?: string, runeName?: string): Promise<BoxedResponse<AlkanesByAddressResponse, string>>;
+    alkanes_getAlkanesByHeight(height: number, protocolTag?: string): void;
+    alkanes_getAlkanesByOutpoint(txid: string, vout: number, protocolTag?: string, height?: string): RpcCall<AlkanesOutpoints[]>;
+    alkanes_trace(txid: string, vout: number): {
+        payload: (string | {
+            txid: string;
+            vout: number;
+        }[])[];
+        call: () => Promise<BoxedResponse<AlkanesTraceResult, AlkanesTraceError>>;
+    };
+    alkanes_getAlkaneById(id: AlkaneId): RpcCall<unknown>;
+    alkanes_simulate(req: AlkaneSimulateRequest): Promise<BoxedResponse<AlkanesSimulationResult, string>>;
+}
+
+/**
+ * Schema that accepts any bigint in the closed interval
+ * [0, 2^128 - 1].  Throws a ZodError otherwise.
+ */
+declare const u128Schema: z.ZodEffects<z.ZodBigInt, bigint, bigint>;
+declare const schemaAlkaneId: BorshSchema<{
+    block: number;
+    tx: bigint;
+}>;
+type ISchemaAlkaneId = Infer<typeof schemaAlkaneId>;
+
+declare const sleep: (ms: number) => Promise<unknown>;
+declare function hexToUint8Array(hex: string): Uint8Array;
+declare function excludeFields<K, T extends object>(obj: T, fields: (keyof T)[]): K;
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+declare class ParsableAlkaneId {
+    readonly alkaneId: AlkaneId | ISchemaAlkaneId;
+    constructor(alkaneId: AlkaneId | ISchemaAlkaneId);
+    toSchemaAlkaneId(): ISchemaAlkaneId;
+    toAlkaneId(): AlkaneId;
+}
+declare function reverseHexBytes(hex: string): string;
+
+type PsbtInputExtended = Expand<Parameters<Psbt["addInput"]>[0]>;
+type IFeeOpts = {
+    vsize: number;
+    input_length: number;
+};
+declare class AlkanesInscription<T> {
+    readonly shape: T;
+    readonly borshSchema: BorshSchema<T>;
+    constructor(shape: T, borshSchema: BorshSchema<T>);
+}
+declare class ProtostoneTransactionWithInscription<T> {
+    private readonly changeAddress;
+    private readonly inscription;
+    private readonly opts;
+    private commitBuilder;
+    private revealBuilder;
+    private script;
+    private commitPsbt?;
+    private tweakedDummySigner;
+    private tweakedPublicKey;
+    private revealPsbt?;
+    private inscriptionBytes;
+    private baseSigner;
+    private signedCommitTx;
+    private signedCommitEsploraTx;
+    private baseFeeRate;
+    private utxoTweak;
+    constructor(changeAddress: string, inscription: AlkanesInscription<T>, opts: ProtostoneTransactionOptions);
+    buildCommit(): Promise<Psbt>;
+    finalizeCommit(txHex: string): void;
+    buildReveal(): Promise<Psbt>;
+    extractPsbts(): [string, string];
+    private taprootAddress;
+}
+declare class ProtostoneTransaction {
+    private readonly addressProvided;
+    private readonly options;
+    private MINIMUM_FEE;
+    private MINIMUM_PROTOCOL_DUST;
+    private availableUtxos;
+    private utxos;
+    private psbt;
+    fee: number;
+    private transactionOptions;
+    private changeAddress;
+    private cumulativeSpendRequirementBtc;
+    private cumulativeSpendRequirementAlkanes;
+    private cumulativeValueInPsbts;
+    constructor(addressProvided: string, options: ProtostoneTransactionOptions);
+    private get sandshrew_getFormattedUtxosForAddress();
+    private get esplora_getfee();
+    private addInputDynamic;
+    private fetchResources;
+    private calculateFee;
+    private calcCumulativeSpendRequirements;
+    private mappableAlkaneId;
+    private isUnlockedUtxo;
+    private getAlkanesUtxosToMeetAlkanesRequirement;
+    private getEsploraUtxosToMeetAllRequirements;
+    private fetchUtxos;
+    private initialize;
+    private getBtcOutputs;
+    private addOutputs;
+    private addInputs;
+    private createEdicts;
+    private addProtostoneData;
+    private appendSinglePsbtToTx;
+    private appendPsbtsToTx;
+    build(): Promise<[number, Buffer | undefined]>;
+    finalizeWithDry(): Promise<Transaction>;
+    extractPsbtBase64(): string;
+    getPsbt(): Psbt;
+}
+type SingularBTCTransfer = {
+    asset: "btc";
+    amount: number;
+    address: string;
+    ignorePush?: boolean;
+};
+type SingularAlkanesTransfer = {
+    asset: AlkaneId;
+    amount: bigint;
+    address: string;
+};
+type SingularTransfer = SingularBTCTransfer | SingularAlkanesTransfer;
+type ProtostoneTransactionOptions = (typeof ProtostoneTransaction)["prototype"]["transactionOptions"];
+type IProtostoneTransactionDryRunResponse = {
+    dummyTx: Transaction;
+    dummyInputLength: number;
+    useMaraPool: boolean;
+    feeOpts: IFeeOpts;
+};
+declare function getDummyProtostoneTransaction(addressProvided: string, options: ProtostoneTransactionOptions): Promise<BoxedResponse<IProtostoneTransactionDryRunResponse, string>>;
+declare function getProtostoneUnsignedPsbtBase64(addressProvided: string, options: Omit<ProtostoneTransactionOptions, "psbtTransfers">): Promise<BoxedResponse<{
+    fee: number;
+    psbtBase64: string;
+    vsize: number;
+    useMaraPool: boolean;
+}, string>>;
+declare function getProtostoneTransactionsWithInscription<T>(addressProvided: string, inscription: AlkanesInscription<T>, signPsbt: (unisignedPsbtBase64: string) => Promise<string>, options: Omit<ProtostoneTransactionOptions, "psbtTransfers">): Promise<BoxedResponse<[string, string], string>>;
+
+declare enum AddressType {
+    P2PKH = 0,
+    P2TR = 1,
+    P2SH_P2WPKH = 2,
+    P2WPKH = 3
+}
+type Account = {
+    taproot: {
+        pubkey: string;
+        pubKeyXOnly: string;
+        address: string;
+        hdPath: string;
+    };
+    nativeSegwit: {
+        pubkey: string;
+        address: string;
+        hdPath: string;
+    };
+    nestedSegwit: {
+        pubkey: string;
+        address: string;
+        hdPath: string;
+    };
+    legacy: {
+        pubkey: string;
+        address: string;
+        hdPath: string;
+    };
+    spendStrategy: SpendStrategy;
+    network: bitcoin.Network;
+};
+type AddressKey = "nativeSegwit" | "taproot" | "nestedSegwit" | "legacy";
+type WalletStandard = "bip44_account_last" | "bip44_standard" | "bip32_simple";
+type HDPaths = {
+    legacy?: string;
+    nestedSegwit?: string;
+    nativeSegwit?: string;
+    taproot?: string;
+};
+interface SpendStrategy {
+    addressOrder: AddressKey[];
+    utxoSortGreatestToLeast: boolean;
+    changeAddress: AddressKey;
+}
+type AlkanesUtxo = {
+    id: string;
+    value_sats: string;
+    block: number;
+    vout_index: number;
+    transaction: string | null;
+};
+type AlkaneDetails = {
+    id: {
+        block: bigint;
+        tx: bigint;
+    };
+    name: string;
+    spacedName: string;
+    divisibility: number;
+    spacers: number;
+    symbol: string;
+};
+interface AlkanesUtxoBalance {
+    balance: bigint;
+    utxo: AlkanesUtxo;
+    alkane: AlkaneDetails;
+}
+
+declare const EcPair: ecpair.ECPairAPI;
+type BasePsbtParams = {
+    feeRate?: number;
+    fee?: number;
+};
+declare const addressFormats: {
+    readonly mainnet: {
+        readonly p2pkh: RegExp;
+        readonly p2sh: RegExp;
+        readonly p2wpkh: RegExp;
+        readonly p2wsh: RegExp;
+        readonly p2tr: RegExp;
+    };
+    readonly testnet: {
+        readonly p2pkh: RegExp;
+        readonly p2sh: RegExp;
+        readonly p2wpkh: RegExp;
+        readonly p2wsh: RegExp;
+        readonly p2tr: RegExp;
+    };
+    readonly signet: {
+        readonly p2pkh: RegExp;
+        readonly p2sh: RegExp;
+        readonly p2wpkh: RegExp;
+        readonly p2wsh: RegExp;
+        readonly p2tr: RegExp;
+    };
+    readonly regtest: {
+        readonly p2pkh: RegExp;
+        readonly p2sh: RegExp;
+        readonly p2wpkh: RegExp;
+        readonly p2wsh: RegExp;
+        readonly p2tr: RegExp;
+    };
+};
+declare const addressTypeToName: {
+    readonly p2pkh: "legacy";
+    readonly p2sh: "nested-segwit";
+    readonly p2wsh: "native-segwit";
+    readonly p2wpkh: "segwit";
+    readonly p2tr: "taproot";
+};
+declare const addressNameToType: {
+    readonly legacy: "p2pkh";
+    readonly segwit: "p2wpkh";
+    readonly "nested-segwit": "p2sh";
+    readonly "native-segwit": "p2wsh";
+    readonly taproot: "p2tr";
+};
+declare function getAddressType(address: string): AddressType | null;
+declare function redeemTypeFromOutput(script: Buffer, network: bitcoin.Network): AddressType | null;
+declare function addInputDynamic(psbt: bitcoin.Psbt, network: bitcoin.Network, utxo: FormattedUtxo): void;
+declare const psbtBuilder: <T extends BasePsbtParams>(provider: Provider, psbtBuilder: (params: T) => Promise<{
+    psbtBase64: string;
+    fee?: number;
+}>, params: T) => Promise<{
+    psbtBase64: string;
+    fee: number;
+    vsize: number;
+}>;
+declare const getEstimatedFee: ({ provider, feeRate, psbtBase64, }: {
+    provider: Provider;
+    feeRate: number;
+    psbtBase64: string;
+}) => Promise<{
+    fee: number;
+    vsize: number;
+}>;
+declare function calculateTaprootTxSize(taprootInputCount: number, nonTaprootInputCount: number, outputCount: number): number;
+declare const minimumFee: ({ taprootInputCount, nonTaprootInputCount, outputCount, }: {
+    taprootInputCount: number;
+    nonTaprootInputCount: number;
+    outputCount: number;
+}) => number;
+declare function trimUndefined<T extends object>(obj: T): T;
+declare function extractWithDummySigs(psbt: bitcoin.Psbt): bitcoin.Transaction;
+declare function toEsploraTx(tx: bitcoin.Transaction, status?: IEsploraTransactionStatus, network?: bitcoin.Network): IEsploraTransaction;
+declare function witnessStackToScriptWitness(stack: Buffer[]): Buffer;
+declare function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer;
+declare const assertHex: (pubKey: Buffer) => Buffer<ArrayBufferLike>;
+declare function tweakSigner(signer: ECPairInterface, opts: {
+    network: bitcoin.Network;
+    tweakHash?: Buffer;
+}): bitcoin.Signer;
+declare const getVSize: (data: Buffer) => number;
+declare const formatInputsToSign: ({ _psbt, senderPublicKey, network, }: {
+    _psbt: bitcoin.Psbt;
+    senderPublicKey: string;
+    network: bitcoin.Network;
+}) => bitcoin.Psbt;
+declare const toFormattedUtxo: (esploraTx: IEsploraTransaction, hex: string, address: string, vout: number) => FormattedUtxo;
+
+declare enum AlkanesExecuteError {
+    UnknownError = "UnknownError",
+    InvalidParams = "InvalidParams"
+}
+interface AlkanesExecuteResponse {
+    psbt: string;
+    fee: number;
+    vsize: number;
+}
+declare const simulate: (provider: Provider, params: AlkaneSimulateRequest) => Promise<BoxedResponse<AlkanesSimulationResult, string>>;
+declare const execute: ({ provider, address, callData, feeRate, transfers, inscription, signPsbt, }: {
+    provider: Provider;
+    address: string;
+    callData: bigint[];
+    signPsbt: (unsignedPsbtBase64: string) => Promise<string>;
+    feeRate?: number;
+    transfers?: SingularTransfer[];
+    inscription?: AlkanesInscription<unknown>;
+}) => Promise<BoxedResponse<string[], AlkanesExecuteError>>;
+
+interface DecoderFns<Obj> {
+    string: (bytes: Uint8Array) => string;
+    boolean: (bytes: Uint8Array) => boolean;
+    bigint: (bytes: Uint8Array) => bigint;
+    hex: (bytes: Uint8Array) => string;
+    uint8Array: (bytes: Uint8Array) => Uint8Array;
+    bigintArray: (bytes: Uint8Array) => bigint[];
+    tokenValue: (bytes: Uint8Array) => number;
+    object: (bytes: Uint8Array) => Obj;
+}
+/** all legal strings accepted by `decodeTo` */
+type AvailableDecodeKind = keyof DecoderFns<unknown>;
+declare class DecodableAlkanesResponse<T = unknown> {
+    readonly bytes: Uint8Array;
+    private readonly borshSchema?;
+    constructor(payload: Uint8Array | bigint | AlkanesSimulationResult | AlkanesTraceReturnEvent["data"], schema?: BorshSchema<T>);
+    private decoderTable;
+    decodeTo<K extends AvailableDecodeKind>(kind: K): ReturnType<DecoderFns<T>[K]>;
+}
+type IDecodableAlkanesResponse<T> = DecodableAlkanesResponse<T>;
+declare enum DecodeError {
+    UnknownError = "UnknownError"
+}
+
+declare enum EncodeError {
+    InvalidPayload = "Invalid payload type",
+    NameTooLong = "Name payload exceeds 2 \u00D7 u128",
+    CharTooLong = "Char payload exceeds 1 \u00D7 u128",
+    BorshMissing = "Borsh schema is required for object serialization"
+}
+interface EncoderFns<Obj> {
+    string: (data: unknown) => BoxedResponse<bigint[], EncodeError>;
+    name: (data: unknown) => BoxedResponse<bigint[], EncodeError>;
+    bigint: (data: unknown) => BoxedResponse<bigint[], EncodeError>;
+    char: (data: unknown) => BoxedResponse<bigint[], EncodeError>;
+    object: (data: unknown, schema?: BorshSchema<Obj>) => BoxedResponse<bigint[], EncodeError>;
+}
+type AvailableEncodeKind = keyof EncoderFns<unknown>;
+declare class Encodable<T = unknown> {
+    readonly payload: unknown;
+    private readonly borshSchema?;
+    constructor(payload: unknown, borshSchema?: BorshSchema<T> | undefined);
+    private encoderTable;
+    encodeFrom<K extends AvailableEncodeKind>(kind: K): BoxedResponse<bigint[], EncodeError>;
+}
+type IEncodable<T> = Expand<Encodable<T>>;
+
+declare const VOID_ENC: "__void";
+type VoidEnc = typeof VOID_ENC;
+type ProtostoneTransactionOptionsPartial = Partial<ProtostoneTransactionOptions>;
+/** Encode‑kind augmented with a sentinel for “no args”. */
+type Enc = AvailableEncodeKind | VoidEnc;
+type Dec = Exclude<AvailableDecodeKind, "object"> | BorshSchema<any> | ArraySchema<any> | ObjectSchema<any>;
+interface ArraySchema<E extends Schema> {
+    kind: "array";
+    element: E;
+}
+interface ObjectSchema<F extends Record<string, Schema>> {
+    kind: "object";
+    fields: F;
+}
+type Schema = Enc | BorshSchema<any> | ArraySchema<any> | ObjectSchema<any>;
+type ResolveSchema<S> = S extends VoidEnc ? never : S extends "string" ? string : S extends "number" ? number : S extends "bigint" ? bigint : S extends "boolean" ? boolean : S extends BorshSchema<infer _Any> ? Infer<S> : S extends BorshSchema<any> ? Infer<S> : S extends ArraySchema<infer E> ? ResolveSchema<E>[] : S extends ObjectSchema<infer F> ? {
+    [K in keyof F]: ResolveSchema<F[K]>;
+} : never;
+declare const VIEW_TAG: unique symbol;
+declare const EXEC_TAG: unique symbol;
+declare const CUSTOM_TAG: unique symbol;
+interface ViewSpec<I extends Schema = Schema, O extends Dec = Dec> {
+    _t: typeof VIEW_TAG;
+    opcode: bigint;
+    input: I;
+    output: O;
+    impl?: (this: AlkanesBaseContract, arg: ResolveSchema<I>) => any;
+}
+/** inscription (K) is either a BorshSchema or the sentinel */
+interface ExecuteSpec<I extends Schema = Schema, K extends BorshSchema<any> | VoidEnc = VoidEnc, O extends Dec = Dec> {
+    _t: typeof EXEC_TAG;
+    opcode: bigint;
+    input: I;
+    output: O;
+    inscription: K;
+    impl?: (this: AlkanesBaseContract, address: string, arg: ResolveSchema<I>, argInscription: ResolveSchema<K>, txOpts?: ProtostoneTransactionOptionsPartial) => any;
+}
+type CustomImpl<P> = (this: AlkanesBaseContract, opcode: bigint, params: P) => any;
+interface CustomSpec<I, O, Impl extends CustomImpl<I>> {
+    _t: typeof CUSTOM_TAG;
+    opcode: bigint;
+    input: I;
+    output: O;
+    impl: Impl;
+}
+type AnySpec = ViewSpec<any, any> | ExecuteSpec<any, any, any> | CustomSpec<any, any, any>;
+declare const createViewBuilder: <I extends Schema>(opcode: bigint, input: I) => {
+    readonly returns: <O extends Dec = "uint8Array">(output?: O) => ViewSpec<I, O>;
+};
+declare const createExecuteBuilder: <I extends Schema = VoidEnc, K extends BorshSchema<any> | VoidEnc = VoidEnc>(opcode: bigint, input: I, inscription?: K) => {
+    readonly returns: <O extends Dec = "uint8Array">(output?: O) => ExecuteSpec<I, K, O>;
+};
+type ExtractParam<T> = T extends (this: any, opcode: bigint, params: infer P) => any ? P : never;
+declare function attach<Spec extends Record<string, any>, Base extends typeof AlkanesBaseContract>(BaseClass: Base, spec: Spec): {
+    new (...a: ConstructorParameters<Base>): (Omit<InstanceType<Base>, keyof Spec | "OpCodes"> & {
+        OpCodes: OpcodeTable;
+    }) & { [K in keyof Spec]: Spec[K] extends {
+        _t: typeof VIEW_TAG;
+    } ? (arg: Spec[K]["input"] extends "__void" ? void : ResolveSchema<Spec[K]["input"]>) => Promise<BoxedResponse<ResolveSchema<Spec[K]["output"]>, AlkanesSimulationError>> : Spec[K] extends {
+        _t: typeof EXEC_TAG;
+    } ? (address: string, ...args: [...Spec[K]["input"] extends "__void" ? Spec[K]["inscription"] extends "__void" ? [] : [ResolveSchema<Spec[K]["inscription"]>] : Spec[K]["inscription"] extends "__void" ? [ResolveSchema<Spec[K]["input"]>] : [ResolveSchema<Spec[K]["input"]>, ResolveSchema<Spec[K]["inscription"]>], (Partial<{
+        provider: Provider;
+        callData?: bigint[];
+        ignoreAlkanesUtxoCheck?: boolean;
+        transfers: SingularTransfer[];
+        feeOpts?: {
+            vsize: number;
+            input_length: number;
+        };
+        feeRate?: number;
+        availableUtxoTweak?: {
+            remove: Set<string>;
+            add: FormattedUtxo[];
+        };
+        ignoreAlkanesRequirementCheck?: boolean;
+        psbtTransfers?: SingularBTCTransfer[];
+        overrideInputs?: FormattedUtxo[] | null;
+        includeInputs?: {
+            input_extended: PsbtInputExtended;
+            input_formatted: FormattedUtxo;
+        }[];
+        includePsbts?: string[];
+        excludeProtostone?: boolean;
+    }> | undefined)?]) => Promise<BoxedResponse<{
+        waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<ResolveSchema<Spec[K]["output"]>>, AlkanesExecuteError>>;
+        txid: string;
+    }, AlkanesExecuteError>> : Spec[K] extends {
+        _t: typeof CUSTOM_TAG;
+    } ? Spec[K]["input"] extends never ? () => ReturnType<NonNullable<Spec[K]["impl"]>> : (params: Spec[K]["input"]) => ReturnType<NonNullable<Spec[K]["impl"]>> : never; };
+};
+declare function contract<Base extends Record<string, any>>(base: Base): Base & {
+    extend: <Extra extends Record<string, any>>(extra: Extra) => Base & Extra & {
+        extend: <Extra_1 extends Record<string, any>>(extra: Extra_1) => Base & Extra & Extra_1 & {
+            extend: <Extra_2 extends Record<string, any>>(extra: Extra_2) => Base & Extra & Extra_1 & Extra_2 & {
+                extend: <Extra_3 extends Record<string, any>>(extra: Extra_3) => Base & Extra & Extra_1 & Extra_2 & Extra_3 & {
+                    extend: <Extra_4 extends Record<string, any>>(extra: Extra_4) => Base & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & {
+                        extend: <Extra_5 extends Record<string, any>>(extra: Extra_5) => Base & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & {
+                            extend: <Extra_6 extends Record<string, any>>(extra: Extra_6) => Base & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & {
+                                extend: <Extra_7 extends Record<string, any>>(extra: Extra_7) => Base & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & Extra_7 & {
+                                    extend: <Extra_8 extends Record<string, any>>(extra: Extra_8) => Base & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & Extra_7 & Extra_8 & {
+                                        extend: <Extra_9 extends Record<string, any>>(extra: Extra_9) => Base & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & Extra_7 & Extra_8 & Extra_9 & {
+                                            extend: <Extra_10 extends Record<string, any>>(extra: Extra_10) => Base & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & Extra_7 & Extra_8 & Extra_9 & Extra_10 & {
+                                                extend: /*elided*/ any;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+declare const abi: {
+    readonly opcode: (code: bigint) => {
+        readonly view: {
+            <I extends Schema>(input: I): ReturnType<typeof createViewBuilder<I>>;
+            (): ReturnType<typeof createViewBuilder<VoidEnc>>;
+        };
+        readonly execute: {
+            <I extends Schema, K extends BorshSchema<any>>(input: I, inscription: K): ReturnType<typeof createExecuteBuilder<I, K>>;
+            <K extends BorshSchema<any>>(input: undefined, inscription: K): ReturnType<typeof createExecuteBuilder<VoidEnc, K>>;
+            <I extends Schema>(input: I): ReturnType<typeof createExecuteBuilder<I, VoidEnc>>;
+            (): ReturnType<typeof createExecuteBuilder<VoidEnc, VoidEnc>>;
+        };
+        readonly custom: <Impl extends CustomImpl<any>, O extends Dec = "uint8Array">(impl: Impl, opts?: {
+            output?: O;
+        }) => CustomSpec<ExtractParam<Impl>, O, Impl>;
+    };
+    readonly contract: typeof contract;
+    readonly attach: typeof attach;
+    readonly extend: <A extends Record<string, AnySpec>, B extends Record<string, AnySpec>>(a: A, b: B) => A & B;
+};
+
+declare enum AlkanesSimulationError {
+    UnknownError = "UnknownError",
+    TransactionReverted = "Revert"
+}
+type OpcodeTable = {
+    readonly [K in string]: bigint;
+};
+type AlkanesPushExecuteResponse<T> = Expand<{
+    waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<T>, AlkanesExecuteError>>;
+    txid: string;
+}>;
+declare abstract class AlkanesBaseContract {
+    protected readonly provider: Provider;
+    readonly alkaneId: AlkaneId;
+    private readonly signPsbtFn;
+    constructor(provider: Provider, alkaneId: AlkaneId, signPsbtFn: (unsigned: string) => Promise<string>);
+    protected abstract get OpCodes(): OpcodeTable;
+    protected get rpc(): <T>(method: string, params?: unknown[]) => RpcCall<T>;
+    protected get execute(): (config: Omit<Parameters<typeof execute>[0], "provider">) => ReturnType<typeof execute>;
+    protected get trace(): (txid: string, vout: number) => ReturnType<ReturnType<(txid: string, vout: number) => {
+        payload: (string | {
+            txid: string;
+            vout: number;
+        }[])[];
+        call: () => Promise<BoxedResponse<AlkanesTraceResult, AlkanesTraceError>>;
+    }>["call"]>;
+    get signPsbt(): (unsigned: string) => Promise<string>;
+    simulate(request: Omit<Parameters<Provider["simulate"]>[0], "target">): ReturnType<Provider["simulate"]>;
+    private getEncodedCallData;
+    private getDecodedResponse;
+    pushExecute: <T>(config: Parameters<Provider["execute"]>[0], borshSchema?: BorshSchema<T>) => Promise<BoxedResponse<AlkanesPushExecuteResponse<T>, AlkanesExecuteError>>;
+    handleView<I extends Schema, O extends Schema>(opcode: bigint, arg: ResolveSchema<I>, inShape: I, // may or may not be a BorshSchema
+    outShape: O): Promise<BoxedResponse<ResolveSchema<O>, AlkanesSimulationError>>;
+    handleExecute<I extends Schema, K extends BorshSchema<unknown>, O extends Dec>(address: string, opcode: bigint, arg: ResolveSchema<I>, argInscription: ResolveSchema<K> | undefined, inShape: I, inInscriptionShape: K | undefined, // may or may not be a BorshSchema
+    outShape: O, txOpts?: Partial<ProtostoneTransactionOptions>): Promise<BoxedResponse<AlkanesPushExecuteResponse<ResolveSchema<O>>, AlkanesExecuteError>>;
+}
+
+declare const paramSchema: z.ZodObject<{
+    premine: z.ZodOptional<z.ZodBigInt>;
+    valuePerMint: z.ZodOptional<z.ZodBigInt>;
+    cap: z.ZodOptional<z.ZodBigInt>;
+    name: z.ZodString;
+    symbol: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    premine?: bigint | undefined;
+    valuePerMint?: bigint | undefined;
+    cap?: bigint | undefined;
+}, {
+    symbol: string;
+    name: string;
+    premine?: bigint | undefined;
+    valuePerMint?: bigint | undefined;
+    cap?: bigint | undefined;
+}>;
+type ITokenParamsSchema = z.infer<typeof paramSchema>;
+declare const TokenABI: {
+    initialize: CustomSpec<{
+        address: string;
+        tokenParams: ITokenParamsSchema;
+    }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+        address: string;
+        tokenParams: ITokenParamsSchema;
+    }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+        waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+        txid: string;
+    }>>>;
+    mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+    getName: ViewSpec<"__void", "string">;
+    getSymbol: ViewSpec<"__void", "string">;
+    getTotalSupply: ViewSpec<"__void", "tokenValue">;
+    getCap: ViewSpec<"__void", "bigint">;
+    getMinted: ViewSpec<"__void", "bigint">;
+    getValuePerMint: ViewSpec<"__void", "tokenValue">;
+    getData: ViewSpec<"__void", "uint8Array">;
+    getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+} & {
+    extend: <Extra extends Record<string, any>>(extra: Extra) => {
+        initialize: CustomSpec<{
+            address: string;
+            tokenParams: ITokenParamsSchema;
+        }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+            address: string;
+            tokenParams: ITokenParamsSchema;
+        }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+            waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+            txid: string;
+        }>>>;
+        mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+        getName: ViewSpec<"__void", "string">;
+        getSymbol: ViewSpec<"__void", "string">;
+        getTotalSupply: ViewSpec<"__void", "tokenValue">;
+        getCap: ViewSpec<"__void", "bigint">;
+        getMinted: ViewSpec<"__void", "bigint">;
+        getValuePerMint: ViewSpec<"__void", "tokenValue">;
+        getData: ViewSpec<"__void", "uint8Array">;
+        getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+    } & Extra & {
+        extend: <Extra_1 extends Record<string, any>>(extra: Extra_1) => {
+            initialize: CustomSpec<{
+                address: string;
+                tokenParams: ITokenParamsSchema;
+            }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                address: string;
+                tokenParams: ITokenParamsSchema;
+            }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                txid: string;
+            }>>>;
+            mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+            getName: ViewSpec<"__void", "string">;
+            getSymbol: ViewSpec<"__void", "string">;
+            getTotalSupply: ViewSpec<"__void", "tokenValue">;
+            getCap: ViewSpec<"__void", "bigint">;
+            getMinted: ViewSpec<"__void", "bigint">;
+            getValuePerMint: ViewSpec<"__void", "tokenValue">;
+            getData: ViewSpec<"__void", "uint8Array">;
+            getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+        } & Extra & Extra_1 & {
+            extend: <Extra_2 extends Record<string, any>>(extra: Extra_2) => {
+                initialize: CustomSpec<{
+                    address: string;
+                    tokenParams: ITokenParamsSchema;
+                }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                    address: string;
+                    tokenParams: ITokenParamsSchema;
+                }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                    waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                    txid: string;
+                }>>>;
+                mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                getName: ViewSpec<"__void", "string">;
+                getSymbol: ViewSpec<"__void", "string">;
+                getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                getCap: ViewSpec<"__void", "bigint">;
+                getMinted: ViewSpec<"__void", "bigint">;
+                getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                getData: ViewSpec<"__void", "uint8Array">;
+                getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+            } & Extra & Extra_1 & Extra_2 & {
+                extend: <Extra_3 extends Record<string, any>>(extra: Extra_3) => {
+                    initialize: CustomSpec<{
+                        address: string;
+                        tokenParams: ITokenParamsSchema;
+                    }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                        address: string;
+                        tokenParams: ITokenParamsSchema;
+                    }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                        waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                        txid: string;
+                    }>>>;
+                    mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                    getName: ViewSpec<"__void", "string">;
+                    getSymbol: ViewSpec<"__void", "string">;
+                    getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                    getCap: ViewSpec<"__void", "bigint">;
+                    getMinted: ViewSpec<"__void", "bigint">;
+                    getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                    getData: ViewSpec<"__void", "uint8Array">;
+                    getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+                } & Extra & Extra_1 & Extra_2 & Extra_3 & {
+                    extend: <Extra_4 extends Record<string, any>>(extra: Extra_4) => {
+                        initialize: CustomSpec<{
+                            address: string;
+                            tokenParams: ITokenParamsSchema;
+                        }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                            address: string;
+                            tokenParams: ITokenParamsSchema;
+                        }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                            waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                            txid: string;
+                        }>>>;
+                        mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                        getName: ViewSpec<"__void", "string">;
+                        getSymbol: ViewSpec<"__void", "string">;
+                        getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                        getCap: ViewSpec<"__void", "bigint">;
+                        getMinted: ViewSpec<"__void", "bigint">;
+                        getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                        getData: ViewSpec<"__void", "uint8Array">;
+                        getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+                    } & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & {
+                        extend: <Extra_5 extends Record<string, any>>(extra: Extra_5) => {
+                            initialize: CustomSpec<{
+                                address: string;
+                                tokenParams: ITokenParamsSchema;
+                            }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                                address: string;
+                                tokenParams: ITokenParamsSchema;
+                            }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                                waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                                txid: string;
+                            }>>>;
+                            mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                            getName: ViewSpec<"__void", "string">;
+                            getSymbol: ViewSpec<"__void", "string">;
+                            getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                            getCap: ViewSpec<"__void", "bigint">;
+                            getMinted: ViewSpec<"__void", "bigint">;
+                            getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                            getData: ViewSpec<"__void", "uint8Array">;
+                            getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+                        } & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & {
+                            extend: <Extra_6 extends Record<string, any>>(extra: Extra_6) => {
+                                initialize: CustomSpec<{
+                                    address: string;
+                                    tokenParams: ITokenParamsSchema;
+                                }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                                    address: string;
+                                    tokenParams: ITokenParamsSchema;
+                                }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                                    waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                                    txid: string;
+                                }>>>;
+                                mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                                getName: ViewSpec<"__void", "string">;
+                                getSymbol: ViewSpec<"__void", "string">;
+                                getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                                getCap: ViewSpec<"__void", "bigint">;
+                                getMinted: ViewSpec<"__void", "bigint">;
+                                getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                                getData: ViewSpec<"__void", "uint8Array">;
+                                getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+                            } & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & {
+                                extend: <Extra_7 extends Record<string, any>>(extra: Extra_7) => {
+                                    initialize: CustomSpec<{
+                                        address: string;
+                                        tokenParams: ITokenParamsSchema;
+                                    }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                                        address: string;
+                                        tokenParams: ITokenParamsSchema;
+                                    }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                                        waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                                        txid: string;
+                                    }>>>;
+                                    mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                                    getName: ViewSpec<"__void", "string">;
+                                    getSymbol: ViewSpec<"__void", "string">;
+                                    getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                                    getCap: ViewSpec<"__void", "bigint">;
+                                    getMinted: ViewSpec<"__void", "bigint">;
+                                    getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                                    getData: ViewSpec<"__void", "uint8Array">;
+                                    getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+                                } & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & Extra_7 & {
+                                    extend: <Extra_8 extends Record<string, any>>(extra: Extra_8) => {
+                                        initialize: CustomSpec<{
+                                            address: string;
+                                            tokenParams: ITokenParamsSchema;
+                                        }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                                            address: string;
+                                            tokenParams: ITokenParamsSchema;
+                                        }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                                            waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                                            txid: string;
+                                        }>>>;
+                                        mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                                        getName: ViewSpec<"__void", "string">;
+                                        getSymbol: ViewSpec<"__void", "string">;
+                                        getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                                        getCap: ViewSpec<"__void", "bigint">;
+                                        getMinted: ViewSpec<"__void", "bigint">;
+                                        getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                                        getData: ViewSpec<"__void", "uint8Array">;
+                                        getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+                                    } & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & Extra_7 & Extra_8 & {
+                                        extend: <Extra_9 extends Record<string, any>>(extra: Extra_9) => {
+                                            initialize: CustomSpec<{
+                                                address: string;
+                                                tokenParams: ITokenParamsSchema;
+                                            }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                                                address: string;
+                                                tokenParams: ITokenParamsSchema;
+                                            }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                                                waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                                                txid: string;
+                                            }>>>;
+                                            mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                                            getName: ViewSpec<"__void", "string">;
+                                            getSymbol: ViewSpec<"__void", "string">;
+                                            getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                                            getCap: ViewSpec<"__void", "bigint">;
+                                            getMinted: ViewSpec<"__void", "bigint">;
+                                            getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                                            getData: ViewSpec<"__void", "uint8Array">;
+                                            getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+                                        } & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & Extra_7 & Extra_8 & Extra_9 & {
+                                            extend: <Extra_10 extends Record<string, any>>(extra: Extra_10) => {
+                                                initialize: CustomSpec<{
+                                                    address: string;
+                                                    tokenParams: ITokenParamsSchema;
+                                                }, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, params: {
+                                                    address: string;
+                                                    tokenParams: ITokenParamsSchema;
+                                                }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+                                                    waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+                                                    txid: string;
+                                                }>>>;
+                                                mintTokens: ExecuteSpec<"__void", "__void", "uint8Array">;
+                                                getName: ViewSpec<"__void", "string">;
+                                                getSymbol: ViewSpec<"__void", "string">;
+                                                getTotalSupply: ViewSpec<"__void", "tokenValue">;
+                                                getCap: ViewSpec<"__void", "bigint">;
+                                                getMinted: ViewSpec<"__void", "bigint">;
+                                                getValuePerMint: ViewSpec<"__void", "tokenValue">;
+                                                getData: ViewSpec<"__void", "uint8Array">;
+                                                getBalance: CustomSpec<string, "uint8Array", (this: AlkanesBaseContract, opcode: bigint, address: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>>;
+                                            } & Extra & Extra_1 & Extra_2 & Extra_3 & Extra_4 & Extra_5 & Extra_6 & Extra_7 & Extra_8 & Extra_9 & Extra_10 & /*elided*/ any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+declare const TokenContract_base: new (provider: Provider, alkaneId: AlkaneId, signPsbtFn: (unsigned: string) => Promise<string>) => Omit<AlkanesBaseContract, "initialize" | "extend" | "OpCodes" | "mintTokens" | "getName" | "getSymbol" | "getTotalSupply" | "getCap" | "getMinted" | "getValuePerMint" | "getData" | "getBalance"> & {
+    OpCodes: OpcodeTable;
+} & {
+    initialize: (params: {
+        address: string;
+        tokenParams: ITokenParamsSchema;
+    }) => Promise<BoxedError<AlkanesExecuteError.InvalidParams> | BoxedSuccess<{
+        waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<unknown>, AlkanesExecuteError>>;
+        txid: string;
+    }>>;
+    mintTokens: (address: string, args_0?: Partial<{
+        provider: Provider;
+        callData?: bigint[];
+        ignoreAlkanesUtxoCheck?: boolean;
+        transfers: SingularTransfer[];
+        feeOpts?: {
+            vsize: number;
+            input_length: number;
+        };
+        feeRate?: number;
+        availableUtxoTweak?: {
+            remove: Set<string>;
+            add: FormattedUtxo[];
+        };
+        ignoreAlkanesRequirementCheck?: boolean;
+        psbtTransfers?: SingularBTCTransfer[];
+        overrideInputs?: FormattedUtxo[] | null;
+        includeInputs?: {
+            input_extended: PsbtInputExtended;
+            input_formatted: FormattedUtxo;
+        }[];
+        includePsbts?: string[];
+        excludeProtostone?: boolean;
+    }> | undefined) => Promise<BoxedResponse<{
+        waitForResult: () => Promise<BoxedResponse<IDecodableAlkanesResponse<never>, AlkanesExecuteError>>;
+        txid: string;
+    }, AlkanesExecuteError>>;
+    getName: (arg: void) => Promise<BoxedResponse<string, AlkanesSimulationError>>;
+    getSymbol: (arg: void) => Promise<BoxedResponse<string, AlkanesSimulationError>>;
+    getTotalSupply: (arg: void) => Promise<BoxedResponse<never, AlkanesSimulationError>>;
+    getCap: (arg: void) => Promise<BoxedResponse<bigint, AlkanesSimulationError>>;
+    getMinted: (arg: void) => Promise<BoxedResponse<bigint, AlkanesSimulationError>>;
+    getValuePerMint: (arg: void) => Promise<BoxedResponse<never, AlkanesSimulationError>>;
+    getData: (arg: void) => Promise<BoxedResponse<never, AlkanesSimulationError>>;
+    getBalance: (params: string) => Promise<BoxedSuccess<number> | BoxedError<AlkanesFetchError.UnknownError>>;
+    extend: never;
+};
+declare class TokenContract extends TokenContract_base {
+}
+
+export { AddressType, AlkanesBaseContract, AlkanesExecuteError, AlkanesFetchError, AlkanesInscription, AlkanesRpcProvider, AlkanesSimulationError, AlkanesTraceError, BaseRpcProvider, DecodableAlkanesResponse, DecodeError, EcPair, ElectrumApiProvider, Encodable, EncodeError, EsploraFetchError, OrdFetchError, OrdRpcProvider, ParsableAlkaneId, ProtostoneTransaction, ProtostoneTransactionWithInscription, Provider, RpcError, RunesFetchError, RunesRpcProvider, SandshrewFetchError, SandshrewRpcProvider, TokenABI, TokenContract, abi, addInputDynamic, addressFormats, addressNameToType, addressTypeToName, assertHex, buildRpcCall, calculateTaprootTxSize, decodeAlkanesTrace, decodeCBOR, excludeFields, execute, extractAbiErrorMessage, extractWithDummySigs, formatInputsToSign, getAddressType, getDummyProtostoneTransaction, getEstimatedFee, getProtostoneTransactionsWithInscription, getProtostoneUnsignedPsbtBase64, getVSize, hexToUint8Array, makeFakeBlock, mapToPrimitives, minimumFee, parseSimulateReturn, psbtBuilder, redeemTypeFromOutput, reverseHexBytes, schemaAlkaneId, simulate, sleep, stripHex, tapTweakHash, toEsploraTx, toFormattedUtxo, toU128LittleEndianHex, toU64BigEndianHex, toU64LittleEndianHex, trimUndefined, tweakSigner, u128Schema, unmapFromPrimitives, witnessStackToScriptWitness };
+export type { Account, AddressKey, Alkane, AlkaneDetails, AlkaneEncoded, AlkaneEncodedSimulationRequest, AlkaneId, AlkaneReadableId, AlkaneRune, AlkaneSimulateRequest, AlkaneToken, AlkanesByAddressOutpoint, AlkanesByAddressResponse, AlkanesByAddressRuneBalance, AlkanesExecuteResponse, AlkanesOutpoint, AlkanesOutpointExtended, AlkanesOutpoints, AlkanesOutpointsExtended, AlkanesParsedSimulationResult, AlkanesParsedTraceResult, AlkanesPushExecuteResponse, AlkanesRawSimulationResponse, AlkanesSimulationResult, AlkanesTraceCreateEvent, AlkanesTraceEncodedCreateEvent, AlkanesTraceEncodedEvent, AlkanesTraceEncodedInvokeEvent, AlkanesTraceEncodedResult, AlkanesTraceEncodedReturnEvent, AlkanesTraceEvent, AlkanesTraceInvokeEvent, AlkanesTraceResult, AlkanesTraceReturnEvent, AlkanesUtxo, AlkanesUtxoBalance, AlkanesUtxoEntry, AvailableDecodeKind, AvailableEncodeKind, CustomSpec, Dec, DecodedCBOR, DecodedCBORValue, DecoderFns, Enc, EncodedAlkaneId, EncoderFns, EsploraAddressResponse, EsploraAddressStats, EsploraUtxo, ExecuteSpec, Expand, FormattedUtxo, HDPaths, IDecodableAlkanesResponse, IEncodable, IEsploraBlockHeader, IEsploraPrevout, IEsploraSpendableUtxo, IEsploraTransaction, IEsploraTransactionStatus, IEsploraVin, IEsploraVout, ISchemaAlkaneId, OpcodeTable, OrdBlock, OrdInscription, OrdOutput, OrdOutputRune, OrdPaginatedIds, OrdSat, ProtoRunesToken, ProtostoneTransactionOptions, ProtostoneTransactionOptionsPartial, ProviderConfig, PsbtInputExtended, ResolveSchema, RpcCall, RpcResponse, RpcTuple, Rune, RuneBalance, RuneName, RunesAddressResult, RunesOutpoint, RunesOutpointResult, Schema, SingularAlkanesTransfer, SingularBTCTransfer, SingularTransfer, SpendStrategy, ViewSpec, WalletStandard };