@bbuilders/djeon402-sdk-client 1.0.1

package/dist/vue/index.d.ts

@@ -0,0 +1,346 @@
+import { TransferResult, BalanceResult, RolesResult, RoleCheckResult, KYCData, TokenInfo, AllowanceResult, TransferAuthorizationSignature, ReceiveAuthorizationSignature, CancelAuthorizationResult, ClientSDKConfig } from '@bbuilders/djeon402-core';
+import { WalletClient, Address, Hex, PublicClient, Chain } from 'viem';
+import { Ref } from 'vue';
+
+declare function useApprove(walletClient: Ref<WalletClient | undefined>): {
+    approve: (spender: Address, amount: string) => Promise<TransferResult>;
+    data: Ref<TransferResult | null, TransferResult | null>;
+    error: Ref<Error | null, Error | null>;
+    isLoading: Ref<boolean, boolean>;
+};
+
+declare function useBalance(address: Ref<Address | undefined>): {
+    data: Ref<BalanceResult | null, BalanceResult | null>;
+    error: Ref<Error | null, Error | null>;
+    isLoading: Ref<boolean, boolean>;
+    refetch: () => Promise<void>;
+};
+
+declare class AdminModule {
+    private sdk;
+    constructor(sdk: Djeon402ClientSDK);
+    /**
+     * Get role hashes
+     */
+    getRoles(): Promise<RolesResult>;
+    /**
+     * Check if address has role
+     */
+    hasRole(role: Hex, account: Address): Promise<RoleCheckResult>;
+    /**
+     * Check if address is blacklisted
+     */
+    isBlacklisted(account: Address): Promise<{
+        isBlacklisted: boolean;
+        address: Address;
+    }>;
+    /**
+     * Blacklist an address
+     */
+    blacklist(params: {
+        walletClient: WalletClient;
+        account: Address;
+    }): Promise<TransferResult>;
+    /**
+     * Remove from blacklist
+     */
+    unBlacklist(params: {
+        walletClient: WalletClient;
+        account: Address;
+    }): Promise<TransferResult>;
+    /**
+     * Pause contract
+     */
+    pause(params: {
+        walletClient: WalletClient;
+    }): Promise<TransferResult>;
+    /**
+     * Unpause contract
+     */
+    unpause(params: {
+        walletClient: WalletClient;
+    }): Promise<TransferResult>;
+}
+
+declare class KYCModule {
+    private sdk;
+    constructor(sdk: Djeon402ClientSDK);
+    /**
+     * Get KYC data for an address
+     */
+    getData(address: Address): Promise<KYCData>;
+    /**
+     * Get remaining daily limit
+     */
+    getRemainingLimit(address: Address): Promise<{
+        address: `0x${string}`;
+        remainingLimit: string;
+    }>;
+    /**
+     * Verify KYC (admin only)
+     */
+    verify(params: {
+        walletClient: WalletClient;
+        userAddress: Address;
+        level: number;
+        expiryDate: number;
+        documentHash: string;
+    }): Promise<TransferResult>;
+    /**
+     * Update KYC level (admin only)
+     */
+    updateKYC(params: {
+        walletClient: WalletClient;
+        userAddress: Address;
+        level: number;
+        expiryDate?: number;
+    }): Promise<TransferResult>;
+    /**
+     * Revoke KYC (admin only)
+     */
+    revokeKYC(params: {
+        walletClient: WalletClient;
+        userAddress: Address;
+    }): Promise<TransferResult>;
+    /**
+     * Set daily limit for a user (admin only)
+     */
+    setDailyLimit(params: {
+        walletClient: WalletClient;
+        userAddress: Address;
+        limitUSD: string;
+    }): Promise<TransferResult>;
+    /**
+     * Check if a transaction amount is within the user's daily limit
+     */
+    checkDailyLimit(params: {
+        walletClient: WalletClient;
+        userAddress: Address;
+        amountUSD: string;
+    }): Promise<boolean>;
+    /**
+     * Check if a user's KYC is valid (view)
+     */
+    isKYCValid(userAddress: Address): Promise<boolean>;
+}
+
+declare class TokenModule {
+    private sdk;
+    constructor(sdk: Djeon402ClientSDK);
+    /**
+     * Get token information
+     */
+    getInfo(): Promise<TokenInfo>;
+    /**
+     * Get balance of an address
+     */
+    getBalance(address: Address): Promise<BalanceResult>;
+    /**
+     * Get allowance
+     */
+    getAllowance(owner: Address, spender: Address): Promise<AllowanceResult>;
+    /**
+     * Transfer tokens using wallet client
+     */
+    transfer(params: {
+        walletClient: WalletClient;
+        to: Address;
+        amount: string;
+    }): Promise<TransferResult>;
+    /**
+     * Approve spending
+     */
+    approve(params: {
+        walletClient: WalletClient;
+        spender: Address;
+        amount: string;
+    }): Promise<TransferResult>;
+    /**
+     * Mint tokens (requires MINTER_ROLE)
+     */
+    mint(params: {
+        walletClient: WalletClient;
+        to: Address;
+        amount: string;
+    }): Promise<TransferResult>;
+    /**
+     * Burn tokens (requires BURNER_ROLE)
+     */
+    burn(params: {
+        walletClient: WalletClient;
+        amount: string;
+    }): Promise<TransferResult>;
+}
+
+declare class X402Module {
+    private sdk;
+    constructor(sdk: Djeon402ClientSDK);
+    /**
+     * Generate a random nonce
+     */
+    generateNonce(): Hex;
+    /**
+     * Get EIP-712 domain separator
+     */
+    getDomainSeparator(): Promise<Hex>;
+    /**
+     * Get authorization state (whether a nonce has been used)
+     */
+    getAuthorizationState(authorizer: Address, nonce: Hex): Promise<boolean>;
+    /**
+     * Sign transfer authorization using wallet
+     */
+    signTransferWithWallet(params: {
+        walletClient: WalletClient;
+        to: Address;
+        amount: string;
+        validAfter?: bigint;
+        validBefore?: bigint;
+        nonce?: Hex;
+    }): Promise<TransferAuthorizationSignature>;
+    /**
+     * Sign receive authorization using wallet (receiver signs)
+     */
+    signReceiveWithWallet(params: {
+        walletClient: WalletClient;
+        from: Address;
+        amount: string;
+        validAfter?: bigint;
+        validBefore?: bigint;
+        nonce?: Hex;
+    }): Promise<ReceiveAuthorizationSignature>;
+    /**
+     * Execute receive with authorization (caller must be the receiver)
+     */
+    executeReceive(params: {
+        walletClient: WalletClient;
+        authorization: ReceiveAuthorizationSignature;
+    }): Promise<TransferResult>;
+    /**
+     * Sign cancel authorization using wallet
+     */
+    signCancelWithWallet(params: {
+        walletClient: WalletClient;
+        authorizer: Address;
+        nonce: Hex;
+    }): Promise<{
+        authorizer: Address;
+        nonce: Hex;
+        v: number;
+        r: Hex;
+        s: Hex;
+    }>;
+    /**
+     * Cancel an authorization (marks nonce as used)
+     */
+    cancelAuthorization(params: {
+        walletClient: WalletClient;
+        authorizer: Address;
+        nonce: Hex;
+    }): Promise<CancelAuthorizationResult>;
+    /**
+     * Execute transfer with authorization (relayer function)
+     */
+    executeTransfer(params: {
+        walletClient: WalletClient;
+        authorization: TransferAuthorizationSignature;
+    }): Promise<TransferResult>;
+    /**
+     * Fetch wrapper that auto-handles 402 Payment Required responses.
+     * On 402, decodes PAYMENT-REQUIRED header, signs authorization, retries with PAYMENT-SIGNATURE.
+     */
+    fetchWithPayment(walletClient: WalletClient, url: string, options?: RequestInit): Promise<Response>;
+}
+
+/**
+ * DJEON402 Client SDK for browsers
+ * Works with wallet providers (MetaMask, WalletConnect, etc.)
+ */
+declare class Djeon402ClientSDK {
+    readonly publicClient: PublicClient;
+    readonly contractAddress: Address;
+    readonly kycRegistryAddress?: Address;
+    readonly chainId: number;
+    readonly token: TokenModule;
+    readonly admin: AdminModule;
+    readonly kyc: KYCModule;
+    readonly x402: X402Module;
+    constructor(config: ClientSDKConfig);
+    /**
+     * Get chain configuration
+     */
+    getChain(): Chain;
+}
+
+interface Djeon402Config {
+    contractAddress: Address;
+    kycRegistryAddress?: Address;
+    chainId: number;
+    rpcUrl?: string;
+}
+interface Djeon402Context {
+    sdk: Djeon402ClientSDK;
+    config: Readonly<Djeon402Config>;
+}
+declare function provideDjeon402(config: Djeon402Config): Djeon402Context;
+declare function useDjeon402(): Djeon402Context;
+
+declare function useIsBlacklisted(address: Ref<Address | undefined>): {
+    data: Ref<{
+        isBlacklisted: boolean;
+        address: Address;
+    } | null, {
+        isBlacklisted: boolean;
+        address: Address;
+    } | null>;
+    error: Ref<Error | null, Error | null>;
+    isLoading: Ref<boolean, boolean>;
+    refetch: () => Promise<void>;
+};
+
+declare function useKYCData(address: Ref<Address | undefined>): {
+    data: Ref<KYCData | null, KYCData | null>;
+    error: Ref<Error | null, Error | null>;
+    isLoading: Ref<boolean, boolean>;
+    refetch: () => Promise<void>;
+};
+
+declare function useTokenInfo(): {
+    data: Ref<TokenInfo | null, TokenInfo | null>;
+    error: Ref<Error | null, Error | null>;
+    isLoading: Ref<boolean, boolean>;
+    refetch: () => Promise<void>;
+};
+
+declare function useTransfer(walletClient: Ref<WalletClient | undefined>): {
+    transfer: (to: Address, amount: string) => Promise<TransferResult>;
+    data: Ref<TransferResult | null, TransferResult | null>;
+    error: Ref<Error | null, Error | null>;
+    isLoading: Ref<boolean, boolean>;
+};
+
+declare function useX402Receive(walletClient: Ref<WalletClient | undefined>): {
+    signReceive: (params: {
+        from: Address;
+        amount: string;
+        validAfter?: bigint;
+        validBefore?: bigint;
+    }) => Promise<ReceiveAuthorizationSignature>;
+    authorization: Ref<ReceiveAuthorizationSignature | null, ReceiveAuthorizationSignature | null>;
+    error: Ref<Error | null, Error | null>;
+    isLoading: Ref<boolean, boolean>;
+};
+
+declare function useX402Transfer(walletClient: Ref<WalletClient | undefined>): {
+    signTransfer: (params: {
+        to: Address;
+        amount: string;
+        validAfter?: bigint;
+        validBefore?: bigint;
+    }) => Promise<TransferAuthorizationSignature>;
+    authorization: Ref<TransferAuthorizationSignature | null, TransferAuthorizationSignature | null>;
+    error: Ref<Error | null, Error | null>;
+    isLoading: Ref<boolean, boolean>;
+};
+
+export { provideDjeon402, useApprove, useBalance, useDjeon402, useIsBlacklisted, useKYCData, useTokenInfo, useTransfer, useX402Receive, useX402Transfer };