@midnight-ntwrk/wallet-sdk-unshielded-wallet 1.0.0-beta.17 → 1.0.0-beta.19

package/dist/UnshieldedWallet.d.ts

@@ -1,12 +1,12 @@
 import { ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { BaseV1Configuration, DefaultV1Configuration, V1Variant, CoreWallet } from './v1/index.js';
+import { BaseV1Configuration, DefaultV1Configuration, V1Variant, CoreWallet, UnboundTransaction } from './v1/index.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import * as rx from 'rxjs';
 import { SerializationCapability } from './v1/Serialization.js';
 import { TransactionHistoryService } from './v1/TransactionHistory.js';
 import { CoinsAndBalancesCapability } from './v1/CoinsAndBalances.js';
 import { KeysCapability } from './v1/Keys.js';
-import { TokenTransfer } from './v1/Transacting.js';
+import { TokenTransfer, FinalizedTransactionBalanceResult, UnboundTransactionBalanceResult, UnprovenTransactionBalanceResult } from './v1/Transacting.js';
 import { WalletSyncUpdate } from './v1/SyncSchema.js';
 import { UtxoWithMeta } from './v1/UnshieldedState.js';
 import { Variant, VariantBuilder, WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
@@ -35,23 +35,26 @@ export declare class UnshieldedWalletState<TSerialized = string> {
     constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: UnshieldedWalletCapabilities<TSerialized>);
     serialize(): TSerialized;
 }
-export type UnshieldedWallet = CustomizedUnshieldedWallet<ledger.FinalizedTransaction, WalletSyncUpdate, string>;
-export type UnshieldedWalletClass = CustomizedUnshieldedWalletClass<ledger.FinalizedTransaction, WalletSyncUpdate, string>;
-export interface CustomizedUnshieldedWallet<TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string> extends WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction>>]> {
+export type UnshieldedWallet = CustomizedUnshieldedWallet<WalletSyncUpdate, string>;
+export type UnshieldedWalletClass = CustomizedUnshieldedWalletClass<WalletSyncUpdate, string, DefaultV1Configuration>;
+export interface CustomizedUnshieldedWallet<TSyncUpdate = WalletSyncUpdate, TSerialized = string> extends WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate>>]> {
     readonly state: rx.Observable<UnshieldedWalletState<TSerialized>>;
     start(): Promise<void>;
-    balanceTransaction(tx: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Promise<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
+    balanceFinalizedTransaction(tx: ledger.FinalizedTransaction): Promise<FinalizedTransactionBalanceResult>;
+    balanceUnboundTransaction(tx: UnboundTransaction): Promise<UnboundTransactionBalanceResult>;
+    balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Promise<UnprovenTransactionBalanceResult>;
     transferTransaction(outputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
     initSwap(desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
-    signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
+    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<UnboundTransaction>;
     serializeState(): Promise<TSerialized>;
     waitForSyncedState(allowedGap?: bigint): Promise<UnshieldedWalletState<TSerialized>>;
     getAddress(): Promise<UnshieldedAddress>;
 }
-export interface CustomizedUnshieldedWalletClass<TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction>>]> {
+export interface CustomizedUnshieldedWalletClass<TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate>>]> {
     configuration: TConfig;
-    startWithPublicKey(publicKey: PublicKey): CustomizedUnshieldedWallet<TTransaction, TSyncUpdate, TSerialized>;
-    restore(serializedState: TSerialized): CustomizedUnshieldedWallet<TTransaction, TSyncUpdate, TSerialized>;
+    startWithPublicKey(publicKey: PublicKey): CustomizedUnshieldedWallet<TSyncUpdate, TSerialized>;
+    restore(serializedState: TSerialized): CustomizedUnshieldedWallet<TSyncUpdate, TSerialized>;
 }
 export declare function UnshieldedWallet(configuration: DefaultV1Configuration): UnshieldedWalletClass;
-export declare function CustomUnshieldedWallet<TConfig extends BaseV1Configuration = DefaultV1Configuration, TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string>(configuration: TConfig, builder: VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate, TTransaction>, TConfig>): CustomizedUnshieldedWalletClass<TTransaction, TSyncUpdate, TSerialized, TConfig>;
+export declare function CustomUnshieldedWallet<TConfig extends BaseV1Configuration = DefaultV1Configuration, TSyncUpdate = WalletSyncUpdate, TSerialized = string>(configuration: TConfig, builder: VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate>, TConfig>): CustomizedUnshieldedWalletClass<TSyncUpdate, TSerialized, TConfig>;

package/dist/UnshieldedWallet.js

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { V1Builder, V1Tag, CoreWallet } from './v1/index.js';
+import { V1Builder, V1Tag, CoreWallet, } from './v1/index.js';
 import { Effect, Either } from 'effect';
 import * as rx from 'rxjs';
 import { WalletBuilder } from '@midnight-ntwrk/wallet-sdk-runtime';
@@ -77,10 +77,24 @@ export function CustomUnshieldedWallet(configuration, builder) {
         start() {
             return this.runtime.dispatch({ [V1Tag]: (v1) => v1.startSyncInBackground() }).pipe(Effect.runPromise);
         }
-        balanceTransaction(tx) {
+        balanceFinalizedTransaction(tx) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.balanceTransaction(tx),
+                [V1Tag]: (v1) => v1.balanceFinalizedTransaction(tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        balanceUnboundTransaction(tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceUnboundTransaction(tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        balanceUnprovenTransaction(tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceUnprovenTransaction(tx),
             })
                 .pipe(Effect.runPromise);
         }
@@ -96,10 +110,17 @@ export function CustomUnshieldedWallet(configuration, builder) {
                 .dispatch({ [V1Tag]: (v1) => v1.initSwap(desiredInputs, desiredOutputs, ttl) })
                 .pipe(Effect.runPromise);
         }
-        signTransaction(transaction, signSegment) {
+        signUnprovenTransaction(transaction, signSegment) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.signUnprovenTransaction(transaction, signSegment),
+            })
+                .pipe(Effect.runPromise);
+        }
+        signUnboundTransaction(transaction, signSegment) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.signTransaction(transaction, signSegment),
+                [V1Tag]: (v1) => v1.signUnboundTransaction(transaction, signSegment),
             })
                 .pipe(Effect.runPromise);
         }

package/dist/v1/RunningV1Variant.d.ts

@@ -3,7 +3,8 @@ import { WalletRuntimeError, Variant, StateChange } from '@midnight-ntwrk/wallet
 import { SerializationCapability } from './Serialization.js';
 import { SyncCapability, SyncService } from './Sync.js';
 import { WalletSyncUpdate } from './SyncSchema.js';
-import { TransactingCapability, TokenTransfer } from './Transacting.js';
+import { TransactingCapability, TokenTransfer, FinalizedTransactionBalanceResult, UnboundTransactionBalanceResult, UnprovenTransactionBalanceResult } from './Transacting.js';
+import { UnboundTransaction } from './TransactionOps.js';
 import { WalletError } from './WalletError.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
@@ -12,30 +13,33 @@ import { CoreWallet } from './CoreWallet.js';
 import { TransactionHistoryService } from './TransactionHistory.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 export declare namespace RunningV1Variant {
-    type Context<TSerialized, TSyncUpdate, TTransaction> = {
+    type Context<TSerialized, TSyncUpdate> = {
         serializationCapability: SerializationCapability<CoreWallet, TSerialized>;
         syncService: SyncService<CoreWallet, TSyncUpdate>;
         syncCapability: SyncCapability<CoreWallet, TSyncUpdate>;
-        transactingCapability: TransactingCapability<TTransaction, CoreWallet>;
+        transactingCapability: TransactingCapability<CoreWallet>;
         coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
         keysCapability: KeysCapability<CoreWallet>;
         coinSelection: CoinSelection<ledger.Utxo>;
         transactionHistoryService: TransactionHistoryService<WalletSyncUpdate>;
     };
-    type AnyContext = Context<any, any, any>;
+    type AnyContext = Context<any, any>;
 }
 export declare const V1Tag: unique symbol;
-export type DefaultRunningV1 = RunningV1Variant<string, WalletSyncUpdate, ledger.FinalizedTransaction>;
-export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction> implements Variant.RunningVariant<typeof V1Tag, CoreWallet> {
+export type DefaultRunningV1 = RunningV1Variant<string, WalletSyncUpdate>;
+export declare class RunningV1Variant<TSerialized, TSyncUpdate> implements Variant.RunningVariant<typeof V1Tag, CoreWallet> {
     #private;
     readonly __polyTag__: typeof V1Tag;
     readonly state: Stream.Stream<StateChange.StateChange<CoreWallet>, WalletRuntimeError>;
-    constructor(scope: Scope.Scope, context: Variant.VariantContext<CoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction>);
+    constructor(scope: Scope.Scope, context: Variant.VariantContext<CoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate>);
     startSyncInBackground(): Effect.Effect<void>;
     startSync(): Stream.Stream<void, WalletError, Scope.Scope>;
-    balanceTransaction(tx: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Effect.Effect<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, WalletError>;
+    balanceFinalizedTransaction(tx: ledger.FinalizedTransaction): Effect.Effect<FinalizedTransactionBalanceResult, WalletError>;
+    balanceUnboundTransaction(tx: UnboundTransaction): Effect.Effect<UnboundTransactionBalanceResult, WalletError>;
+    balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Effect.Effect<UnprovenTransactionBalanceResult, WalletError>;
     transferTransaction(outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     initSwap(desiredInputs: Record<string, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
-    signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<UnboundTransaction, WalletError>;
     serializeState(state: CoreWallet): TSerialized;
 }

package/dist/v1/RunningV1Variant.js

@@ -67,14 +67,24 @@ export class RunningV1Variant {
             return Duration.millis(Math.min(delayWithJitter, Duration.toMillis(maxDelay)));
         }))));
     }
-    balanceTransaction(tx) {
+    balanceFinalizedTransaction(tx) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.balanceTransaction(state, tx), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
+            return pipe(this.#v1Context.transactingCapability.balanceFinalizedTransaction(state, tx), EitherOps.toEffect);
+        });
+    }
+    balanceUnboundTransaction(tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceUnboundTransaction(state, tx), EitherOps.toEffect);
+        });
+    }
+    balanceUnprovenTransaction(tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceUnprovenTransaction(state, tx), EitherOps.toEffect);
         });
     }
     transferTransaction(outputs, ttl) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), EitherOps.toEffect, Effect.flatMap(({ transaction, newState }) => pipe(this.#v1Context.transactingCapability.balanceTransaction(newState, transaction), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]))));
+            return pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
         });
     }
     initSwap(desiredInputs, desiredOutputs, ttl) {
@@ -82,8 +92,11 @@ export class RunningV1Variant {
             return pipe(this.#v1Context.transactingCapability.initSwap(state, desiredInputs, desiredOutputs, ttl), Effect.map(({ transaction, newState }) => [transaction, newState]));
         });
     }
-    signTransaction(transaction, signSegment) {
-        return this.#v1Context.transactingCapability.signTransaction(transaction, signSegment);
+    signUnprovenTransaction(transaction, signSegment) {
+        return this.#v1Context.transactingCapability.signUnprovenTransaction(transaction, signSegment);
+    }
+    signUnboundTransaction(transaction, signSegment) {
+        return this.#v1Context.transactingCapability.signUnboundTransaction(transaction, signSegment);
     }
     serializeState(state) {
         return this.#v1Context.serializationCapability.serialize(state);

package/dist/v1/Transacting.d.ts

@@ -4,7 +4,7 @@ import { Either } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
 import { WalletError } from './WalletError.js';
 import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { TransactionTrait } from './Transaction.js';
+import { TransactionOps, UnboundTransaction } from './TransactionOps.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
 export interface TokenTransfer {
@@ -12,15 +12,22 @@ export interface TokenTransfer {
     readonly type: ledger.RawTokenType;
     readonly receiverAddress: string;
 }
+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<_TTransaction, TState> {
+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>;
-    balanceTransaction(wallet: CoreWallet, transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Either.Either<TransactingResult<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TState>, WalletError>;
-    signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<ledger.UnprovenTransaction, 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>;
+    revert(wallet: CoreWallet, transaction: ledger.FinalizedTransaction | UnboundTransaction | ledger.UnprovenTransaction): Either.Either<CoreWallet, WalletError>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<UnboundTransaction, WalletError>;
 }
 export type DefaultTransactingConfiguration = {
     networkId: NetworkId.NetworkId;
@@ -30,16 +37,64 @@ export type DefaultTransactingContext = {
     coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
     keysCapability: KeysCapability<CoreWallet>;
 };
-export declare const makeDefaultTransactingCapability: (config: DefaultTransactingConfiguration, getContext: () => DefaultTransactingContext) => TransactingCapability<ledger.UnprovenTransaction, CoreWallet>;
-export declare class TransactingCapabilityImplementation<TTransaction extends ledger.UnprovenTransaction> implements TransactingCapability<ledger.UnprovenTransaction, 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 txTrait: TransactionTrait<TTransaction>;
+    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>, txTrait: TransactionTrait<TTransaction>);
-    balanceTransaction(wallet: CoreWallet, transaction: TTransaction): Either.Either<TransactingResult<TTransaction, CoreWallet>, WalletError>;
-    makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<TTransaction, CoreWallet>, WalletError>;
-    initSwap(wallet: CoreWallet, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<TTransaction, CoreWallet>, WalletError>;
-    signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<ledger.UnprovenTransaction, WalletError>;
+    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>;
+    /**
+     * 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
+     */
+    revert(wallet: CoreWallet, transaction: ledger.FinalizedTransaction | UnboundTransaction | ledger.UnprovenTransaction): Either.Either<CoreWallet, WalletError>;
 }