@midnightntwrk/wallet-sdk-unshielded-wallet 3.1.0

package/dist/v1/SyncSchema.d.ts

@@ -0,0 +1,447 @@
+import { Schema } from 'effect';
+declare const UtxoWithMetaSchema: Schema.transform<Schema.Struct<{
+    value: Schema.Schema<bigint, string, never>;
+    owner: typeof Schema.String;
+    tokenType: typeof Schema.String;
+    intentHash: typeof Schema.String;
+    outputIndex: typeof Schema.Number;
+    ctime: typeof Schema.Number;
+    registeredForDustGeneration: typeof Schema.Boolean;
+}>, Schema.SchemaClass<{
+    readonly utxo: {
+        readonly type: string;
+        readonly value: bigint;
+        readonly owner: string;
+        readonly intentHash: string;
+        readonly outputNo: number;
+    };
+    readonly meta: {
+        readonly ctime: Date;
+        readonly registeredForDustGeneration: boolean;
+    };
+}, {
+    readonly utxo: {
+        readonly type: string;
+        readonly value: bigint;
+        readonly owner: string;
+        readonly intentHash: string;
+        readonly outputNo: number;
+    };
+    readonly meta: {
+        readonly ctime: Date;
+        readonly registeredForDustGeneration: boolean;
+    };
+}, never>>;
+export type UtxoWithMeta = Schema.Schema.Type<typeof UtxoWithMetaSchema>;
+export declare const UnshieldedTransactionSchema: Schema.Data<Schema.Struct<{
+    id: typeof Schema.Number;
+    hash: typeof Schema.String;
+    type: Schema.Literal<["RegularTransaction", "SystemTransaction"]>;
+    protocolVersion: typeof Schema.Number;
+    identifiers: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    block: Schema.Struct<{
+        timestamp: Schema.transform<typeof Schema.Number, typeof Schema.DateFromSelf>;
+    }>;
+    fees: Schema.optional<Schema.Struct<{
+        paidFees: Schema.Schema<bigint, string, never>;
+        estimatedFees: Schema.Schema<bigint, string, never>;
+    }>>;
+    transactionResult: Schema.optional<Schema.Struct<{
+        status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
+        segments: Schema.NullOr<Schema.Array$<Schema.Struct<{
+            id: typeof Schema.Number;
+            success: typeof Schema.Boolean;
+        }>>>;
+    }>>;
+}>>;
+export type UnshieldedTransaction = Schema.Schema.Type<typeof UnshieldedTransactionSchema>;
+export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
+    type: Schema.Literal<["UnshieldedTransaction"]>;
+    transaction: Schema.Data<Schema.Struct<{
+        id: typeof Schema.Number;
+        hash: typeof Schema.String;
+        type: Schema.Literal<["RegularTransaction", "SystemTransaction"]>;
+        protocolVersion: typeof Schema.Number;
+        identifiers: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        block: Schema.Struct<{
+            timestamp: Schema.transform<typeof Schema.Number, typeof Schema.DateFromSelf>;
+        }>;
+        fees: Schema.optional<Schema.Struct<{
+            paidFees: Schema.Schema<bigint, string, never>;
+            estimatedFees: Schema.Schema<bigint, string, never>;
+        }>>;
+        transactionResult: Schema.optional<Schema.Struct<{
+            status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
+            segments: Schema.NullOr<Schema.Array$<Schema.Struct<{
+                id: typeof Schema.Number;
+                success: typeof Schema.Boolean;
+            }>>>;
+        }>>;
+    }>>;
+    createdUtxos: Schema.Array$<Schema.transform<Schema.Struct<{
+        value: Schema.Schema<bigint, string, never>;
+        owner: typeof Schema.String;
+        tokenType: typeof Schema.String;
+        intentHash: typeof Schema.String;
+        outputIndex: typeof Schema.Number;
+        ctime: typeof Schema.Number;
+        registeredForDustGeneration: typeof Schema.Boolean;
+    }>, Schema.SchemaClass<{
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }, {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }, never>>>;
+    spentUtxos: Schema.Array$<Schema.transform<Schema.Struct<{
+        value: Schema.Schema<bigint, string, never>;
+        owner: typeof Schema.String;
+        tokenType: typeof Schema.String;
+        intentHash: typeof Schema.String;
+        outputIndex: typeof Schema.Number;
+        ctime: typeof Schema.Number;
+        registeredForDustGeneration: typeof Schema.Boolean;
+    }>, Schema.SchemaClass<{
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }, {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }, never>>>;
+}>, Schema.SchemaClass<{
+    readonly type: "UnshieldedTransaction";
+    readonly spentUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
+    readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
+    readonly transaction: {
+        readonly type: "RegularTransaction" | "SystemTransaction";
+        readonly protocolVersion: number;
+        readonly id: number;
+        readonly hash: string;
+        readonly identifiers?: readonly string[] | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
+        readonly fees?: {
+            readonly paidFees: bigint;
+            readonly estimatedFees: bigint;
+        } | undefined;
+        readonly transactionResult?: {
+            readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
+            readonly segments: readonly {
+                readonly id: number;
+                readonly success: boolean;
+            }[] | null;
+        } | undefined;
+    };
+    readonly createdUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
+}, {
+    readonly type: "UnshieldedTransaction";
+    readonly spentUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
+    readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
+    readonly transaction: {
+        readonly type: "RegularTransaction" | "SystemTransaction";
+        readonly protocolVersion: number;
+        readonly id: number;
+        readonly hash: string;
+        readonly identifiers?: readonly string[] | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
+        readonly fees?: {
+            readonly paidFees: bigint;
+            readonly estimatedFees: bigint;
+        } | undefined;
+        readonly transactionResult?: {
+            readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
+            readonly segments: readonly {
+                readonly id: number;
+                readonly success: boolean;
+            }[] | null;
+        } | undefined;
+    };
+    readonly createdUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
+}, never>>;
+export type UnshieldedUpdate = Schema.Schema.Type<typeof UnshieldedUpdateSchema>;
+export declare const ProgressSchema: Schema.Struct<{
+    type: Schema.Literal<["UnshieldedTransactionsProgress"]>;
+    highestTransactionId: typeof Schema.Number;
+}>;
+export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Schema.Struct<{
+    type: Schema.Literal<["UnshieldedTransaction"]>;
+    transaction: Schema.Data<Schema.Struct<{
+        id: typeof Schema.Number;
+        hash: typeof Schema.String;
+        type: Schema.Literal<["RegularTransaction", "SystemTransaction"]>;
+        protocolVersion: typeof Schema.Number;
+        identifiers: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        block: Schema.Struct<{
+            timestamp: Schema.transform<typeof Schema.Number, typeof Schema.DateFromSelf>;
+        }>;
+        fees: Schema.optional<Schema.Struct<{
+            paidFees: Schema.Schema<bigint, string, never>;
+            estimatedFees: Schema.Schema<bigint, string, never>;
+        }>>;
+        transactionResult: Schema.optional<Schema.Struct<{
+            status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
+            segments: Schema.NullOr<Schema.Array$<Schema.Struct<{
+                id: typeof Schema.Number;
+                success: typeof Schema.Boolean;
+            }>>>;
+        }>>;
+    }>>;
+    createdUtxos: Schema.Array$<Schema.transform<Schema.Struct<{
+        value: Schema.Schema<bigint, string, never>;
+        owner: typeof Schema.String;
+        tokenType: typeof Schema.String;
+        intentHash: typeof Schema.String;
+        outputIndex: typeof Schema.Number;
+        ctime: typeof Schema.Number;
+        registeredForDustGeneration: typeof Schema.Boolean;
+    }>, Schema.SchemaClass<{
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }, {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }, never>>>;
+    spentUtxos: Schema.Array$<Schema.transform<Schema.Struct<{
+        value: Schema.Schema<bigint, string, never>;
+        owner: typeof Schema.String;
+        tokenType: typeof Schema.String;
+        intentHash: typeof Schema.String;
+        outputIndex: typeof Schema.Number;
+        ctime: typeof Schema.Number;
+        registeredForDustGeneration: typeof Schema.Boolean;
+    }>, Schema.SchemaClass<{
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }, {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }, never>>>;
+}>, Schema.SchemaClass<{
+    readonly type: "UnshieldedTransaction";
+    readonly spentUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
+    readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
+    readonly transaction: {
+        readonly type: "RegularTransaction" | "SystemTransaction";
+        readonly protocolVersion: number;
+        readonly id: number;
+        readonly hash: string;
+        readonly identifiers?: readonly string[] | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
+        readonly fees?: {
+            readonly paidFees: bigint;
+            readonly estimatedFees: bigint;
+        } | undefined;
+        readonly transactionResult?: {
+            readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
+            readonly segments: readonly {
+                readonly id: number;
+                readonly success: boolean;
+            }[] | null;
+        } | undefined;
+    };
+    readonly createdUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
+}, {
+    readonly type: "UnshieldedTransaction";
+    readonly spentUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
+    readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
+    readonly transaction: {
+        readonly type: "RegularTransaction" | "SystemTransaction";
+        readonly protocolVersion: number;
+        readonly id: number;
+        readonly hash: string;
+        readonly identifiers?: readonly string[] | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
+        readonly fees?: {
+            readonly paidFees: bigint;
+            readonly estimatedFees: bigint;
+        } | undefined;
+        readonly transactionResult?: {
+            readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
+            readonly segments: readonly {
+                readonly id: number;
+                readonly success: boolean;
+            }[] | null;
+        } | undefined;
+    };
+    readonly createdUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
+}, never>>, Schema.Struct<{
+    type: Schema.Literal<["UnshieldedTransactionsProgress"]>;
+    highestTransactionId: typeof Schema.Number;
+}>]>;
+export type WalletSyncUpdate = Schema.Schema.Type<typeof WalletSyncUpdateSchema>;
+export {};

package/dist/v1/SyncSchema.js

@@ -0,0 +1,114 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Schema } from 'effect';
+import { SafeBigInt } from '@midnightntwrk/wallet-sdk-utilities';
+const DateFromMillis = Schema.transform(Schema.Number, Schema.DateFromSelf, {
+    strict: true,
+    decode: (millis) => new Date(millis),
+    encode: (date) => date.getTime(),
+});
+const WireUtxoSchema = Schema.Struct({
+    value: SafeBigInt.SafeBigInt,
+    owner: Schema.String,
+    tokenType: Schema.String,
+    intentHash: Schema.String,
+    outputIndex: Schema.Number,
+    ctime: Schema.Number,
+    registeredForDustGeneration: Schema.Boolean,
+});
+const UtxoWithMetaSchema = Schema.transform(WireUtxoSchema, Schema.typeSchema(Schema.Struct({
+    utxo: Schema.Struct({
+        value: SafeBigInt.BigIntSchema,
+        owner: Schema.String,
+        type: Schema.String,
+        intentHash: Schema.String,
+        outputNo: Schema.Number,
+    }),
+    meta: Schema.Struct({
+        ctime: Schema.DateFromSelf,
+        registeredForDustGeneration: Schema.Boolean,
+    }),
+})), {
+    strict: true,
+    decode: (wire) => ({
+        utxo: {
+            value: wire.value,
+            owner: wire.owner,
+            type: wire.tokenType,
+            intentHash: wire.intentHash,
+            outputNo: wire.outputIndex,
+        },
+        meta: {
+            ctime: new Date(wire.ctime * 1000),
+            registeredForDustGeneration: wire.registeredForDustGeneration,
+        },
+    }),
+    encode: (domain) => ({
+        value: domain.utxo.value,
+        owner: domain.utxo.owner,
+        tokenType: domain.utxo.type,
+        intentHash: domain.utxo.intentHash,
+        outputIndex: domain.utxo.outputNo,
+        ctime: Math.floor(domain.meta.ctime.getTime() / 1000),
+        registeredForDustGeneration: domain.meta.registeredForDustGeneration,
+    }),
+});
+export const UnshieldedTransactionSchema = Schema.Data(Schema.Struct({
+    id: Schema.Number,
+    hash: Schema.String,
+    type: Schema.Literal('RegularTransaction', 'SystemTransaction'),
+    protocolVersion: Schema.Number,
+    identifiers: Schema.optional(Schema.Array(Schema.String)),
+    block: Schema.Struct({
+        timestamp: DateFromMillis,
+    }),
+    fees: Schema.optional(Schema.Struct({
+        paidFees: SafeBigInt.SafeBigInt,
+        estimatedFees: SafeBigInt.SafeBigInt,
+    })),
+    transactionResult: Schema.optional(Schema.Struct({
+        status: Schema.Literal('SUCCESS', 'FAILURE', 'PARTIAL_SUCCESS'),
+        segments: Schema.NullOr(Schema.Array(Schema.Struct({
+            id: Schema.Number,
+            success: Schema.Boolean,
+        }))),
+    })),
+}));
+const UnshieldedUpdateWireSchema = Schema.Struct({
+    type: Schema.Literal('UnshieldedTransaction'),
+    transaction: UnshieldedTransactionSchema,
+    createdUtxos: Schema.Array(UtxoWithMetaSchema),
+    spentUtxos: Schema.Array(UtxoWithMetaSchema),
+});
+export const UnshieldedUpdateSchema = Schema.transform(UnshieldedUpdateWireSchema, Schema.typeSchema(Schema.Struct({
+    type: Schema.Literal('UnshieldedTransaction'),
+    transaction: UnshieldedTransactionSchema,
+    createdUtxos: Schema.Array(Schema.typeSchema(UtxoWithMetaSchema)),
+    spentUtxos: Schema.Array(Schema.typeSchema(UtxoWithMetaSchema)),
+    status: Schema.Literal('SUCCESS', 'FAILURE', 'PARTIAL_SUCCESS'),
+})), {
+    strict: true,
+    decode: (wire) => {
+        const isSystemTransaction = wire.transaction.type === 'SystemTransaction';
+        return {
+            ...wire,
+            status: isSystemTransaction ? 'SUCCESS' : wire.transaction.transactionResult.status,
+        };
+    },
+    encode: ({ status: _status, ...rest }) => rest,
+});
+export const ProgressSchema = Schema.Struct({
+    type: Schema.Literal('UnshieldedTransactionsProgress'),
+    highestTransactionId: Schema.Number,
+});
+export const WalletSyncUpdateSchema = Schema.Union(UnshieldedUpdateSchema, ProgressSchema);

package/dist/v1/Transacting.d.ts

@@ -0,0 +1,125 @@
+import * as ledger from '@midnight-ntwrk/ledger-v8';
+import { type NetworkId } from '@midnightntwrk/wallet-sdk-abstractions';
+import { Either } from 'effect';
+import { CoreWallet } from './CoreWallet.js';
+import { type WalletError } from './WalletError.js';
+import { type UtxoWithMeta } from './UnshieldedState.js';
+import { type CoinSelection } from '@midnightntwrk/wallet-sdk-capabilities';
+import { TransactionOps, type UnboundTransaction } from './TransactionOps.js';
+import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { type KeysCapability } from './Keys.js';
+import { type UnshieldedAddress } from '@midnightntwrk/wallet-sdk-address-format';
+export interface TokenTransfer {
+    readonly amount: bigint;
+    readonly type: ledger.RawTokenType;
+    readonly receiverAddress: UnshieldedAddress;
+}
+export type FinalizedTransactionBalanceResult = ledger.UnprovenTransaction | undefined;
+export type UnboundTransactionBalanceResult = UnboundTransaction | undefined;
+export type UnprovenTransactionBalanceResult = ledger.UnprovenTransaction | undefined;
+export type TransactingResult<TTransaction, TState> = {
+    readonly newState: TState;
+    readonly transaction: TTransaction;
+};
+export interface TransactingCapability<TState> {
+    makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, TState>, WalletError>;
+    initSwap(wallet: CoreWallet, desiredInputs: Record<string, bigint>, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, TState>, WalletError>;
+    /**
+     * Builds an unproven transaction that moves a caller-supplied set of Night UTxOs back to their current owner,
+     * splitting them between the guaranteed and fallible sections of a single intent. The provided UTxOs are booked in
+     * the wallet state (moved from available to pending) so that no subsequent build call can pick them.
+     *
+     * Used by the Dust wallet's registration/deregistration flow, where the Dust wallet picks the guaranteed slot (based
+     * on dust generation) and hands both sets here for booking and intent construction. The Dust wallet then attaches its
+     * DustActions onto the returned intent.
+     *
+     * @param wallet - The wallet whose UTxOs are being passed through
+     * @param guaranteedUtxos - UTxOs to place in the guaranteed offer (segment 0)
+     * @param fallibleUtxos - UTxOs to place in the fallible offer (segment 1+)
+     * @param nightVerifyingKey - The verifying key used as the input owner and the address for the consolidating output
+     * @param ttl - The TTL for the transaction
+     * @returns The new wallet state (with all provided UTxOs booked) and the unproven transaction
+     */
+    rotateUtxos(wallet: CoreWallet, guaranteedUtxos: ReadonlyArray<UtxoWithMeta>, fallibleUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, TState>, WalletError>;
+    balanceFinalizedTransaction(wallet: CoreWallet, transaction: ledger.FinalizedTransaction): Either.Either<[FinalizedTransactionBalanceResult, CoreWallet], WalletError>;
+    balanceUnboundTransaction(wallet: CoreWallet, transaction: UnboundTransaction): Either.Either<[UnboundTransactionBalanceResult, CoreWallet], WalletError>;
+    balanceUnprovenTransaction(wallet: CoreWallet, transaction: ledger.UnprovenTransaction): Either.Either<[UnprovenTransactionBalanceResult, CoreWallet], WalletError>;
+    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<ledger.UnprovenTransaction, WalletError>;
+    revertTransaction(wallet: CoreWallet, transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Either.Either<CoreWallet, WalletError>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<UnboundTransaction, WalletError>;
+}
+export type DefaultTransactingConfiguration = {
+    networkId: NetworkId.NetworkId;
+};
+export type DefaultTransactingContext = {
+    coinSelection: CoinSelection<ledger.Utxo>;
+    coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
+    keysCapability: KeysCapability<CoreWallet>;
+};
+export declare const makeDefaultTransactingCapability: (config: DefaultTransactingConfiguration, getContext: () => DefaultTransactingContext) => TransactingCapability<CoreWallet>;
+export declare class TransactingCapabilityImplementation implements TransactingCapability<CoreWallet> {
+    #private;
+    readonly networkId: NetworkId.NetworkId;
+    readonly getCoinSelection: () => CoinSelection<ledger.Utxo>;
+    readonly txOps: TransactionOps;
+    readonly getCoins: () => CoinsAndBalancesCapability<CoreWallet>;
+    readonly getKeys: () => KeysCapability<CoreWallet>;
+    constructor(networkId: NetworkId.NetworkId, getCoinSelection: () => CoinSelection<ledger.Utxo>, getCoins: () => CoinsAndBalancesCapability<CoreWallet>, getKeys: () => KeysCapability<CoreWallet>, txOps: TransactionOps);
+    /**
+     * Balances an unbound transaction Note: Unbound transactions are balanced in place and returned
+     *
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns The balanced transaction and the new wallet state if successful, otherwise an error
+     */
+    balanceUnboundTransaction(wallet: CoreWallet, transaction: UnboundTransaction): Either.Either<[UnboundTransactionBalanceResult, CoreWallet], WalletError>;
+    /**
+     * Balances an unproven transaction Note: This method does the same thing as balanceUnboundTransaction but is provided
+     * for convenience and type safety
+     *
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns The balanced transaction and the new wallet state if successful, otherwise an error
+     */
+    balanceUnprovenTransaction(wallet: CoreWallet, transaction: ledger.UnprovenTransaction): Either.Either<[UnprovenTransactionBalanceResult, CoreWallet], WalletError>;
+    /**
+     * Balances a bound transaction Note: In bound transactions we can only balance the guaranteed section in intents
+     *
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns A balancing counterpart transaction (which should be merged with the original transaction ) and the new
+     *   wallet state if successful, otherwise an error
+     */
+    balanceFinalizedTransaction(wallet: CoreWallet, transaction: ledger.FinalizedTransaction): Either.Either<[FinalizedTransactionBalanceResult, CoreWallet], WalletError>;
+    /**
+     * Makes a transfer transaction
+     *
+     * @param wallet - The wallet to make the transfer with
+     * @param outputs - The outputs for the transfer
+     * @param ttl - The TTL for the transaction
+     * @returns The balanced transfer transaction and the new wallet state if successful, otherwise an error
+     */
+    makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, CoreWallet>, WalletError>;
+    rotateUtxos(wallet: CoreWallet, guaranteedUtxos: ReadonlyArray<UtxoWithMeta>, fallibleUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, CoreWallet>, WalletError>;
+    /**
+     * Initializes a swap transaction
+     *
+     * @param wallet - The wallet to initialize the swap for
+     * @param desiredInputs - The desired inputs for the swap
+     * @param desiredOutputs - The desired outputs for the swap
+     * @param ttl - The TTL for the swap
+     * @returns The initialized swap transaction and the new wallet state if successful, otherwise an error
+     */
+    initSwap(wallet: CoreWallet, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, CoreWallet>, WalletError>;
+    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<ledger.UnprovenTransaction, WalletError>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<UnboundTransaction, WalletError>;
+    /**
+     * Reverts a transaction by rolling back all inputs owned by this wallet
+     *
+     * @param wallet - The wallet to revert the transaction for
+     * @param transaction - The transaction to revert (can be FinalizedTransaction, UnboundTransaction, or
+     *   UnprovenTransaction)
+     * @returns The updated wallet with rolled back UTXOs if successful, otherwise an error
+     */
+    revertTransaction(wallet: CoreWallet, transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Either.Either<CoreWallet, WalletError>;
+}