@midnight-ntwrk/wallet-sdk-unshielded-wallet 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/v1/SyncSchema.d.ts

@@ -0,0 +1,449 @@
+import { Schema } from 'effect';
+export declare const BigIntSchema: Schema.declare<bigint, bigint, readonly [], never>;
+export declare const SafeBigInt: Schema.Schema<bigint, string>;
+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 fees?: {
+            readonly paidFees: bigint;
+            readonly estimatedFees: bigint;
+        } | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
+        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 fees?: {
+            readonly paidFees: bigint;
+            readonly estimatedFees: bigint;
+        } | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
+        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 fees?: {
+            readonly paidFees: bigint;
+            readonly estimatedFees: bigint;
+        } | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
+        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 fees?: {
+            readonly paidFees: bigint;
+            readonly estimatedFees: bigint;
+        } | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
+        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,123 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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 { Effect, Schema, ParseResult } from 'effect';
+export const BigIntSchema = Schema.declare((input) => typeof input === 'bigint').annotations({
+    identifier: 'BigIntSchema',
+});
+export const SafeBigInt = Schema.transformOrFail(Schema.String, BigIntSchema, {
+    decode: (value) => Effect.try({
+        try: () => BigInt(value),
+        catch: (err) => new ParseResult.Unexpected(err, 'Could not parse bigint'),
+    }),
+    encode: (value) => Effect.succeed(value.toString()),
+});
+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,
+    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: 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,
+        estimatedFees: 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,45 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+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 { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { KeysCapability } from './Keys.js';
+export interface TokenTransfer {
+    readonly amount: bigint;
+    readonly type: ledger.RawTokenType;
+    readonly receiverAddress: string;
+}
+export type TransactingResult<TTransaction, TState> = {
+    readonly newState: TState;
+    readonly transaction: TTransaction;
+};
+export interface TransactingCapability<_TTransaction, 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>;
+}
+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<ledger.UnprovenTransaction, CoreWallet>;
+export declare class TransactingCapabilityImplementation<TTransaction extends ledger.UnprovenTransaction> implements TransactingCapability<ledger.UnprovenTransaction, CoreWallet> {
+    readonly networkId: NetworkId.NetworkId;
+    readonly getCoinSelection: () => CoinSelection<ledger.Utxo>;
+    readonly txTrait: TransactionTrait<TTransaction>;
+    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>;
+}