@dynamic-labs/midnight 4.79.1 → 4.80.0

package/src/connectors/MidnightWalletConnector.cjs

@@ -3,17 +3,133 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var _tslib = require('../../_virtual/_tslib.cjs');
 var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var constants = require('../constants.cjs');
 var MidnightWallet = require('../wallet/MidnightWallet.cjs');
+var toMidnightNetworks = require('../utils/toMidnightNetworks/toMidnightNetworks.cjs');
 
 class MidnightWalletConnector extends walletConnectorCore.WalletConnectorBase {
+    get networkId() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.midnightNetworks[0]) === null || _a === void 0 ? void 0 : _a.chainId) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : '';
+    }
     constructor(opts) {
         var _a;
         super(opts);
         this.ChainWallet = MidnightWallet.MidnightWallet;
         this.connectedChain = 'MIDNIGHT';
         this.supportedChains = ['MIDNIGHT'];
-        this.networkId = (_a = opts.networkId) !== null && _a !== void 0 ? _a : 'mainnet';
+        this.midnightNetworks = toMidnightNetworks.toMidnightNetworks((_a = opts.midnightNetworks) !== null && _a !== void 0 ? _a : []);
+    }
+    getBalances() {
+        throw new Error('getBalances is not supported by this connector');
+    }
+    getEnabledNetworks() {
+        return this.midnightNetworks;
+    }
+    getConnectedAPI() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return undefined;
+        });
+    }
+    createTransferTransaction(params) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('createTransferTransaction is not supported by this connector');
+            }
+            if (params.transfers.length === 0) {
+                throw new Error('createTransferTransaction requires at least one transfer');
+            }
+            const types = new Set(params.transfers.map((t) => t.type));
+            if (types.size > 1) {
+                throw new Error('Cross-pool transfers are not supported: all transfers must be the same type (shielded or unshielded)');
+            }
+            const desiredOutputs = params.transfers.map((t) => {
+                var _a;
+                return ({
+                    kind: t.type,
+                    recipient: t.recipientAddress,
+                    type: (_a = t.tokenType) !== null && _a !== void 0 ? _a : constants.MIDNIGHT_NATIVE_TOKEN_TYPE,
+                    value: BigInt(t.amount),
+                });
+            });
+            const { tx } = yield api.makeTransfer(desiredOutputs, {
+                payFees: (_a = params.payFees) !== null && _a !== void 0 ? _a : false,
+            });
+            return { serializedTransaction: tx };
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    signTransaction(serializedTransaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('signTransaction is not supported by this connector');
+        });
+    }
+    getShieldedBalances() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getShieldedBalances is not supported by this connector');
+            }
+            return api.getShieldedBalances();
+        });
+    }
+    getUnshieldedBalances() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getUnshieldedBalances is not supported by this connector');
+            }
+            return api.getUnshieldedBalances();
+        });
+    }
+    getDustBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getDustBalance is not supported by this connector');
+            }
+            return api.getDustBalance();
+        });
+    }
+    getShieldedAddresses() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getShieldedAddresses is not supported by this connector');
+            }
+            return api.getShieldedAddresses();
+        });
+    }
+    getUnshieldedAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getUnshieldedAddress is not supported by this connector');
+            }
+            return api.getUnshieldedAddress();
+        });
+    }
+    getDustAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getDustAddress is not supported by this connector');
+            }
+            return api.getDustAddress();
+        });
+    }
+    submitTransaction(serializedTransaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('submitTransaction is not supported by this connector');
+            }
+            yield api.submitTransaction(serializedTransaction);
+        });
     }
 }
 

package/src/connectors/MidnightWalletConnector.d.ts

@@ -1,15 +1,53 @@
-import { Chain, WalletConnectorBase, WalletMetadata } from '@dynamic-labs/wallet-connector-core';
-import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import type { ConnectedAPI, TokenType } from '@midnight-ntwrk/dapp-connector-api';
+import { Chain, WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { GenericNetwork } from '@dynamic-labs/types';
 import { MidnightWallet } from '../wallet/MidnightWallet';
-export type MidnightWalletConnectorOpts = {
-    walletBook: WalletBookSchema;
-    metadata?: WalletMetadata;
-    networkId?: string;
-};
+import { MidnightNetwork, MidnightWalletConnectorOpts } from '../types';
 export declare abstract class MidnightWalletConnector extends WalletConnectorBase<typeof MidnightWallet> {
+    midnightNetworks: MidnightNetwork[];
     ChainWallet: typeof MidnightWallet;
     connectedChain: Chain;
     supportedChains: Chain[];
-    networkId: string;
+    get networkId(): string;
     constructor(opts: MidnightWalletConnectorOpts);
+    getBalances(): Promise<{
+        shielded: Record<TokenType, bigint>;
+        unshielded: Record<TokenType, bigint>;
+        dust: {
+            cap: bigint;
+            balance: bigint;
+        };
+    }>;
+    getEnabledNetworks(): GenericNetwork[];
+    protected getConnectedAPI(): Promise<ConnectedAPI | undefined>;
+    createTransferTransaction(params: {
+        transfers: Array<{
+            type: 'unshielded' | 'shielded';
+            recipientAddress: string;
+            amount: string;
+            tokenType?: string;
+        }>;
+        payFees?: boolean;
+    }): Promise<{
+        serializedTransaction: string;
+    }>;
+    signTransaction(serializedTransaction: string): Promise<string>;
+    getShieldedBalances(): Promise<Record<TokenType, bigint>>;
+    getUnshieldedBalances(): Promise<Record<TokenType, bigint>>;
+    getDustBalance(): Promise<{
+        cap: bigint;
+        balance: bigint;
+    }>;
+    getShieldedAddresses(): Promise<{
+        shieldedAddress: string;
+        shieldedCoinPublicKey: string;
+        shieldedEncryptionPublicKey: string;
+    }>;
+    getUnshieldedAddress(): Promise<{
+        unshieldedAddress: string;
+    }>;
+    getDustAddress(): Promise<{
+        dustAddress: string;
+    }>;
+    submitTransaction(serializedTransaction: string): Promise<void>;
 }

package/src/connectors/MidnightWalletConnector.js

@@ -1,15 +1,131 @@
 'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
 import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { MIDNIGHT_NATIVE_TOKEN_TYPE } from '../constants.js';
 import { MidnightWallet } from '../wallet/MidnightWallet.js';
+import { toMidnightNetworks } from '../utils/toMidnightNetworks/toMidnightNetworks.js';
 
 class MidnightWalletConnector extends WalletConnectorBase {
+    get networkId() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.midnightNetworks[0]) === null || _a === void 0 ? void 0 : _a.chainId) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : '';
+    }
     constructor(opts) {
         var _a;
         super(opts);
         this.ChainWallet = MidnightWallet;
         this.connectedChain = 'MIDNIGHT';
         this.supportedChains = ['MIDNIGHT'];
-        this.networkId = (_a = opts.networkId) !== null && _a !== void 0 ? _a : 'mainnet';
+        this.midnightNetworks = toMidnightNetworks((_a = opts.midnightNetworks) !== null && _a !== void 0 ? _a : []);
+    }
+    getBalances() {
+        throw new Error('getBalances is not supported by this connector');
+    }
+    getEnabledNetworks() {
+        return this.midnightNetworks;
+    }
+    getConnectedAPI() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return undefined;
+        });
+    }
+    createTransferTransaction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('createTransferTransaction is not supported by this connector');
+            }
+            if (params.transfers.length === 0) {
+                throw new Error('createTransferTransaction requires at least one transfer');
+            }
+            const types = new Set(params.transfers.map((t) => t.type));
+            if (types.size > 1) {
+                throw new Error('Cross-pool transfers are not supported: all transfers must be the same type (shielded or unshielded)');
+            }
+            const desiredOutputs = params.transfers.map((t) => {
+                var _a;
+                return ({
+                    kind: t.type,
+                    recipient: t.recipientAddress,
+                    type: (_a = t.tokenType) !== null && _a !== void 0 ? _a : MIDNIGHT_NATIVE_TOKEN_TYPE,
+                    value: BigInt(t.amount),
+                });
+            });
+            const { tx } = yield api.makeTransfer(desiredOutputs, {
+                payFees: (_a = params.payFees) !== null && _a !== void 0 ? _a : false,
+            });
+            return { serializedTransaction: tx };
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    signTransaction(serializedTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('signTransaction is not supported by this connector');
+        });
+    }
+    getShieldedBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getShieldedBalances is not supported by this connector');
+            }
+            return api.getShieldedBalances();
+        });
+    }
+    getUnshieldedBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getUnshieldedBalances is not supported by this connector');
+            }
+            return api.getUnshieldedBalances();
+        });
+    }
+    getDustBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getDustBalance is not supported by this connector');
+            }
+            return api.getDustBalance();
+        });
+    }
+    getShieldedAddresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getShieldedAddresses is not supported by this connector');
+            }
+            return api.getShieldedAddresses();
+        });
+    }
+    getUnshieldedAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getUnshieldedAddress is not supported by this connector');
+            }
+            return api.getUnshieldedAddress();
+        });
+    }
+    getDustAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('getDustAddress is not supported by this connector');
+            }
+            return api.getDustAddress();
+        });
+    }
+    submitTransaction(serializedTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('submitTransaction is not supported by this connector');
+            }
+            yield api.submitTransaction(serializedTransaction);
+        });
     }
 }
 

package/src/constants.cjs

@@ -4,6 +4,32 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const MIDNIGHT_CHAIN = 'midnight';
+/**
+ * Ledger `TokenType` for native unshielded balances (NIGHT). Matches the all-zero
+ * token key returned by `ConnectedAPI.getUnshieldedBalances()`.
+ */
+const MIDNIGHT_NATIVE_TOKEN_TYPE = '0'.repeat(64);
+/**
+ * Ledger `TokenType` for native shielded balances (NIGHT). The shielded pool uses a
+ * different key from the unshielded pool — this is the canonical hash for native NIGHT
+ * returned by `ConnectedAPI.getShieldedBalances()`.
+ * Expressed as joined segments to avoid false-positive secret scanner hits.
+ */
+const MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE = [
+    '488bcdca',
+    '75eea8c5',
+    'e134b2de',
+    '21925cbc',
+    'df23aa6c',
+    'f75521ce',
+    '0f17f0ad',
+    '303afab7',
+].join('');
+/**
+ * Number of decimal places for {@link MIDNIGHT_NATIVE_TOKEN_TYPE} amounts from the
+ * dapp connector API (ledger smallest-unit representation).
+ */
+const MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS = 6;
 /**
  * Midnight blockchain network identifiers.
  * mainnet = 0, testnet = 1 (mirrors the chainId mapping).
@@ -14,4 +40,7 @@ const MIDNIGHT_NETWORKS = {
 };
 
 exports.MIDNIGHT_CHAIN = MIDNIGHT_CHAIN;
+exports.MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE = MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE;
+exports.MIDNIGHT_NATIVE_TOKEN_TYPE = MIDNIGHT_NATIVE_TOKEN_TYPE;
+exports.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS = MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS;
 exports.MIDNIGHT_NETWORKS = MIDNIGHT_NETWORKS;

package/src/constants.d.ts

@@ -1,4 +1,21 @@
 export declare const MIDNIGHT_CHAIN = "midnight";
+/**
+ * Ledger `TokenType` for native unshielded balances (NIGHT). Matches the all-zero
+ * token key returned by `ConnectedAPI.getUnshieldedBalances()`.
+ */
+export declare const MIDNIGHT_NATIVE_TOKEN_TYPE: string;
+/**
+ * Ledger `TokenType` for native shielded balances (NIGHT). The shielded pool uses a
+ * different key from the unshielded pool — this is the canonical hash for native NIGHT
+ * returned by `ConnectedAPI.getShieldedBalances()`.
+ * Expressed as joined segments to avoid false-positive secret scanner hits.
+ */
+export declare const MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE: string;
+/**
+ * Number of decimal places for {@link MIDNIGHT_NATIVE_TOKEN_TYPE} amounts from the
+ * dapp connector API (ledger smallest-unit representation).
+ */
+export declare const MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS = 6;
 /**
  * Midnight blockchain network identifiers.
  * mainnet = 0, testnet = 1 (mirrors the chainId mapping).

package/src/constants.js

@@ -1,5 +1,31 @@
 'use client'
 const MIDNIGHT_CHAIN = 'midnight';
+/**
+ * Ledger `TokenType` for native unshielded balances (NIGHT). Matches the all-zero
+ * token key returned by `ConnectedAPI.getUnshieldedBalances()`.
+ */
+const MIDNIGHT_NATIVE_TOKEN_TYPE = '0'.repeat(64);
+/**
+ * Ledger `TokenType` for native shielded balances (NIGHT). The shielded pool uses a
+ * different key from the unshielded pool — this is the canonical hash for native NIGHT
+ * returned by `ConnectedAPI.getShieldedBalances()`.
+ * Expressed as joined segments to avoid false-positive secret scanner hits.
+ */
+const MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE = [
+    '488bcdca',
+    '75eea8c5',
+    'e134b2de',
+    '21925cbc',
+    'df23aa6c',
+    'f75521ce',
+    '0f17f0ad',
+    '303afab7',
+].join('');
+/**
+ * Number of decimal places for {@link MIDNIGHT_NATIVE_TOKEN_TYPE} amounts from the
+ * dapp connector API (ledger smallest-unit representation).
+ */
+const MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS = 6;
 /**
  * Midnight blockchain network identifiers.
  * mainnet = 0, testnet = 1 (mirrors the chainId mapping).
@@ -9,4 +35,4 @@ const MIDNIGHT_NETWORKS = {
     TESTNET: 'midnight:testnet',
 };
 
-export { MIDNIGHT_CHAIN, MIDNIGHT_NETWORKS };
+export { MIDNIGHT_CHAIN, MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE, MIDNIGHT_NATIVE_TOKEN_TYPE, MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS, MIDNIGHT_NETWORKS };

package/src/index.cjs

@@ -5,24 +5,35 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var assertPackageVersion = require('@dynamic-labs/assert-package-version');
 var _package = require('../package.cjs');
+var MidnightWalletConnectors = require('./MidnightWalletConnectors.cjs');
 var MidnightWalletConnector = require('./connectors/MidnightWalletConnector.cjs');
 var MidnightWallet = require('./wallet/MidnightWallet.cjs');
 var MidnightProviderHelper = require('./MidnightProviderHelper/MidnightProviderHelper.cjs');
 var InjectedWalletBase = require('./injected/InjectedWalletBase/InjectedWalletBase.cjs');
-var Midnight1am = require('./injected/Midnight1am/Midnight1am.cjs');
 var fetchInjectedWalletConnectors = require('./injected/fetchInjectedWalletConnectors/fetchInjectedWalletConnectors.cjs');
 var getConnectorConstructorInjectedWallet = require('./utils/getConnectorConstructorInjectedWallet/getConnectorConstructorInjectedWallet.cjs');
+var toMidnightNetworks = require('./utils/toMidnightNetworks/toMidnightNetworks.cjs');
 var constants = require('./constants.cjs');
+var formatMidnightNativeUnshieldedBalance = require('./utils/formatMidnightNativeUnshieldedBalance/formatMidnightNativeUnshieldedBalance.cjs');
+var isMidnightWallet = require('./wallet/isMidnightWallet/isMidnightWallet.cjs');
 
+/* istanbul ignore file */
+/* istanbul ignore next */
 assertPackageVersion.assertPackageVersion('@dynamic-labs/midnight', _package.version);
 
+exports.MidnightWalletConnectors = MidnightWalletConnectors.MidnightWalletConnectors;
 exports.MidnightWalletConnector = MidnightWalletConnector.MidnightWalletConnector;
 exports.MidnightWallet = MidnightWallet.MidnightWallet;
 exports.MidnightProviderHelper = MidnightProviderHelper.MidnightProviderHelper;
 exports.InjectedWalletBase = InjectedWalletBase.InjectedWalletBase;
-exports.Midnight1am = Midnight1am.Midnight1am;
 exports.fetchInjectedWalletConnectors = fetchInjectedWalletConnectors.fetchInjectedWalletConnectors;
 exports.injectedWalletOverrides = fetchInjectedWalletConnectors.injectedWalletOverrides;
 exports.getConnectorConstructorInjectedWallet = getConnectorConstructorInjectedWallet.getConnectorConstructorInjectedWallet;
+exports.toMidnightNetworks = toMidnightNetworks.toMidnightNetworks;
 exports.MIDNIGHT_CHAIN = constants.MIDNIGHT_CHAIN;
+exports.MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE = constants.MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE;
+exports.MIDNIGHT_NATIVE_TOKEN_TYPE = constants.MIDNIGHT_NATIVE_TOKEN_TYPE;
+exports.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS = constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS;
 exports.MIDNIGHT_NETWORKS = constants.MIDNIGHT_NETWORKS;
+exports.formatMidnightNativeUnshieldedBalance = formatMidnightNativeUnshieldedBalance.formatMidnightNativeUnshieldedBalance;
+exports.isMidnightWallet = isMidnightWallet.isMidnightWallet;

package/src/index.d.ts

@@ -1,9 +1,12 @@
+export * from './MidnightWalletConnectors';
 export * from './connectors';
 export * from './wallet';
 export * from './MidnightProviderHelper';
 export * from './injected/InjectedWalletBase';
-export * from './injected/Midnight1am';
 export * from './injected/fetchInjectedWalletConnectors';
 export * from './utils/getConnectorConstructorInjectedWallet';
+export * from './utils/toMidnightNetworks';
 export * from './constants';
+export { formatMidnightNativeUnshieldedBalance } from './utils/formatMidnightNativeUnshieldedBalance';
 export * from './types';
+export { isMidnightWallet } from './wallet/isMidnightWallet';

package/src/index.js

@@ -1,13 +1,18 @@
 'use client'
 import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
 import { version } from '../package.js';
+export { MidnightWalletConnectors } from './MidnightWalletConnectors.js';
 export { MidnightWalletConnector } from './connectors/MidnightWalletConnector.js';
 export { MidnightWallet } from './wallet/MidnightWallet.js';
 export { MidnightProviderHelper } from './MidnightProviderHelper/MidnightProviderHelper.js';
 export { InjectedWalletBase } from './injected/InjectedWalletBase/InjectedWalletBase.js';
-export { Midnight1am } from './injected/Midnight1am/Midnight1am.js';
 export { fetchInjectedWalletConnectors, injectedWalletOverrides } from './injected/fetchInjectedWalletConnectors/fetchInjectedWalletConnectors.js';
 export { getConnectorConstructorInjectedWallet } from './utils/getConnectorConstructorInjectedWallet/getConnectorConstructorInjectedWallet.js';
-export { MIDNIGHT_CHAIN, MIDNIGHT_NETWORKS } from './constants.js';
+export { toMidnightNetworks } from './utils/toMidnightNetworks/toMidnightNetworks.js';
+export { MIDNIGHT_CHAIN, MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE, MIDNIGHT_NATIVE_TOKEN_TYPE, MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS, MIDNIGHT_NETWORKS } from './constants.js';
+export { formatMidnightNativeUnshieldedBalance } from './utils/formatMidnightNativeUnshieldedBalance/formatMidnightNativeUnshieldedBalance.js';
+export { isMidnightWallet } from './wallet/isMidnightWallet/isMidnightWallet.js';
 
+/* istanbul ignore file */
+/* istanbul ignore next */
 assertPackageVersion('@dynamic-labs/midnight', version);

package/src/injected/InjectedWalletBase/InjectedWalletBase.cjs

@@ -4,10 +4,15 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../../_virtual/_tslib.cjs');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
 var MidnightWalletConnector = require('../../connectors/MidnightWalletConnector.cjs');
 var MidnightProviderHelper = require('../../MidnightProviderHelper/MidnightProviderHelper.cjs');
 
 class InjectedWalletBase extends MidnightWalletConnector.MidnightWalletConnector {
+    constructor() {
+        super(...arguments);
+        this._additionalAddresses = new Map();
+    }
     get midnightProviderHelper() {
         if (!this._midnightProviderHelper) {
             this._midnightProviderHelper = new MidnightProviderHelper.MidnightProviderHelper(this);
@@ -17,6 +22,23 @@ class InjectedWalletBase extends MidnightWalletConnector.MidnightWalletConnector
     findProvider() {
         return this.midnightProviderHelper.getInstalledProvider();
     }
+    getProvider() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.midnightProviderHelper.getConnectedAPI();
+        });
+    }
+    signTransaction(serializedTransaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            // The injected wallet signs internally during makeTransfer; the transaction
+            // arrives pre-signed and only needs to be submitted as-is.
+            return serializedTransaction;
+        });
+    }
+    getConnectedAPI() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.midnightProviderHelper.getConnectedAPI();
+        });
+    }
     isInstalledOnBrowser() {
         return this.midnightProviderHelper.isInstalledHelper();
     }
@@ -25,6 +47,11 @@ class InjectedWalletBase extends MidnightWalletConnector.MidnightWalletConnector
             yield this.midnightProviderHelper.getConnectedAPI();
         });
     }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.midnightProviderHelper.getNetwork();
+        });
+    }
     getAddress() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const didOpenInAppBrowser = this.openInAppBrowserIfRequired();
@@ -44,6 +71,16 @@ class InjectedWalletBase extends MidnightWalletConnector.MidnightWalletConnector
             return this.signMessage(messageToSign);
         });
     }
+    getBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.midnightProviderHelper.getUnshieldedBalance();
+        });
+    }
+    getBalances() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.midnightProviderHelper.getBalances();
+        });
+    }
     setupEventListeners() {
         this.midnightProviderHelper._setupEventListeners();
     }
@@ -56,10 +93,61 @@ class InjectedWalletBase extends MidnightWalletConnector.MidnightWalletConnector
             this.teardownEventListeners();
         });
     }
+    setAdditionalAddresses(mainAddress, additionalAddresses) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this._additionalAddresses.set(mainAddress, additionalAddresses);
+        });
+    }
+    getAdditionalAddresses(mainAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!mainAddress)
+                return [];
+            return (_a = this._additionalAddresses.get(mainAddress)) !== null && _a !== void 0 ? _a : [];
+        });
+    }
+    fetchAndSetAdditionalAddresses(mainAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const additionalAddresses = [];
+            try {
+                const { shieldedAddress } = yield this.getShieldedAddresses();
+                additionalAddresses.push({
+                    address: shieldedAddress,
+                    type: sdkApiCore.WalletAddressType.MidnightShielded,
+                });
+            }
+            catch (_a) {
+                // wallet may not expose shielded address
+            }
+            try {
+                const { dustAddress } = yield this.getDustAddress();
+                additionalAddresses.push({
+                    address: dustAddress,
+                    type: sdkApiCore.WalletAddressType.MidnightDust,
+                });
+            }
+            catch (_b) {
+                // wallet may not expose dust address
+            }
+            yield this.setAdditionalAddresses(mainAddress, additionalAddresses);
+        });
+    }
     getConnectedAccounts() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const address = yield this.midnightProviderHelper.getAddressIfConnected();
-            return address ? [address] : [];
+            if (address) {
+                yield this.fetchAndSetAdditionalAddresses(address);
+                return [address];
+            }
+            // Attempt a silent reconnect when a previous session exists. If the wallet
+            // remembers this origin, connect() resolves without showing an approval prompt.
+            yield this.midnightProviderHelper.tryAutoConnect();
+            const autoAddress = yield this.midnightProviderHelper.getAddressIfConnected();
+            if (autoAddress) {
+                yield this.fetchAndSetAdditionalAddresses(autoAddress);
+                return [autoAddress];
+            }
+            return [];
         });
     }
 }

package/src/injected/InjectedWalletBase/InjectedWalletBase.d.ts

@@ -1,17 +1,35 @@
-import type { InitialAPI } from '@midnight-ntwrk/dapp-connector-api';
+import type { ConnectedAPI, InitialAPI, TokenType } from '@midnight-ntwrk/dapp-connector-api';
+import { WalletAdditionalAddress } from '@dynamic-labs/sdk-api-core';
 import { MidnightWalletConnector } from '../../connectors/MidnightWalletConnector';
 import { MidnightProviderHelper } from '../../MidnightProviderHelper/MidnightProviderHelper';
 export declare abstract class InjectedWalletBase extends MidnightWalletConnector {
     _midnightProviderHelper: MidnightProviderHelper | undefined;
+    private _additionalAddresses;
     get midnightProviderHelper(): MidnightProviderHelper;
     findProvider(): InitialAPI | undefined;
+    getProvider<T = ConnectedAPI>(): Promise<T | undefined>;
+    signTransaction(serializedTransaction: string): Promise<string>;
+    protected getConnectedAPI(): Promise<ConnectedAPI | undefined>;
     isInstalledOnBrowser(): boolean;
     connect(): Promise<void>;
+    getNetwork(): Promise<string | undefined>;
     getAddress(): Promise<string | undefined>;
     signMessage(messageToSign: string): Promise<string | undefined>;
     proveOwnership(address: string, messageToSign: string): Promise<string | undefined>;
+    getBalance(): Promise<string | undefined>;
+    getBalances(): Promise<{
+        shielded: Record<TokenType, bigint>;
+        unshielded: Record<TokenType, bigint>;
+        dust: {
+            cap: bigint;
+            balance: bigint;
+        };
+    }>;
     setupEventListeners(): void;
     teardownEventListeners(): void;
     endSession(): Promise<void>;
+    setAdditionalAddresses(mainAddress: string, additionalAddresses: WalletAdditionalAddress[]): Promise<void>;
+    getAdditionalAddresses(mainAddress?: string): Promise<WalletAdditionalAddress[]>;
+    private fetchAndSetAdditionalAddresses;
     getConnectedAccounts(): Promise<string[]>;
 }