monei-sdk 1.0.3 → 1.0.4

package/README.md

@@ -1,6 +1,6 @@
 # Mr. Monei Node.js SDK
 
-The official Node.js SDK for Monei API - providing seamless integration with Monei's comprehensive financial services including wallets, crypto transactions, bill payments, and AI agent.
+The official Node.js SDK for Monei API - providing seamless integration with Monei's comprehensive financial services including wallets, crypto transactions, bill payments, and exchanges.
 
 ## Installation
 
@@ -24,8 +24,8 @@ async function main() {
     const user = await sdk.user.getCurrentUser();
     console.log(`Welcome ${user.data.firstName} ${user.data.lastName}!`);
 
-    // Get wallet balance
-    const wallet = await sdk.wallet.getWalletBalance();
+    // Get wallet info
+    const wallet = await sdk.walletAccount.getWallet();
     console.log(`Naira Balance: ₦${wallet.nairaBalance.toLocaleString()}`);
 
   } catch (error) {
@@ -38,13 +38,12 @@ main();
 
 ## Features
 
-- **User Management** - Profile, KYC verification, user updates
+- **User Informations** - Profile
 - **Wallet Operations** - Balance, funding, withdrawals, peer transfers, bank verification
 - **EVM Wallets** - Ethereum, BSC, Polygon, Arbitrum support
 - **Solana Wallets** - SOL and SPL token management
 - **Bill Payments** - Airtime, data, electricity, cable TV
 - **Crypto Exchange** - Token swaps on EVM and Solana
-- **AI Agent** - Financial assistant with streaming support
 - **Transaction Management** - Transaction history and tracking
 - **Beneficiary Management** - Bank, crypto, and peer beneficiaries
 - **Full TypeScript Support** - Complete type definitions
@@ -58,22 +57,22 @@ import MoneiSDK from 'monei-sdk';
 
 const sdk = new MoneiSDK({ apiKey: 'your-api-key' });
 
-// Fund wallet
-const fundResult = await sdk.wallet.fundWalletByNaira({
+// Generate payment link
+const paymentResult = await sdk.deposit.generatePaymentLink({
   amount: 5000
 });
-console.log(`Funding link: ${fundResult.data.link}`);
+console.log(`Payment link: ${paymentResult.data.link}`);
 
 // Peer transfer
-await sdk.wallet.peerTransfer({
+await sdk.payout.peerTransfer({
   receiver: "user@example.com",
   amount: 1000,
   transactionPin: "123456"
 });
 
 // Get banks and verify account
-const banks = await sdk.wallet.getBanks();
-const account = await sdk.wallet.verifyBankAccount({
+const banks = await sdk.walletUtility.getBanks();
+const account = await sdk.walletUtility.verifyBankAccount({
   accountNumber: "1234567890",
   bank: "058" // GTBank code
 });
@@ -284,6 +283,10 @@ interface MoneiConfig {
 
 - `sdk.user` - User profile and management
 - `sdk.wallet` - Wallet and financial operations
+- `sdk.deposit` - Deposit operations through different channels
+- `sdk.payout` - Payout financial operations
+- `sdk.walletUtility` - Banking and wallet utilities
+- `sdk.paymentMethod` - Processing Financial operaios with payment methods(Automatic and recurrent charges)
 - `sdk.evm` - EVM blockchain operations
 - `sdk.solana` - Solana blockchain operations
 - `sdk.transactions` - Transaction history

package/dist/index.d.ts

@@ -1,12 +1,16 @@
 import { MoneiConfig } from './types';
-import { UserService, WalletService, EvmService, SolanaService, TransactionService, AgentService, BillService, ExchangeService } from './services';
+import { UserService, WalletService, DepositService, WalletAccountService, PayoutService, WalletUtilityService, PaymentMethodService, EvmService, SolanaService, TransactionService, BillService, ExchangeService } from './services';
 export declare class MoneiSDK {
     user: UserService;
     wallet: WalletService;
+    deposit: DepositService;
+    walletAccount: WalletAccountService;
+    payout: PayoutService;
+    walletUtility: WalletUtilityService;
+    paymentMethod: PaymentMethodService;
     evm: EvmService;
     solana: SolanaService;
     transactions: TransactionService;
-    agent: AgentService;
     bills: BillService;
     exchange: ExchangeService;
     private client;

package/dist/index.js

@@ -23,10 +23,15 @@ class MoneiSDK {
         // Initialize all services
         this.user = new services_1.UserService(this.client);
         this.wallet = new services_1.WalletService(this.client);
+        this.deposit = new services_1.DepositService(this.client);
+        this.walletAccount = new services_1.WalletAccountService(this.client);
+        this.payout = new services_1.PayoutService(this.client);
+        this.walletUtility = new services_1.WalletUtilityService(this.client);
+        this.paymentMethod = new services_1.PaymentMethodService(this.client);
         this.evm = new services_1.EvmService(this.client);
         this.solana = new services_1.SolanaService(this.client);
         this.transactions = new services_1.TransactionService(this.client);
-        this.agent = new services_1.AgentService(this.client);
+        //this.agent = new AgentService(this.client);
         this.bills = new services_1.BillService(this.client);
         this.exchange = new services_1.ExchangeService(this.client);
     }

package/dist/services/EvmService.d.ts

@@ -1,8 +1,9 @@
 import { MoneiClient } from '../client/MoneiClient';
-import { UserEvmPortfolioResponseDto, SendNativeTokenDto, SendNativeTokenResponseDto, SendTokenDto, SendTokenResponseDto, BalanceResponseDto } from '../types';
+import { UserEvmPortfolioResponseDto, SendNativeTokenDto, SendNativeTokenResponseDto, SendTokenDto, SendTokenResponseDto, BalanceResponseDto, SupportedNetworkResponseDto } from '../types';
 export declare class EvmService {
     private client;
     constructor(client: MoneiClient);
+    getSupportedNetworks(): Promise<SupportedNetworkResponseDto>;
     getPortfolio(chainId: number): Promise<UserEvmPortfolioResponseDto>;
     getNativeBalance(chainId: number): Promise<BalanceResponseDto>;
     getTokenBalance(tokenAddress: string, chainId: number): Promise<BalanceResponseDto>;

package/dist/services/EvmService.js

@@ -5,6 +5,9 @@ class EvmService {
     constructor(client) {
         this.client = client;
     }
+    async getSupportedNetworks() {
+        return this.client.get(`api/v1/evm/networks`);
+    }
     async getPortfolio(chainId) {
         return this.client.get(`/api/v1/evm/portfolio/${chainId}`);
     }

package/dist/services/ExchangeService.d.ts

@@ -1,5 +1,5 @@
 import { MoneiClient } from '../client/MoneiClient';
-import { SwapNativeToTokenDto, SwapTokenToTokenDto, SwapTokenToNativeDto, PriceResponseDto, TxHashResponseDto, SwapSolToTokenDto, SwapResponseDto } from '../types';
+import { SwapNativeToTokenDto, SwapTokenToTokenDto, SwapTokenToNativeDto, PriceResponseDto, TxHashResponseDto, SwapSolToTokenDto, SwapResponseDto, SwapTokenToSolDto } from '../types';
 export declare class ExchangeService {
     private client;
     constructor(client: MoneiClient);
@@ -9,8 +9,10 @@ export declare class ExchangeService {
     swapTokenToToken(swapData: SwapTokenToTokenDto): Promise<TxHashResponseDto>;
     getTokenToNativePrice(quoteData: SwapTokenToNativeDto): Promise<PriceResponseDto>;
     swapTokenToNative(swapData: SwapTokenToNativeDto): Promise<TxHashResponseDto>;
-    getSolanaQuote(inputMint: string, outputMint: string, amount: number): Promise<any>;
+    getSolanaToTokenQuote(quoteData: SwapSolToTokenDto): Promise<any>;
+    getTokenToSolanaQuote(quoteData: SwapTokenToSolDto): Promise<any>;
+    getTokenToTokenQuote(quoteData: SwapTokenToTokenDto): Promise<any>;
     swapSolToToken(swapData: SwapSolToTokenDto): Promise<SwapResponseDto>;
     swapTokenToTokenSolana(swapData: SwapTokenToTokenDto): Promise<SwapResponseDto>;
-    swapTokenToSol(swapData: SwapSolToTokenDto): Promise<SwapResponseDto>;
+    swapTokenToSol(swapData: SwapTokenToSolDto): Promise<SwapResponseDto>;
 }

package/dist/services/ExchangeService.js

@@ -25,10 +25,14 @@ class ExchangeService {
         return this.client.post('/api/v1/evm-exchange/token-to-native', swapData);
     }
     // Solana Exchange
-    async getSolanaQuote(inputMint, outputMint, amount) {
-        return this.client.get('/api/v1/solana-exchange/quote', {
-            params: { inputMint, outputMint, amount }
-        });
+    async getSolanaToTokenQuote(quoteData) {
+        return this.client.get('/api/v1/solana-exchange/quote/sol-to-token', { params: quoteData });
+    }
+    async getTokenToSolanaQuote(quoteData) {
+        return this.client.get('/api/v1/solana-exchange/quote/token-to-sol', { params: quoteData });
+    }
+    async getTokenToTokenQuote(quoteData) {
+        return this.client.get('/api/v1/solana-exchange/quote/token-to-token', { params: quoteData });
     }
     async swapSolToToken(swapData) {
         return this.client.post('/api/v1/solana-exchange/swap-sol-to-token', swapData);

package/dist/services/PaymentMethodService.d.ts

@@ -0,0 +1,12 @@
+import { MoneiClient } from "../client/MoneiClient";
+import { ResponseDto } from "../types";
+import { PaymentMethodDto, PaymentMethodResponseDto, PaymentMethodsResponseDto } from "../types/payment-method";
+export declare class PaymentMethodService {
+    private client;
+    constructor(client: MoneiClient);
+    getUserPaymentMethods(subWalletId: string): Promise<PaymentMethodsResponseDto>;
+    createPaymentMethod(paymentMethodData: PaymentMethodDto): Promise<PaymentMethodResponseDto>;
+    getPaymentMethodDetails(id: string): Promise<PaymentMethodResponseDto>;
+    deleteUserPaymentMethods(id: string): Promise<ResponseDto>;
+    setDefaultPaymentMethod(id: string): Promise<PaymentMethodResponseDto>;
+}

package/dist/services/PaymentMethodService.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMethodService = void 0;
+class PaymentMethodService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getUserPaymentMethods(subWalletId) {
+        return this.client.get('/api/v1/payment-methods', { params: { subWalletId } });
+    }
+    async createPaymentMethod(paymentMethodData) {
+        return this.client.post('/api/v1/payment-methods', paymentMethodData);
+    }
+    async getPaymentMethodDetails(id) {
+        return this.client.get(`/api/v1/payment-methods/${id}`);
+    }
+    async deleteUserPaymentMethods(id) {
+        return this.client.delete(`/api/v1/payment-methods/${id}`);
+    }
+    async setDefaultPaymentMethod(id) {
+        return this.client.patch(`/api/v1/payment-methods/${id}/default`);
+    }
+}
+exports.PaymentMethodService = PaymentMethodService;

package/dist/services/WalletService.d.ts

@@ -1,11 +1,8 @@
 import { MoneiClient } from '../client/MoneiClient';
-import { BalanceResponseDto, FundWalletByNairaDto, FundWalletByNairaResponseDto, UserWalletDto, BankListResponseDto, VerifyBankAccountRequestDto, BankAccountResponseDto, WithdrawWalletDto, PeerTransferDto, VerifyBvnDto, UserKycInfoDto } from '../types';
+import { FundWalletByNairaDto, FundWalletByNairaResponseDto, BankListResponseDto, VerifyBankAccountRequestDto, BankAccountResponseDto, WithdrawWalletDto, PeerTransferDto, VerifyBvnDto, UserKycInfoDto } from '../types';
 export declare class WalletService {
     private client;
     constructor(client: MoneiClient);
-    getWalletBalance(chainId?: number): Promise<UserWalletDto>;
-    getNativeBalance(chainId: number): Promise<BalanceResponseDto>;
-    getTokenBalance(tokenAddress: string, chainId: number): Promise<BalanceResponseDto>;
     fundWalletByNaira(fundData: FundWalletByNairaDto): Promise<FundWalletByNairaResponseDto>;
     getBanks(): Promise<BankListResponseDto>;
     verifyBankAccount(verifyData: VerifyBankAccountRequestDto): Promise<BankAccountResponseDto>;

package/dist/services/WalletService.js

@@ -5,20 +5,6 @@ class WalletService {
     constructor(client) {
         this.client = client;
     }
-    async getWalletBalance(chainId) {
-        const params = chainId ? { chainId } : undefined;
-        return this.client.get('/api/v1/wallet/me', { params });
-    }
-    async getNativeBalance(chainId) {
-        return this.client.get('/api/v1/evm/balance/native', {
-            params: { chainId }
-        });
-    }
-    async getTokenBalance(tokenAddress, chainId) {
-        return this.client.get('/api/v1/evm/balance/token', {
-            params: { tokenAddress, chainId }
-        });
-    }
     async fundWalletByNaira(fundData) {
         return this.client.post('/api/v1/wallet/user/fund-wallet', fundData);
     }

package/dist/services/index.d.ts

@@ -1,5 +1,7 @@
 export { UserService } from './UserService';
 export { WalletService } from './WalletService';
+export { WalletAccountService, DepositService, PayoutService, WalletUtilityService } from './wallet';
+export { PaymentMethodService } from './PaymentMethodService';
 export { EvmService } from './EvmService';
 export { SolanaService } from './SolanaService';
 export { TransactionService } from './TransactionService';

package/dist/services/index.js

@@ -1,10 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExchangeService = exports.BillService = exports.AgentService = exports.TransactionService = exports.SolanaService = exports.EvmService = exports.WalletService = exports.UserService = void 0;
+exports.ExchangeService = exports.BillService = exports.AgentService = exports.TransactionService = exports.SolanaService = exports.EvmService = exports.PaymentMethodService = exports.WalletUtilityService = exports.PayoutService = exports.DepositService = exports.WalletAccountService = exports.WalletService = exports.UserService = void 0;
 var UserService_1 = require("./UserService");
 Object.defineProperty(exports, "UserService", { enumerable: true, get: function () { return UserService_1.UserService; } });
 var WalletService_1 = require("./WalletService");
 Object.defineProperty(exports, "WalletService", { enumerable: true, get: function () { return WalletService_1.WalletService; } });
+var wallet_1 = require("./wallet");
+Object.defineProperty(exports, "WalletAccountService", { enumerable: true, get: function () { return wallet_1.WalletAccountService; } });
+Object.defineProperty(exports, "DepositService", { enumerable: true, get: function () { return wallet_1.DepositService; } });
+Object.defineProperty(exports, "PayoutService", { enumerable: true, get: function () { return wallet_1.PayoutService; } });
+Object.defineProperty(exports, "WalletUtilityService", { enumerable: true, get: function () { return wallet_1.WalletUtilityService; } });
+var PaymentMethodService_1 = require("./PaymentMethodService");
+Object.defineProperty(exports, "PaymentMethodService", { enumerable: true, get: function () { return PaymentMethodService_1.PaymentMethodService; } });
 var EvmService_1 = require("./EvmService");
 Object.defineProperty(exports, "EvmService", { enumerable: true, get: function () { return EvmService_1.EvmService; } });
 var SolanaService_1 = require("./SolanaService");

package/dist/services/wallet/WalletAccount.service.d.ts

@@ -0,0 +1,8 @@
+import { MoneiClient } from '../../client/MoneiClient';
+import { CreateVirtualAccountDataDto, UserWalletResponseDto, VirtualAccountResponseDto } from '../../types';
+export declare class WalletAccountService {
+    private client;
+    constructor(client: MoneiClient);
+    getWallet(chainId?: number): Promise<UserWalletResponseDto>;
+    createVirtualAccount(accountData: CreateVirtualAccountDataDto): Promise<VirtualAccountResponseDto>;
+}

package/dist/services/wallet/WalletAccount.service.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletAccountService = void 0;
+class WalletAccountService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getWallet(chainId) {
+        //const params = chainId ? { chainId } : undefined;
+        return this.client.get('/api/v1/wallet/me', { params: { chainId } });
+    }
+    async createVirtualAccount(accountData) {
+        return this.client.post('/api/v1/wallet/virtual-account', accountData);
+    }
+}
+exports.WalletAccountService = WalletAccountService;

package/dist/services/wallet/WalletUtility.service.d.ts

@@ -0,0 +1,8 @@
+import { MoneiClient } from '../../client/MoneiClient';
+import { BankAccountResponseDto, BankListResponseDto, VerifyBankAccountRequestDto } from '../../types';
+export declare class WalletUtilityService {
+    private client;
+    constructor(client: MoneiClient);
+    getBanks(): Promise<BankListResponseDto>;
+    verifyBankAccount(verifyData: VerifyBankAccountRequestDto): Promise<BankAccountResponseDto>;
+}

package/dist/services/wallet/WalletUtility.service.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletUtilityService = void 0;
+class WalletUtilityService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getBanks() {
+        return this.client.get('/api/v1/wallet/utils/banks');
+    }
+    async verifyBankAccount(verifyData) {
+        return this.client.post('/api/v1/wallet/utils/verify-bank-account', verifyData);
+    }
+}
+exports.WalletUtilityService = WalletUtilityService;

package/dist/services/wallet/deposit.service.d.ts

@@ -0,0 +1,13 @@
+import { MoneiClient } from '../../client/MoneiClient';
+import { DEPOSIT_METHOD } from '../../types/enums/deposit.enum';
+import { ResponseDto } from '../../types';
+import { CreatePaymentLinkDto, DepositAuthorizationDto, DepositResponseDto, DepositWithPaymentMethodDto, InitializeDepositDto, PaymentLinkResponseDto } from '../../types/deposit';
+export declare class DepositService {
+    private client;
+    constructor(client: MoneiClient);
+    initializeDeposit(method: DEPOSIT_METHOD, depositData: InitializeDepositDto): Promise<DepositResponseDto>;
+    depositWithPaymentMethod(depositData: DepositWithPaymentMethodDto): Promise<DepositResponseDto>;
+    authorizeDeposit(authorizeData: DepositAuthorizationDto): Promise<ResponseDto>;
+    generatePaymentLink(paymentData: CreatePaymentLinkDto): Promise<PaymentLinkResponseDto>;
+    getStatus(reference: string): Promise<ResponseDto>;
+}

package/dist/services/wallet/deposit.service.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepositService = void 0;
+class DepositService {
+    constructor(client) {
+        this.client = client;
+    }
+    async initializeDeposit(method, depositData) {
+        const { data } = await this.client.post('/api/v1/wallet/deposit', depositData, { params: { method }, });
+        return data;
+    }
+    async depositWithPaymentMethod(depositData) {
+        return this.client.post('/api/v1/wallet/deposit/payment-method', depositData);
+    }
+    async authorizeDeposit(authorizeData) {
+        return this.client.post('/api/v1/wallet/deposit/authorize', authorizeData);
+    }
+    async generatePaymentLink(paymentData) {
+        return this.client.post('/api/v1/wallet/deposit/payment-link', paymentData);
+    }
+    async getStatus(reference) {
+        return this.client.get(`/api/v1/wallet/deposit/status/${reference}`);
+    }
+}
+exports.DepositService = DepositService;

package/dist/services/wallet/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./WalletAccount.service";
+export * from "./deposit.service";
+export * from "./payout.service";
+export * from "./WalletUtility.service";

package/dist/services/wallet/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./WalletAccount.service"), exports);
+__exportStar(require("./deposit.service"), exports);
+__exportStar(require("./payout.service"), exports);
+__exportStar(require("./WalletUtility.service"), exports);

package/dist/services/wallet/payout.service.d.ts

@@ -0,0 +1,9 @@
+import { MoneiClient } from '../../client/MoneiClient';
+import { ResponseDto } from '../../types';
+import { BankTransferRequestDto, BankTransferResponseDto, PeerTransferDto } from '../../types/payout';
+export declare class PayoutService {
+    private client;
+    constructor(client: MoneiClient);
+    bankTransfer(data: BankTransferRequestDto): Promise<BankTransferResponseDto>;
+    peerTransfer(transferData: PeerTransferDto): Promise<ResponseDto>;
+}

package/dist/services/wallet/payout.service.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayoutService = void 0;
+class PayoutService {
+    constructor(client) {
+        this.client = client;
+    }
+    async bankTransfer(data) {
+        return this.client.post(`/api/v1/wallet/payout/bank-transfer`, data);
+    }
+    async peerTransfer(transferData) {
+        return this.client.post('/api/v1/wallet/payout/transfer', transferData);
+    }
+}
+exports.PayoutService = PayoutService;

package/dist/types/deposit.d.ts

@@ -0,0 +1,101 @@
+import { AuthAction, AuthType } from "./enums/deposit.enum";
+import { TransactionStatus } from "./enums/transaction.enum";
+import { CardDto, UssdDto } from "./wallet";
+export interface CreatePaymentLinkDto {
+    amount: number;
+    reference?: string;
+    currency?: string;
+    redirectUrl?: string;
+    customization?: Customization;
+    customer?: Customer;
+}
+interface Customization {
+    title?: string;
+}
+interface Customer {
+    email: string;
+    phoneNumber: string;
+    name: string;
+}
+interface NextAction {
+    type: AuthAction;
+    redirect_url?: {
+        url: string;
+    };
+    payment_instruction?: {
+        note: string;
+    };
+}
+export interface InitializeDepositDto {
+    amount: number;
+    reference?: string;
+    currency?: 'NGN';
+    narration?: string;
+    card?: CardDto;
+    ussd?: UssdDto;
+}
+export interface DepositResponseDataDto {
+    amount: number;
+    reference: string;
+    currency: string;
+    redirectUrl?: string;
+    customization?: Customization;
+    customer?: Customer;
+    narration: string;
+    accountNumber?: string;
+    bankName?: string;
+    accountName?: string;
+    expiry_datetime?: string;
+    note?: string;
+    status: TransactionStatus;
+    nextAction?: NextAction;
+}
+export interface DepositResponseDto {
+    statusCode: number;
+    message: string;
+    data: DepositResponseDataDto;
+    errors?: string;
+}
+export interface PaymentLinkResponseDto {
+    statusCode: number;
+    message: string;
+    data: LinkDto;
+    errors?: string;
+}
+export interface DepositWithPaymentMethodDto {
+    amount: number;
+    paymentMethodId: string;
+    reference: string;
+    currency: 'NGN';
+    redirectUrl: string;
+    meta: Record<string, any>;
+    narration: string;
+}
+export interface PaymentResponseDto {
+    statusCode: number;
+    message: string;
+    data: LinkDto;
+    errors?: string;
+}
+export interface LinkDto {
+    link: string;
+}
+export interface DepositAuthorizationDto {
+    type: AuthType;
+    reference: string;
+    pin: string;
+    otp: string;
+    avs: AvsDto;
+}
+export interface AvsDto {
+    address: AvsAddressDto;
+}
+export interface AvsAddressDto {
+    city: string;
+    country: string;
+    line1: string;
+    line2: string;
+    postal_code: string;
+    state: string;
+}
+export {};

package/dist/types/deposit.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/enums/deposit.enum.d.ts

@@ -0,0 +1,19 @@
+export declare enum DEPOSIT_METHOD {
+    BANK_TRANSFER = "BANK_TRANSFER",
+    USSD = "USSD",
+    CARD = "CARD"
+}
+export declare enum AuthAction {
+    PIN = "requires_pin",
+    OTP = "requires_otp",
+    REDIRECT_URL = "redirect_url",
+    ADDITIONAL_FIELDS = "requires_additional_fields",
+    PAYMENT_INSTRUCTIONS = "payment_Instructions"
+}
+export declare enum AuthType {
+    PIN = "pin",
+    OTP = "otp",
+    AVS = "avs",
+    REDIRECT_URL = "redirect_url",
+    PAYMENT_INSTRUCTION = "payment_instruction"
+}

package/dist/types/enums/deposit.enum.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthType = exports.AuthAction = exports.DEPOSIT_METHOD = void 0;
+var DEPOSIT_METHOD;
+(function (DEPOSIT_METHOD) {
+    DEPOSIT_METHOD["BANK_TRANSFER"] = "BANK_TRANSFER";
+    DEPOSIT_METHOD["USSD"] = "USSD";
+    DEPOSIT_METHOD["CARD"] = "CARD";
+})(DEPOSIT_METHOD || (exports.DEPOSIT_METHOD = DEPOSIT_METHOD = {}));
+var AuthAction;
+(function (AuthAction) {
+    AuthAction["PIN"] = "requires_pin";
+    AuthAction["OTP"] = "requires_otp";
+    AuthAction["REDIRECT_URL"] = "redirect_url";
+    AuthAction["ADDITIONAL_FIELDS"] = "requires_additional_fields";
+    AuthAction["PAYMENT_INSTRUCTIONS"] = "payment_Instructions";
+})(AuthAction || (exports.AuthAction = AuthAction = {}));
+var AuthType;
+(function (AuthType) {
+    AuthType["PIN"] = "pin";
+    AuthType["OTP"] = "otp";
+    AuthType["AVS"] = "avs";
+    AuthType["REDIRECT_URL"] = "redirect_url";
+    AuthType["PAYMENT_INSTRUCTION"] = "payment_instruction";
+})(AuthType || (exports.AuthType = AuthType = {}));

package/dist/types/enums/payment-method.d.ts

@@ -0,0 +1,7 @@
+export declare enum PaymentMethodType {
+    VIRTUAL_ACCOUNT = "VIRTUAL_ACCOUNT",
+    CARD = "CARD",
+    BANK_TRANSFER = "BANK_TRANSFER",
+    USSD = "USSD",
+    CRYPTO_WALLET = "CRYPTO_WALLET"
+}

package/dist/types/enums/payment-method.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMethodType = void 0;
+var PaymentMethodType;
+(function (PaymentMethodType) {
+    PaymentMethodType["VIRTUAL_ACCOUNT"] = "VIRTUAL_ACCOUNT";
+    PaymentMethodType["CARD"] = "CARD";
+    PaymentMethodType["BANK_TRANSFER"] = "BANK_TRANSFER";
+    PaymentMethodType["USSD"] = "USSD";
+    PaymentMethodType["CRYPTO_WALLET"] = "CRYPTO_WALLET";
+})(PaymentMethodType || (exports.PaymentMethodType = PaymentMethodType = {}));

package/dist/types/enums/transaction.enum.d.ts

@@ -0,0 +1,34 @@
+export declare enum TransactionType {
+    DEBIT = "DEBIT",
+    CREDIT = "CREDIT",
+    PEER_TRANSFER = "PEER-TRANSFER"
+}
+export declare enum TransactionStatus {
+    PENDING = "PENDING",
+    SUCCESS = "SUCCESS",
+    FAILED = "FAILED",
+    COMPLETED = "COMPLETED"
+}
+export declare enum TransactionOwnerType {
+    USER = "USER",
+    BUSINESS_CUSTOMER = "BUSINESS_CUSTOMER"
+}
+export declare enum TransactionNature {
+    FIAT_DEPOSIT = "FIAT_DEPOSIT",
+    FIAT_CARD_DEPOSIT = "FIAT_CARD_DEPOSIT",
+    FIAT_USSD_DEPOSIT = "FIAT_USSD_DEPOSIT",
+    FIAT_WITHDRAWAL = "FIAT_WITHDRAWAL",
+    FIAT_TRANSFER = "FIAT_TRANSFER",
+    FIAT_P2P = "FIAT_P2P",
+    CRYPTO_DEPOSIT = "CRYPTO_DEPOSIT",
+    CRYPTO_WITHDRAWAL = "CRYPTO_WITHDRAWAL",
+    CRYPTO_TRADE_BUY = "CRYPTO_TRADE_BUY",
+    CRYPTO_TRADE_SELL = "CRYPTO_TRADE_SELL",
+    CRYPTO_P2P = "CRYPTO_P2P",
+    CROSS_BORDER_IN = "CROSS_BORDER_IN",
+    CROSS_BORDER_OUT = "CROSS_BORDER_OUT",
+    FOREX_BUY = "FOREX_BUY",
+    FOREX_SELL = "FOREX_SELL",
+    BUY_TOKENIZED_STOCK = "BUY_TOKENIZED_STOCK",
+    SELL_TOKENIZED_STOCK = "SELL_TOKENIZED_STOCK"
+}

package/dist/types/enums/transaction.enum.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionNature = exports.TransactionOwnerType = exports.TransactionStatus = exports.TransactionType = void 0;
+var TransactionType;
+(function (TransactionType) {
+    TransactionType["DEBIT"] = "DEBIT";
+    TransactionType["CREDIT"] = "CREDIT";
+    TransactionType["PEER_TRANSFER"] = "PEER-TRANSFER";
+})(TransactionType || (exports.TransactionType = TransactionType = {}));
+var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["PENDING"] = "PENDING";
+    TransactionStatus["SUCCESS"] = "SUCCESS";
+    TransactionStatus["FAILED"] = "FAILED";
+    TransactionStatus["COMPLETED"] = "COMPLETED";
+})(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
+var TransactionOwnerType;
+(function (TransactionOwnerType) {
+    TransactionOwnerType["USER"] = "USER";
+    TransactionOwnerType["BUSINESS_CUSTOMER"] = "BUSINESS_CUSTOMER";
+})(TransactionOwnerType || (exports.TransactionOwnerType = TransactionOwnerType = {}));
+var TransactionNature;
+(function (TransactionNature) {
+    TransactionNature["FIAT_DEPOSIT"] = "FIAT_DEPOSIT";
+    TransactionNature["FIAT_CARD_DEPOSIT"] = "FIAT_CARD_DEPOSIT";
+    TransactionNature["FIAT_USSD_DEPOSIT"] = "FIAT_USSD_DEPOSIT";
+    TransactionNature["FIAT_WITHDRAWAL"] = "FIAT_WITHDRAWAL";
+    TransactionNature["FIAT_TRANSFER"] = "FIAT_TRANSFER";
+    TransactionNature["FIAT_P2P"] = "FIAT_P2P";
+    TransactionNature["CRYPTO_DEPOSIT"] = "CRYPTO_DEPOSIT";
+    TransactionNature["CRYPTO_WITHDRAWAL"] = "CRYPTO_WITHDRAWAL";
+    TransactionNature["CRYPTO_TRADE_BUY"] = "CRYPTO_TRADE_BUY";
+    TransactionNature["CRYPTO_TRADE_SELL"] = "CRYPTO_TRADE_SELL";
+    TransactionNature["CRYPTO_P2P"] = "CRYPTO_P2P";
+    TransactionNature["CROSS_BORDER_IN"] = "CROSS_BORDER_IN";
+    TransactionNature["CROSS_BORDER_OUT"] = "CROSS_BORDER_OUT";
+    TransactionNature["FOREX_BUY"] = "FOREX_BUY";
+    TransactionNature["FOREX_SELL"] = "FOREX_SELL";
+    TransactionNature["BUY_TOKENIZED_STOCK"] = "BUY_TOKENIZED_STOCK";
+    TransactionNature["SELL_TOKENIZED_STOCK"] = "SELL_TOKENIZED_STOCK";
+})(TransactionNature || (exports.TransactionNature = TransactionNature = {}));

package/dist/types/evm.d.ts

@@ -1,3 +1,15 @@
+export interface SupportedNetworkDto {
+    chainId: number;
+    name: string;
+    nativeToken: string;
+    blockExploreUrl: string;
+    isTestnet: boolean;
+}
+export interface SupportedNetworkResponseDto {
+    statusCode: number;
+    message: string;
+    data: SupportedNetworkDto[];
+}
 export interface UserTokenBalanceDto {
     contractAddress: string;
     name: string;

package/dist/types/exchange.d.ts

@@ -36,6 +36,10 @@ export interface SwapSolToTokenDto {
     amount: number;
     slippageBps?: number;
 }
+export interface SwapTokenToSolDto {
+    amount: string;
+    inputMint: string;
+}
 export interface SwapDto {
     signature: string;
     txUrl: string;

package/dist/types/payment-method.d.ts

@@ -0,0 +1,34 @@
+import { PaymentMethodType } from "./enums/payment-method";
+import { CardDto, UssdDto } from "./wallet";
+export interface PaymentMethodDto {
+    type: PaymentMethodType;
+    nickname?: string;
+    subWalletId: string;
+    card?: CardDto;
+    virtualAccountId?: string;
+    ussd?: UssdDto;
+}
+export interface PaymentMethodResponseDto {
+    statusCode: number;
+    message: string;
+    data: PaymentMethodDetailsDto;
+}
+export interface PaymentMethodsResponseDto {
+    statusCode: number;
+    message: string;
+    data: PaymentMethodDetailsDto[];
+}
+export interface PaymentMethodDetailsDto {
+    id: string;
+    type: PaymentMethodType;
+    status: string;
+    isDefault: boolean;
+    nickname?: string;
+    isEnabled: boolean;
+    lastUsedAt: string | null;
+    usageCount: number;
+    capability: {};
+    details: {};
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/types/payment-method.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/payout.d.ts

@@ -0,0 +1,27 @@
+import { TransactionStatus } from "./enums/transaction.enum";
+export interface BankTransferRequestDto {
+    amount: number;
+    bank: string;
+    accountNumber: string;
+    transactionPin: string;
+    reference?: string;
+    narration?: string;
+    meta?: any;
+}
+export interface BankTransferResponseDataDto {
+    reference: string;
+    status: TransactionStatus;
+    amount: number;
+}
+export interface BankTransferResponseDto {
+    statusCode: string;
+    message: string;
+    data: BankTransferResponseDataDto;
+    errors?: any;
+}
+export interface PeerTransferDto {
+    receiver: string;
+    amount: number;
+    transactionPin: string;
+    currency?: string;
+}

package/dist/types/payout.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/transaction.d.ts

@@ -1,9 +1,10 @@
+import { TransactionNature, TransactionStatus, TransactionType } from "./enums/transaction.enum";
 export interface TransactionResponseDto {
     id: string;
     userId: string;
     amount: number;
-    type: 'CREDIT' | 'DEBIT';
-    status: 'SUCCESS' | 'PENDING' | 'FAILED';
+    type: TransactionType;
+    status: TransactionStatus;
     reference: string;
     currency: string;
     narration: string;
@@ -23,15 +24,15 @@ export interface UserTransactionsResponseDto {
 export interface TransactionDto {
     id: string;
     amount: number;
-    type: 'CREDIT' | 'DEBIT';
-    status: 'SUCCESS' | 'PENDING' | 'FAILED';
-    currency: string;
+    type: TransactionType;
+    status: TransactionStatus;
+    currency?: string;
     reference: string;
-    fincraReference?: string;
     narration: string;
+    nature: TransactionNature;
     user: any;
     wallet: any;
-    subwallet: any;
+    subwallet?: any;
     metadata?: any;
     createdAt: string;
     updatedAt: string;

package/dist/types/wallet.d.ts

@@ -1,3 +1,37 @@
+export declare enum DepositMethodsEnum {
+    BANK_TRANSFER = "BANK_TRANSFER",
+    USSD = "USSD",
+    VirtualId = "VirtualId"
+}
+export interface WalletDepositResponseDto {
+    statusCode: string;
+    message: string;
+    data: WalletDepositDto;
+}
+export interface WalletDepositDto {
+    amount: string;
+    reference: string;
+    currency: 'NGN';
+    narration: string;
+    status: string;
+    nextAction: {};
+}
+export interface ResponseDto {
+    statusCode: number;
+    message: string;
+    data: any;
+    error?: any;
+}
+export interface CardDto {
+    expiryMonth: string;
+    expiryYear: string;
+    cardNumber: string;
+    cvv: string;
+    cardHolderName: string;
+}
+export interface UssdDto {
+    bankCode: string;
+}
 export interface BalanceDto {
     balance: string;
 }
@@ -50,16 +84,15 @@ export interface UserWalletDto {
     solPortfolio?: any;
     subwallets: SubWalletDto[];
 }
+export interface UserWalletResponseDto {
+    statusCode: number;
+    message: string;
+    data: UserWalletDto;
+}
 export interface BankDto {
-    swiftCode?: string;
-    bic?: string;
-    isMobileVerified?: boolean;
-    isCashPickUp: boolean;
-    nibssCode: string;
     id: string;
     code: string;
     name: string;
-    branches: any[];
 }
 export interface BankListResponseDto {
     statusCode: number;
@@ -126,4 +159,105 @@ export interface WalletResponseDto {
     message: string;
     data: WithdrawDto;
 }
+export interface WalletOverviewDto {
+    nairaBalance: string;
+    subwallets: SubwalletDto[];
+}
+export interface SubwalletDto {
+    id: string;
+    type: 'CRYPTO' | 'FIAT';
+    virtualAccount: string | null;
+    currency: string;
+    balance: number;
+    chain: 'SOLANA' | 'EVM' | null;
+    publicAddress: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedDate: string | null;
+    solPortfolio?: SolPortfolioDto;
+    evmPortfolio?: EvmPortfolioDto;
+}
+export interface SolPortfolioDto {
+    userId: string;
+    address: string;
+    nativeBalance: string;
+    nativeBalanceLamports: string;
+    tokens: SolTokenDto[];
+}
+export interface SolTokenDto {
+    mintAddress: string;
+    name: string;
+    symbol: string;
+    balance: number;
+    rawBalance: string;
+    decimals: number;
+}
+export interface EvmPortfolioDto {
+    userId: string;
+    walletAddress: string;
+    network: string;
+    totalPortfolioValueUSD: string;
+    nativeToken: EvmNativeTokenDto;
+    tokens: EvmTokenDto[];
+    updatedAt: string;
+}
+export interface EvmNativeTokenDto {
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoUrl: string;
+    balance: string;
+    balanceUSD: string;
+    priceUSD: string;
+    rawBalance: string;
+    network: string;
+    type: 'native';
+}
+export interface EvmTokenDto {
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoUrl?: string;
+    balance: string;
+    balanceUSD: string;
+    priceUSD: string;
+    rawBalance: string;
+    contractAddress: string;
+    network: string;
+    type: 'erc20';
+}
+export interface CreateVirtualAccountDataDto {
+    nin: string;
+    reference?: string;
+}
+export interface VirtualAccountResponseDto {
+    statusCode: number;
+    message: string;
+    data: VirtualAccountDto;
+}
+export interface VirtualAccountDto {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    deletedDate: string | null;
+    accountNumber: string;
+    bankName: string;
+    reference: string;
+    status: string;
+    isActive: boolean;
+}
+export interface virtualSubWalletDto {
+    id: string;
+    type: 'CRYPTO' | 'FIAT';
+    currency: string;
+    balance: number;
+    chain: 'EVM' | 'SOLANA' | null;
+    publicAddress: string | null;
+}
+export interface TransferDto {
+    receiver: string;
+    amount: number;
+    transactionPin: string;
+    currency: string;
+}
 export {};

package/dist/types/wallet.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepositMethodsEnum = void 0;
+var DepositMethodsEnum;
+(function (DepositMethodsEnum) {
+    DepositMethodsEnum["BANK_TRANSFER"] = "BANK_TRANSFER";
+    DepositMethodsEnum["USSD"] = "USSD";
+    DepositMethodsEnum["VirtualId"] = "VirtualId";
+})(DepositMethodsEnum || (exports.DepositMethodsEnum = DepositMethodsEnum = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monei-sdk",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Node.js SDK for Monei API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",