@dynamic-labs/aptos 4.37.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dynamic Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @dynamic-labs/aptos
+
+An Aptos wallet connector package for the Dynamic SDK that enables seamless integration with Aptos network wallets.
+
+## Installation
+
+```bash
+npm install @dynamic-labs/aptos
+```
+
+## 🔌 Supported Wallets
+
+### Provider Interface
+
+## 🌐 Supported Networks
+
+## 📖 Usage
+
+### Basic Integration
+
+```typescript
+import { DynamicContextProvider } from '@dynamic-labs/sdk-react-core';
+import { AptosWalletConnectors } from '@dynamic-labs/aptos';
+
+function App() {
+  return (
+    <DynamicContextProvider
+      settings={{
+        environmentId: 'your-environment-id',
+        walletConnectors: [AptosWalletConnectors()],
+      }}
+    >
+      {/* Your app content */}
+    </DynamicContextProvider>
+  );
+}
+```
+
+### Type Checking
+
+Use the `isAptosWallet` type guard to safely work with Aptos wallets:
+
+```typescript
+import { isAptosWallet } from '@dynamic-labs/aptos';
+
+function handleWallet(wallet: Wallet) {
+  if (isAptosWallet(wallet)) {
+    // Do something
+  }
+}
+```
+
+## 🧪 Testing
+
+### Run Tests
+
+```bash
+npx nx test aptos
+```
+
+### Build Package
+
+```bash
+npx nx build aptos
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [contributing guidelines](https://github.com/dynamic-labs/dynamic-sdk/blob/main/CONTRIBUTING.md) for details.
+
+## 📄 License
+
+This package is part of the Dynamic SDK and follows the same licensing terms. See [LICENSE](https://github.com/dynamic-labs/dynamic-sdk/blob/main/LICENSE) for details.
+
+## 🆘 Support
+
+- **Documentation**: [docs.dynamic.xyz](https://docs.dynamic.xyz)
+- **GitHub Issues**: [Report bugs or request features](https://github.com/dynamic-labs/dynamic-sdk/issues)
+- **Discord**: [Join our community](https://discord.gg/dynamic)
+
+---
+
+**Built with ❤️ by the Dynamic Labs team**

package/package.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var version = "4.37.2";
+
+exports.version = version;

package/package.js

@@ -0,0 +1,4 @@
+'use client'
+var version = "4.37.2";
+
+export { version };

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@dynamic-labs/aptos",
+  "version": "4.37.2",
+  "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
+  "author": "Dynamic Labs, Inc.",
+  "license": "MIT",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "homepage": "https://www.dynamic.xyz/",
+  "dependencies": {
+    "@aptos-labs/ts-sdk": "5.1.1",
+    "@aptos-labs/wallet-standard": "0.5.2",
+    "@dynamic-labs/assert-package-version": "4.37.2",
+    "@wallet-standard/core": "1.1.1",
+    "@dynamic-labs/utils": "4.37.2"
+  },
+  "peerDependencies": {}
+}

package/src/consts/index.d.ts

@@ -0,0 +1,2 @@
+import { MinimallyRequiredFeatures } from '@aptos-labs/wallet-standard';
+export declare const REQUIRED_FEATURES: (keyof MinimallyRequiredFeatures)[];

package/src/index.cjs

@@ -0,0 +1,18 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assertPackageVersion = require('@dynamic-labs/assert-package-version');
+var _package = require('../package.cjs');
+
+assertPackageVersion.assertPackageVersion('@dynamic-labs/aptos', _package.version);
+// TODO: Add connector exports
+// TODO: Add type exports
+// TODO: Add wallet exports
+// TODO: Add utility exports
+const AptosWalletConnectors = () => [
+// TODO: Add Aptos wallet connectors
+];
+
+exports.AptosWalletConnectors = AptosWalletConnectors;

package/src/index.d.ts

@@ -0,0 +1 @@
+export declare const AptosWalletConnectors: () => never[];

package/src/index.js

@@ -0,0 +1,14 @@
+'use client'
+import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
+import { version } from '../package.js';
+
+assertPackageVersion('@dynamic-labs/aptos', version);
+// TODO: Add connector exports
+// TODO: Add type exports
+// TODO: Add wallet exports
+// TODO: Add utility exports
+const AptosWalletConnectors = () => [
+// TODO: Add Aptos wallet connectors
+];
+
+export { AptosWalletConnectors };

package/src/types.d.ts

@@ -0,0 +1,215 @@
+import type { AccountAuthenticator, AnyRawTransaction } from '@aptos-labs/ts-sdk';
+import type { AccountInfo, AptosSignMessageInput, AptosSignMessageOutput, NetworkInfo, UserResponse } from '@aptos-labs/wallet-standard';
+/**
+ * Global window interface extension for Aptos wallet providers
+ */
+declare global {
+    interface Window {
+        aptos?: IAptosProvider;
+    }
+}
+/**
+ * Interface that all Aptos wallet providers must implement.
+ *
+ * This interface is designed to work with both wallet-standard compliant wallets
+ * and injected providers (like OKX, Petra, etc.). It supports the core methods
+ * needed for Aptos wallet functionality while maintaining flexibility for different
+ * wallet implementations.
+ *
+ * ## Design Philosophy
+ * This interface accommodates both:
+ * - **Wallet Standard**: Modern wallets implementing AIP-62 wallet standard with `features` object
+ * - **Injected Providers**: Wallets that inject methods directly (like OKX, Petra legacy)
+ *
+ * ## Core Features
+ * - **Connection Management**: Connect, disconnect, and account retrieval
+ * - **Network Support**: Network information and switching capabilities
+ * - **Transaction Signing**: Support for transaction and message signing
+ * - **Event Handling**: Account and network change listeners
+ * - **Flexible Returns**: Support for different response formats
+ *
+ * @example
+ * ```typescript
+ * // Basic connection (works for both wallet-standard and injected)
+ * const result = await provider.connect();
+ *
+ * // Sign a transaction
+ * const signature = await provider.signTransaction(transaction);
+ *
+ * // Sign a message
+ * const messageSignature = await provider.signMessage({
+ *   message: "Hello Aptos",
+ *   nonce: "12345"
+ * });
+ *
+ * // Listen for account changes
+ * provider.onAccountChange?.((account) => {
+ *   console.log('Account changed:', account);
+ * });
+ * ```
+ */
+export interface IAptosProvider {
+    /** Whether the wallet is currently connected */
+    isConnected?: boolean;
+    /** The current network information */
+    network?: NetworkInfo;
+    /** The current account information */
+    account?: AccountInfo;
+    /** Wallet-standard features (for AIP-62 compliant wallets) */
+    features?: {
+        'aptos:connect'?: {
+            version: string;
+            connect(): Promise<UserResponse<AccountInfo>>;
+        };
+        'aptos:disconnect'?: {
+            version: string;
+            disconnect(): Promise<void>;
+        };
+        'aptos:signTransaction'?: {
+            version: string;
+            signTransaction(transaction: AnyRawTransaction, asFeePayer?: boolean): Promise<UserResponse<AccountAuthenticator>>;
+        };
+        'aptos:signMessage'?: {
+            version: string;
+            signMessage(input: AptosSignMessageInput): Promise<UserResponse<AptosSignMessageOutput>>;
+        };
+        'aptos:signAndSubmitTransaction'?: {
+            version: string;
+            signAndSubmitTransaction(transaction: AnyRawTransaction): Promise<UserResponse<{
+                hash: string;
+            }>>;
+        };
+        'aptos:network'?: {
+            version: string;
+            network(): Promise<NetworkInfo>;
+        };
+        'aptos:account'?: {
+            version: string;
+            account(): Promise<AccountInfo>;
+        };
+        'aptos:onAccountChange'?: {
+            version: string;
+            onAccountChange(callback: (account: AccountInfo | null) => void): () => void;
+        };
+        'aptos:onNetworkChange'?: {
+            version: string;
+            onNetworkChange(callback: (network: NetworkInfo) => void): () => void;
+        };
+        'aptos:submitTransaction'?: {
+            version: string;
+            submitTransaction(transaction: AccountAuthenticator): Promise<string>;
+        };
+        'aptos:getNetwork'?: {
+            version: string;
+            getNetwork(): Promise<NetworkInfo>;
+        };
+    };
+    /**
+     * Establishes a connection to the wallet
+     * @returns Promise resolving to connection result with account information
+     */
+    connect(): Promise<AptosConnectionResult>;
+    /**
+     * Disconnects from the wallet
+     * @returns Promise that resolves when disconnected
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Retrieves the current account information
+     * @returns Promise resolving to account information
+     */
+    getAccount?(): Promise<AccountInfo>;
+    /**
+     * Retrieves the current network information
+     * @returns Promise resolving to network information
+     */
+    getNetwork?(): Promise<NetworkInfo>;
+    /**
+     * Signs a transaction for submission to the network
+     * @param transaction - Transaction to sign
+     * @param asFeePayer - Whether signing as fee payer (optional)
+     * @returns Promise resolving to signed transaction or user response
+     */
+    signTransaction(transaction: AnyRawTransaction, asFeePayer?: boolean): Promise<UserResponse<AccountAuthenticator> | AccountAuthenticator>;
+    /**
+     * Signs a message for authentication purposes
+     * @param input - Message signing input parameters
+     * @returns Promise resolving to signature result or user response
+     */
+    signMessage(input: AptosSignMessageInput): Promise<UserResponse<AptosSignMessageOutput> | AptosSignMessageOutput>;
+    /**
+     * Submits a signed transaction to the network
+     * @param transaction - Signed transaction to submit
+     * @returns Promise resolving to transaction hash
+     */
+    submitTransaction?(transaction: AccountAuthenticator): Promise<string>;
+    /**
+     * Signs and submits a transaction in one call
+     * @param transaction - Transaction to sign and submit
+     * @returns Promise resolving to transaction hash
+     */
+    signAndSubmitTransaction?(transaction: AnyRawTransaction): Promise<string>;
+    /**
+     * Switches to a different Aptos network
+     * @param network - Network to switch to
+     * @returns Promise that resolves when network is switched
+     */
+    changeNetwork?(network: NetworkInfo | string): Promise<void>;
+    /**
+     * Listen for account changes
+     * @param callback - Callback function for account changes
+     * @returns Cleanup function to remove listener
+     */
+    onAccountChange?(callback: (account: AccountInfo | null) => void): (() => void) | void;
+    /**
+     * Listen for network changes
+     * @param callback - Callback function for network changes
+     * @returns Cleanup function to remove listener
+     */
+    onNetworkChange?(callback: (network: NetworkInfo) => void): (() => void) | void;
+    /**
+     * Generic request method for custom wallet operations
+     * @param method - The method name to call
+     * @param params - Optional parameters for the method
+     * @returns Promise resolving to the method result
+     */
+    request?(method: string, params?: unknown): Promise<unknown>;
+    /** Additional properties that providers may implement */
+    [key: string]: unknown;
+}
+/**
+ * Result from wallet connection, supporting different response formats
+ */
+export type AptosConnectionResult = UserResponse<AccountInfo> | AccountInfo | {
+    address: string;
+    publicKey?: string | Uint8Array;
+} | string;
+/**
+ * Props for sending APT or token balance
+ */
+export interface AptosSendBalanceProps {
+    /** Amount to send (in APT for native transfers) */
+    amount: string;
+    /** Recipient address */
+    toAddress: string;
+    /** Optional token information for non-APT transfers */
+    token?: {
+        /** Token contract address */
+        address: string;
+        /** Token decimals */
+        decimals?: number;
+        /** Token symbol */
+        symbol?: string;
+    };
+}
+/**
+ * Aptos wallet connector constructor properties
+ */
+export interface AptosWalletConnectorProps {
+    /** Wallet book schema */
+    walletBook: any;
+    /** Wallet metadata */
+    metadata?: any;
+}
+export type AptosFeatureName = keyof NonNullable<IAptosProvider['features']>;
+export type AptosMethodName = 'connect' | 'disconnect' | 'signTransaction' | 'signMessage' | 'signAndSubmitTransaction' | 'submitTransaction' | 'getNetwork' | 'network';

package/src/utils/assertProvider/assertProvider.d.ts

@@ -0,0 +1,20 @@
+import type { IAptosProvider } from '../../types';
+/**
+ * Asserts that a wallet provider is available and throws a consistent error if not.
+ *
+ * This utility function eliminates repetitive provider checking throughout the codebase
+ * by providing a centralized assertion with consistent error messaging. After calling
+ * this function, TypeScript will know that the provider is guaranteed to be non-null.
+ *
+ * @param provider - The wallet provider to check, may be undefined
+ * @throws {DynamicError} When the provider is undefined or null
+ *
+ * @example
+ * ```typescript
+ * const provider = getProvider();
+ * assertProvider(provider);
+ * // TypeScript now knows provider is not undefined
+ * await provider.connect();
+ * ```
+ */
+export declare const assertProvider: (provider: IAptosProvider | undefined) => asserts provider is IAptosProvider;

package/src/utils/assertProvider/index.d.ts

@@ -0,0 +1 @@
+export { assertProvider } from './assertProvider';

package/src/utils/getWalletStandardWallets/getWalletStandardWallets.d.ts

@@ -0,0 +1,33 @@
+import { WalletsEventsListeners } from '@wallet-standard/core';
+import { AptosWallet } from '@aptos-labs/wallet-standard';
+/**
+ * Retrieves all available Aptos-compatible wallets from the wallet standard registry.
+ *
+ * This function fetches all registered wallets and filters them to return only those
+ * that support the required Aptos feature set. It also provides an event listener
+ * function to monitor wallet registration events.
+ *
+ * @returns An object containing:
+ * - `aptosWallets`: Array of Aptos-compatible wallets that support required features
+ * - `on`: Event listener function to subscribe to wallet registration/unregistration events
+ *
+ * @example
+ * ```typescript
+ * const { aptosWallets, on } = getWalletStandardWallets();
+ *
+ * // Use the Aptos wallets
+ * console.log('Available Aptos wallets:', aptosWallets);
+ *
+ * // Listen for new wallet registrations
+ * const unsubscribe = on('register', (wallet) => {
+ *   console.log('New wallet registered:', wallet);
+ * });
+ *
+ * // Clean up listener when done
+ * unsubscribe();
+ * ```
+ */
+export declare const getWalletStandardWallets: () => {
+    aptosWallets: AptosWallet[];
+    on: <E extends keyof WalletsEventsListeners>(event: E, listener: WalletsEventsListeners[E]) => () => void;
+};

package/src/utils/getWalletStandardWallets/index.d.ts

@@ -0,0 +1 @@
+export { getWalletStandardWallets } from './getWalletStandardWallets';

package/src/utils/invokeWalletMethod/index.d.ts

@@ -0,0 +1 @@
+export { invokeWalletMethod } from './invokeWalletMethod';

package/src/utils/invokeWalletMethod/invokeWalletMethod.d.ts

@@ -0,0 +1,37 @@
+import type { IAptosProvider, AptosFeatureName, AptosMethodName } from '../../types';
+/**
+ * Invokes a method on either wallet-standard or injected provider.
+ *
+ * This utility handles the dual provider pattern used throughout Aptos wallet interactions,
+ * automatically detecting whether to use wallet-standard features or direct method calls
+ * on injected providers. It provides a unified interface for calling wallet methods
+ * regardless of the underlying wallet implementation.
+ *
+ * @template T - The expected return type of the wallet method
+ * @param provider - The Aptos wallet provider (wallet-standard or injected)
+ * @param featureName - The wallet-standard feature name (e.g., 'aptos:connect')
+ * @param methodName - The method name to call (e.g., 'connect', 'signTransaction')
+ * @param args - Arguments to pass to the wallet method
+ * @returns Promise resolving to the method's return value
+ * @throws {DynamicError} When the method is not supported by the provider
+ *
+ * @example
+ * ```typescript
+ * // Connect to wallet
+ * const result = await invokeWalletMethod(
+ *   provider,
+ *   'aptos:connect',
+ *   'connect'
+ * );
+ *
+ * // Sign transaction
+ * const signature = await invokeWalletMethod(
+ *   provider,
+ *   'aptos:signTransaction',
+ *   'signTransaction',
+ *   transaction,
+ *   false // asFeePayer
+ * );
+ * ```
+ */
+export declare const invokeWalletMethod: <T>(provider: IAptosProvider, featureName: AptosFeatureName, methodName: AptosMethodName, ...args: unknown[]) => Promise<T>;

package/src/utils/isWalletWithRequiredFeatureSet/index.d.ts

@@ -0,0 +1 @@
+export { isWalletWithRequiredFeatureSet } from './isWalletWithRequiredFeatureSet';

package/src/utils/isWalletWithRequiredFeatureSet/isWalletWithRequiredFeatureSet.d.ts

@@ -0,0 +1,2 @@
+import { Wallet, WalletWithFeatures } from '@wallet-standard/core';
+export declare const isWalletWithRequiredFeatureSet: <AdditionalFeatures extends Readonly<Record<`${string}:${string}`, unknown>>>(wallet: Wallet, additionalFeatures?: (keyof AdditionalFeatures)[]) => wallet is WalletWithFeatures<import("@aptos-labs/wallet-standard").AptosFeatures & AdditionalFeatures>;

package/src/utils/parseConnectionResult/index.d.ts

@@ -0,0 +1 @@
+export { parseConnectionResult, type ParsedAccountInfo, } from './parseConnectionResult';

package/src/utils/parseConnectionResult/parseConnectionResult.d.ts

@@ -0,0 +1,18 @@
+import type { AccountInfo } from '@aptos-labs/wallet-standard';
+import type { AptosConnectionResult } from '../../types';
+/**
+ * Parsed account information that may be a full AccountInfo or minimal account data
+ */
+export type ParsedAccountInfo = AccountInfo | {
+    address: string;
+    publicKey?: string | Uint8Array;
+};
+/**
+ * Parses wallet connection result into account information.
+ * Handles different response formats from wallet-standard and injected providers.
+ *
+ * @param result - Connection result matching AptosConnectionResult format
+ * @returns Parsed account information (full AccountInfo or minimal account data)
+ * @throws {DynamicError} When result format is not supported
+ */
+export declare const parseConnectionResult: (result: AptosConnectionResult) => ParsedAccountInfo;