@hashgraphonline/hashinal-wc 2.0.62 → 2.0.63

package/dist/umd/index.d.ts

@@ -0,0 +1,161 @@
+import { SessionTypes, SignClientTypes } from '@walletconnect/types';
+import { Transaction, AccountId, ContractId, LedgerId, TransactionReceipt, ContractFunctionParameters, PrivateKey } from '@hashgraph/sdk';
+import { AppKit } from '@reown/appkit';
+import { DAppConnector } from '@hashgraph/hedera-wallet-connect';
+import { FetchMessagesResult, TokenBalance, HederaAccountResponse, HederaTXResponse, Nft } from './types';
+import { Logger } from './logger';
+import * as HashgraphSDK from '@hashgraph/sdk';
+/**
+ * Detect if current device is mobile
+ */
+declare function isMobileDevice(): boolean;
+/**
+ * Detect if device is iOS
+ */
+declare function isIOSDevice(): boolean;
+/**
+ * Detect if device is Android
+ */
+declare function isAndroidDevice(): boolean;
+/**
+ * Get the appropriate app store URL for the current platform
+ */
+declare function getHashPackStoreUrl(): string;
+/**
+ * Open HashPack app on mobile device.
+ * Used primarily for sign requests after a connection is already established.
+ *
+ * Uses a hidden anchor element to trigger the deep link without navigating
+ * away from the current page. This ensures users can return to the dApp
+ * after signing in the wallet.
+ *
+ * @param wcUri - Optional WalletConnect URI to pass to HashPack
+ */
+declare function openHashPackOnMobile(wcUri?: string): Promise<void>;
+/**
+ * Check if there's a saved return URL from a wallet connection attempt.
+ * If found, returns the URL and clears it from storage.
+ *
+ * dApps should call this on page load and redirect if a URL is returned.
+ */
+declare function checkWalletReturnUrl(): string | null;
+declare class HashinalsWalletConnectSDK {
+    private static instance;
+    private static dAppConnectorInstance;
+    private static proxyInstance;
+    private logger;
+    private network;
+    private reownAppKit;
+    private reownAppKitKey;
+    private extensionCheckInterval;
+    private hasCalledExtensionCallback;
+    private useAppKit;
+    get dAppConnector(): DAppConnector;
+    constructor(logger?: Logger, network?: LedgerId);
+    static getInstance(logger?: Logger, network?: LedgerId): HashinalsWalletConnectSDK;
+    setLogger(logger: Logger): void;
+    setNetwork(network: LedgerId): void;
+    getNetwork(): LedgerId;
+    setReownAppKit(appKit: AppKit | null): void;
+    private ensureReownAppKit;
+    setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
+    init(projectId: string, metadata: SignClientTypes.Metadata, network?: LedgerId, onSessionIframeCreated?: (session: SessionTypes.Struct) => void, options?: {
+        useAppKit?: boolean;
+    }): Promise<DAppConnector>;
+    connect(options?: {
+        pairingTopic?: string;
+        onUri?: (uri: string) => void;
+    }): Promise<SessionTypes.Struct>;
+    private connectUsingReownAppKit;
+    disconnect(): Promise<boolean>;
+    disconnectAll(): Promise<boolean>;
+    /**
+     * Triggers the browser extension popup for signing on desktop.
+     * This is needed when the signer doesn't have an extensionId set
+     * (e.g., when connecting via the Reown AppKit modal).
+     */
+    private triggerExtensionPopupIfNeeded;
+    /**
+     * Gets the available desktop browser extension (e.g., HashPack).
+     * Returns undefined if no extension is available or on mobile devices.
+     */
+    private getAvailableDesktopExtension;
+    executeTransaction(tx: Transaction, disableSigner?: boolean): Promise<TransactionReceipt>;
+    executeTransactionWithErrorHandling(tx: Transaction, disableSigner: boolean): Promise<{
+        result?: TransactionReceipt;
+        error?: string;
+    }>;
+    submitMessageToTopic(topicId: string, message: string, submitKey?: PrivateKey): Promise<TransactionReceipt>;
+    transferHbar(fromAccountId: string, toAccountId: string, amount: number): Promise<TransactionReceipt>;
+    executeSmartContract(contractId: string, functionName: string, parameters: ContractFunctionParameters, gas?: number): Promise<TransactionReceipt>;
+    private handleNewSession;
+    private getNetworkPrefix;
+    requestAccount(account: string): Promise<HederaAccountResponse>;
+    getAccountBalance(): Promise<string>;
+    getAccountInfo(): {
+        accountId: string;
+        network: LedgerId;
+    };
+    createTopic(memo?: string, adminKey?: string, submitKey?: string): Promise<string>;
+    createToken(name: string, symbol: string, initialSupply: number, decimals: number, treasuryAccountId: string, adminKey: string, supplyKey: string): Promise<string>;
+    mintNFT(tokenId: string, metadata: string, supplyKey: PrivateKey): Promise<TransactionReceipt>;
+    getMessages(topicId: string, lastTimestamp?: number, disableTimestampFilter?: boolean, network?: string): Promise<FetchMessagesResult>;
+    /**
+     * Sign a message with the connected wallet.
+     * On mobile devices, this will automatically open the HashPack app
+     * to prompt the user to sign the message.
+     *
+     * @param message - The message to sign
+     * @param options - Optional configuration for signing
+     * @param options.openWalletOnMobile - Whether to open the wallet app on mobile (default: true)
+     * @param options.onMobileRedirect - Callback before redirecting to wallet on mobile
+     */
+    signMessage(message: string, options?: {
+        openWalletOnMobile?: boolean;
+        onMobileRedirect?: () => void;
+    }): Promise<{
+        userSignature: string;
+    }>;
+    private saveConnectionInfo;
+    loadConnectionInfo(): {
+        accountId: string | null;
+        network: string | null;
+    };
+    connectWallet(PROJECT_ID: string, APP_METADATA: SignClientTypes.Metadata, network?: LedgerId, options?: {
+        onUri?: (uri: string) => void;
+        useAppKit?: boolean;
+    }): Promise<{
+        accountId: string;
+        balance: string;
+        session: SessionTypes.Struct;
+    }>;
+    disconnectWallet(clearStorage?: boolean): Promise<boolean>;
+    initAccount(PROJECT_ID: string, APP_METADATA: SignClientTypes.Metadata, networkOverride?: LedgerId, onSessionIframeCreated?: (session: SessionTypes.Struct) => void, options?: {
+        useAppKit?: boolean;
+    }): Promise<{
+        accountId: string;
+        balance: string;
+    } | null>;
+    subscribeToExtensions(callback: (extension: any) => void): () => void;
+    connectViaDappBrowser(): Promise<void>;
+    private connectToExtension;
+    private ensureInitialized;
+    static run(): void;
+    transferToken(tokenId: string, fromAccountId: string, toAccountId: string, amount: number): Promise<TransactionReceipt>;
+    createAccount(initialBalance: number): Promise<TransactionReceipt>;
+    associateTokenToAccount(accountId: string, tokenId: string): Promise<TransactionReceipt>;
+    dissociateTokenFromAccount(accountId: string, tokenId: string): Promise<TransactionReceipt>;
+    updateAccount(accountId: string, maxAutomaticTokenAssociations: number): Promise<TransactionReceipt>;
+    approveAllowance(spenderAccountId: string, tokenId: string, amount: number, ownerAccountId: string): Promise<TransactionReceipt>;
+    getAccountTokens(accountId: string): Promise<{
+        tokens: TokenBalance[];
+    }>;
+    getTransaction(transactionId: string): Promise<HederaTXResponse | null>;
+    getTransactionByTimestamp(timestamp: string): Promise<HederaTXResponse | null>;
+    getAccountNFTs(accountId: string, tokenId?: string): Promise<Nft[]>;
+    validateNFTOwnership(serialNumber: string, accountId: string, tokenId: string): Promise<Nft | null>;
+    readSmartContract(data: string, fromAccount: AccountId, contractId: ContractId, estimate?: boolean, value?: number): Promise<any>;
+}
+export * from './types';
+export * from './sign';
+export { HashinalsWalletConnectSDK, HashgraphSDK, isMobileDevice, isIOSDevice, isAndroidDevice, openHashPackOnMobile, getHashPackStoreUrl, checkWalletReturnUrl, };

package/dist/umd/logger.d.ts

@@ -0,0 +1,10 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export declare class Logger {
+    private level;
+    setLogLevel(level: LogLevel): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    warn(message: unknown, ...optionalParams: unknown[]): void;
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    debug(message: unknown, ...optionalParams: unknown[]): void;
+    private shouldLog;
+}

package/dist/umd/sign/index.d.ts

@@ -0,0 +1 @@
+export { base64StringToSignatureMap, prefixMessageToSign, verifyMessageSignature, } from '@hashgraph/hedera-wallet-connect';

package/dist/umd/types.d.ts

@@ -0,0 +1,254 @@
+import { DAppConnector } from '@hashgraph/hedera-wallet-connect';
+import { ContractFunctionParameters, TransactionReceipt, PrivateKey, Transaction, AccountId, ContractId } from '@hashgraph/sdk';
+import { SessionTypes, SignClientTypes } from '@walletconnect/types';
+import * as hashgraph from '@hashgraph/sdk';
+export interface HederaAccountResponse {
+    account: string;
+    alias: null;
+    auto_renew_period: number;
+    balance: Balance;
+    created_timestamp: string;
+    decline_reward: boolean;
+    deleted: boolean;
+    ethereum_nonce: number;
+    evm_address: string;
+    expiry_timestamp: string;
+    key: Key;
+    max_automatic_token_associations: number;
+    memo: string;
+    pending_reward: number;
+    receiver_sig_required: boolean;
+    staked_account_id: null;
+    staked_node_id: number;
+    stake_period_start: string;
+    transactions: HBARTransaction[];
+    links: Links;
+}
+export interface Balance {
+    balance: number;
+    timestamp: string;
+    tokens: Token[];
+}
+export interface Token {
+    token_id: string;
+    balance: number;
+}
+export interface Key {
+    _type: string;
+    key: string;
+}
+export interface Links {
+    next: string;
+}
+export interface HBARTransaction {
+    bytes: null;
+    charged_tx_fee: number;
+    consensus_timestamp: string;
+    entity_id: null | string;
+    max_fee: string;
+    memo_base64: string;
+    name: Name;
+    nft_transfers: NftTransfer[];
+    node: string;
+    nonce: number;
+    parent_consensus_timestamp: null;
+    result: Result;
+    scheduled: boolean;
+    staking_reward_transfers: StakingRewardTransfer[];
+    token_transfers: Transfer[];
+    transaction_hash: string;
+    transaction_id: string;
+    transfers: Transfer[];
+    valid_duration_seconds: string;
+    valid_start_timestamp: string;
+}
+export declare enum Name {
+    Contractcall = "CONTRACTCALL",
+    Cryptotransfer = "CRYPTOTRANSFER"
+}
+export interface NftTransfer {
+    is_approval: boolean;
+    receiver_account_id: string;
+    sender_account_id: string;
+    serial_number: number;
+    token_id: string;
+}
+export declare enum Result {
+    Success = "SUCCESS"
+}
+export interface StakingRewardTransfer {
+    account: string;
+    amount: number;
+}
+export interface Transfer {
+    token_id?: string;
+    account: string;
+    amount: number;
+    is_approval: boolean;
+}
+export interface Message {
+    payer: string;
+    created: Date;
+    consensus_timestamp: string;
+    sequence_number: number;
+    [key: string]: any;
+}
+export interface FetchMessagesResult {
+    messages: Message[];
+    error?: string;
+}
+export interface Account {
+    account: string;
+    alias: null;
+    auto_renew_period: number;
+    balance: Balance;
+    decline_reward: boolean;
+    deleted: boolean;
+    ethereum_nonce: null;
+    evm_address: null;
+    expiry_timestamp: string;
+    key: Key;
+    max_automatic_token_associations: number;
+    memo: string;
+    receiver_sig_required: null;
+    staked_account_id: null;
+    staked_node_id: null;
+    stake_period_start: null;
+}
+export interface Balance {
+    balance: number;
+    timestamp: string;
+    tokens: Token[];
+}
+export interface Token {
+    token_id: string;
+    balance: number;
+}
+export interface Key {
+    _type: string;
+    key: string;
+}
+export interface TokenBalance {
+    tokenId: string;
+    balance: string;
+    decimals: number;
+    created_timestamp: Date;
+    formatted_balance: string;
+}
+export interface HederaTXResponse {
+    transactions: MirrorNodeTransaction[];
+}
+export interface MirrorNodeTransaction {
+    bytes: null;
+    charged_tx_fee: number;
+    consensus_timestamp: string;
+    entity_id: string;
+    max_fee: string;
+    memo_base64: string;
+    name: string;
+    node: null | string;
+    nonce: number;
+    parent_consensus_timestamp: null | string;
+    result: string;
+    scheduled: boolean;
+    transaction_hash: string;
+    transaction_id: string;
+    transfers: Transfer[];
+    token_transfers: TokenTransfer[];
+    valid_duration_seconds: null | string;
+    valid_start_timestamp: string;
+    nft_transfers?: NftTransfer[];
+}
+export interface NftTransfer {
+    is_approval: boolean;
+    receiver_account_id: string;
+    sender_account_id: string;
+    serial_number: number;
+    token_id: string;
+}
+export interface TokenTransfer {
+    token_id: string;
+    account: string;
+    amount: number;
+}
+export interface HBarNFT {
+    nfts: Nft[];
+    links: Links;
+}
+export interface Links {
+    next: string;
+}
+export interface Nft {
+    account_id: string;
+    created_timestamp: string;
+    delegating_spender: null;
+    deleted: boolean;
+    metadata: string;
+    modified_timestamp: string;
+    serial_number: number;
+    spender: null;
+    token_id: string;
+    token_uri?: string;
+    owner_of?: string;
+}
+export interface FormattedOwner {
+    token_uri?: string;
+    chain?: string;
+    owner_of?: string;
+    token_address?: string;
+    token_id?: string;
+    account_id?: string;
+    serial_number?: number;
+    [key: string]: any;
+}
+export type HashinalsWalletConnectSDK = {
+    run: () => void;
+    init: (projectId: string, metadata: SignClientTypes.Metadata) => Promise<DAppConnector>;
+    connect: () => Promise<SessionTypes.Struct>;
+    connectWallet(PROJECT_ID: string, APP_METADATA: SignClientTypes.Metadata): Promise<{
+        accountId: string;
+        balance: string;
+        session: SessionTypes.Struct;
+    }>;
+    disconnect: () => Promise<boolean>;
+    disconnectAll: () => Promise<boolean>;
+    disconnectWallet: () => Promise<boolean>;
+    loadConnectionInfo: () => string | null;
+    saveConnectionInfo: (accountId: string) => void;
+    executeTransaction: (tx: Transaction, disableSigner: boolean) => Promise<TransactionReceipt>;
+    executeTransationWithErrorHandling: (tx: Transaction, disableSigner: boolean) => Promise<{
+        result?: TransactionReceipt;
+        error?: string;
+    }>;
+    result?: TransactionReceipt;
+    error?: string;
+    submitMessageToTopic: (topicId: string, message: string) => Promise<TransactionReceipt>;
+    transferHbar: (fromAccountId: string, toAccountId: string, amount: number) => Promise<TransactionReceipt>;
+    executeSmartContract: (contractId: string, functionName: string, parameters: ContractFunctionParameters, gas?: number) => Promise<TransactionReceipt>;
+    getAccountBalance: () => Promise<string>;
+    getAccountInfo: () => string;
+    createTopic: (memo?: string, adminKey?: string, submitKey?: string) => Promise<string>;
+    createToken: (name: string, symbol: string, initialSupply: number, decimals: number, treasuryAccountId: string, adminKey: string, supplyKey: string) => Promise<string>;
+    mintNFT: (tokenId: string, metadata: string, supplyKey: PrivateKey) => Promise<TransactionReceipt>;
+    dAppConnector?: DAppConnector;
+    getMessages: (topicId: string, lastTimestamp?: number, disableTimestampFilter?: boolean) => Promise<FetchMessagesResult>;
+    initAccount: (PROJECT_ID: string, APP_METADATA: SignClientTypes.Metadata) => Promise<{
+        accountId: string;
+        balance: string;
+    } | null>;
+    transferToken: (tokenId: string, fromAccountId: string, toAccountId: string, amount: number) => Promise<TransactionReceipt>;
+    createAccount: (initialBalance: number) => Promise<TransactionReceipt>;
+    associateTokenToAccount: (accountId: string, tokenId: string) => Promise<TransactionReceipt>;
+    dissociateTokenFromAccount: (accountId: string, tokenId: string) => Promise<TransactionReceipt>;
+    updateAccount: (accountId: string, maxAutomaticTokenAssociations: number) => Promise<TransactionReceipt>;
+    approveAllowance: (spenderAccountId: string, tokenId: string, amount: number, ownerAccountId: string) => Promise<TransactionReceipt>;
+    getAccountTokens: (accountId: string) => Promise<{
+        tokens: TokenBalance[];
+    }>;
+    getTransaction: (transactionId: string) => Promise<HederaTXResponse | null>;
+    getTransactionByTimestamp: (timestamp: string) => Promise<HederaTXResponse | null>;
+    getAccountNFTs: (accountId: string, tokenId?: string) => Promise<Nft[]>;
+    validateNFTOwnership: (serialNumber: string, accountId: string, tokenId: string) => Promise<Nft | null>;
+    readSmartContract: (data: string, fromAccount: AccountId, contractId: ContractId, estimate?: boolean, value?: number) => Promise<any>;
+    HashgraphSDK: typeof hashgraph;
+};

package/dist/umd/utils/retry.d.ts

@@ -0,0 +1 @@
+export declare const fetchWithRetry: () => (input: string | Request | URL, init?: import('fetch-retry').RequestInitWithRetry<typeof fetch>) => Promise<Response>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraphonline/hashinal-wc",
-  "version": "2.0.62",
+  "version": "2.0.63",
   "description": "The official Hashinal Wallet Connect SDK. A set of easy-to-use functions to interact with Hedera through Wallet Connect.",
   "type": "module",
   "files": [