@phantom/server-sdk 0.0.2

package/README.md

@@ -0,0 +1,208 @@
+# Server SDK
+
+This package provides integration with @phantom/openapi-wallet-service for secure wallet management and transaction signing.
+
+## Installation
+
+```bash
+npm install @phantom/server-sdk
+```
+
+## Configuration
+
+The SDK requires the following configuration:
+
+- `apiPrivateKey`: Your signing key for authentication (base58 encoded)
+- `organizationId`: Your organization ID from Phantom
+- `apiBaseUrl`: The wallet API endpoint URL
+
+```typescript
+import { ServerSDK } from '@phantom/server-sdk';
+
+const sdk = new ServerSDK({
+  apiPrivateKey: 'your-signing-key-base58',
+  organizationId: 'your-org-id',
+  apiBaseUrl: 'https://api.phantom.app/v1'
+});
+```
+
+## Network Identifiers
+
+The SDK provides user-friendly enums for CAIP-2 network identifiers:
+
+```typescript
+import { NetworkId } from '@phantom/server-sdk';
+
+// Use the NetworkId enum for easy access to CAIP-2 identifiers
+const solanaMainnet = NetworkId.SOLANA_MAINNET; // 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+const ethMainnet = NetworkId.ETHEREUM_MAINNET;  // 'eip155:1'
+const polygonMainnet = NetworkId.POLYGON_MAINNET; // 'eip155:137'
+
+// Example usage with SDK methods
+const result = await sdk.signAndSendTransaction(
+  walletId,
+  transaction,
+  NetworkId.SOLANA_MAINNET  // Instead of hardcoding 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+);
+
+// Sign a message on Ethereum
+const signature = await sdk.signMessage(
+  walletId,
+  'Hello World',
+  NetworkId.ETHEREUM_MAINNET
+);
+
+
+```
+
+### Available Networks
+
+| Network | Enum Value | CAIP-2 ID |
+|---------|-----------|-----------|
+| **Solana** | | |
+| Mainnet | `NetworkId.SOLANA_MAINNET` | `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` |
+| Devnet | `NetworkId.SOLANA_DEVNET` | `solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1` |
+| Testnet | `NetworkId.SOLANA_TESTNET` | `solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z` |
+| **Ethereum** | | |
+| Mainnet | `NetworkId.ETHEREUM_MAINNET` | `eip155:1` |
+| Goerli | `NetworkId.ETHEREUM_GOERLI` | `eip155:5` |
+| Sepolia | `NetworkId.ETHEREUM_SEPOLIA` | `eip155:11155111` |
+| **Polygon** | | |
+| Mainnet | `NetworkId.POLYGON_MAINNET` | `eip155:137` |
+| Mumbai | `NetworkId.POLYGON_MUMBAI` | `eip155:80001` |
+| **Arbitrum** | | |
+| One | `NetworkId.ARBITRUM_ONE` | `eip155:42161` |
+| Goerli | `NetworkId.ARBITRUM_GOERLI` | `eip155:421613` |
+| **Base** | | |
+| Mainnet | `NetworkId.BASE_MAINNET` | `eip155:8453` |
+| Sepolia | `NetworkId.BASE_SEPOLIA` | `eip155:84532` |
+
+## CAIP-2 Network Identifiers
+
+This SDK uses the CAIP-2 (Chain Agnostic Improvement Proposal 2) standard for network identifiers. CAIP-2 provides a standardized way to identify blockchain networks across different ecosystems.
+
+### Format
+CAIP-2 identifiers follow the format: `namespace:reference`
+
+### Common Network IDs
+- **Solana Mainnet**: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`
+- **Solana Devnet**: `solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1`
+- **Ethereum Mainnet**: `eip155:1`
+- **Polygon Mainnet**: `eip155:137`
+- **Arbitrum One**: `eip155:42161`
+- **Base Mainnet**: `eip155:8453`
+
+## Methods
+
+### createWallet(walletName?: string)
+Creates a new wallet with an optional name. If no name is provided, a default name with timestamp is used.
+After creation, it retrieves the public key by signing an empty payload.
+
+```typescript
+const wallet = await sdk.createWallet('My Main Wallet');
+// Returns: { 
+//   walletId: 'wallet-uuid',
+//   addresses: [{ addressType: 'Solana', address: 'public-key' }]
+// }
+```
+
+### signAndSendTransaction(walletId: string, transaction: Uint8Array, networkId: string)
+Signs a transaction using the wallet service. The transaction should be provided as a Uint8Array and will be encoded as base64 before sending to the KMS.
+
+The SDK automatically derives the submission configuration from the CAIP-2 network ID. If the network supports transaction submission, Phantom will submit the transaction to the blockchain after signing.
+
+**Note:** This method returns only the signed transaction data. To get the transaction hash/signature, you need to extract it from the signed transaction.
+
+```typescript
+import { NetworkId } from '@phantom/server-sdk';
+
+const transactionBuffer = new Uint8Array([...]); // Your serialized transaction
+const result = await sdk.signAndSendTransaction(
+  'wallet-id',
+  transactionBuffer,
+  NetworkId.SOLANA_MAINNET // Using enum - submission config automatically derived
+);
+
+// Returns: { 
+//   rawTransaction: 'base64-signed-transaction'
+// }
+
+// Extract the transaction signature (hash)
+// Note: requires 'import bs58 from "bs58"'
+const signedTx = Transaction.from(Buffer.from(result.rawTransaction, 'base64'));
+const signature = signedTx.signature 
+  ? bs58.encode(signedTx.signature)
+  : bs58.encode(signedTx.signatures[0].signature);
+```
+
+### signMessage(walletId: string, message: string, networkId: string)
+Signs a message with the specified wallet using the signRawPayload method.
+
+```typescript
+const signature = await sdk.signMessage(
+  'wallet-id', 
+  'Hello World', 
+  NetworkId.SOLANA_MAINNET // Using enum for CAIP-2 network ID
+);
+// Returns: base64 encoded signature
+```
+
+## CAIP-2 Utility Functions
+
+The SDK exports several utility functions for working with CAIP-2 network identifiers:
+
+```typescript
+import {
+  deriveSubmissionConfig,
+  supportsTransactionSubmission,
+  getNetworkDescription,
+  getSupportedNetworkIds,
+  getNetworkIdsByChain
+} from '@phantom/server-sdk';
+
+// Check if a network supports transaction submission
+if (supportsTransactionSubmission('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')) {
+  // Network supports automatic transaction submission
+}
+
+// Get human-readable network description
+const description = getNetworkDescription('eip155:137'); // "Polygon Mainnet"
+
+// List all supported networks
+const allNetworks = getSupportedNetworkIds();
+
+// Get networks for a specific chain
+const solanaNetworks = getNetworkIdsByChain('solana');
+// ['solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1', ...]
+```
+
+## Implementation Details
+
+This SDK uses the @phantom/openapi-wallet-service package which provides:
+- `createWallet` - Creates a new wallet and retrieves its public key via signRawPayload
+- `signTransaction` - Signs transactions with the wallet's private key
+- `signRawPayload` - Signs raw payloads/messages and returns signature with public key
+
+The SDK handles:
+- Network-specific algorithms and curves automatically
+- Standard derivation paths for each blockchain
+- Base64 encoding for transaction data
+- Authentication via Ed25519 signatures
+- CAIP-2 network ID parsing and submission config derivation
+
+## Authentication
+
+The SDK authenticates requests using Ed25519 signatures:
+- Each request is signed with your organization's private key
+- The signature, public key, and timestamp are added as headers
+- This ensures secure communication with the Phantom wallet service
+
+
+## Notes
+
+- The wallet ID is a UUID assigned by the service when creating the wallet
+- Public keys are retrieved using the signRawPayload method with an empty payload
+- Transaction hashes are not returned by the signing service - they're generated after blockchain submission
+- The service returns the public key that signed the transaction in the signature field
+- Default wallet names include a timestamp to ensure uniqueness
+- Message signing supports both Solana (Ed25519) and Ethereum (Secp256k1) networks

package/dist/auth.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from 'axios';
+import nacl from 'tweetnacl';
+/**
+ * Creates an authenticated axios instance that signs requests with Ed25519
+ */
+export declare function createAuthenticatedAxiosInstance(signingKeypair: nacl.SignKeyPair): AxiosInstance;

package/dist/auth.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthenticatedAxiosInstance = createAuthenticatedAxiosInstance;
+const axios_1 = __importDefault(require("axios"));
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+/**
+ * Creates an authenticated axios instance that signs requests with Ed25519
+ */
+function createAuthenticatedAxiosInstance(signingKeypair) {
+    const instance = axios_1.default.create();
+    instance.interceptors.request.use((config) => {
+        // Sign the message
+        const requestBody = typeof config.data === "string" ? config.data : JSON.stringify(config.data);
+        const dataUtf8 = Buffer.from(requestBody, "utf8");
+        const signature = tweetnacl_1.default.sign.detached(dataUtf8, signingKeypair.secretKey);
+        config.headers["X-Phantom-Sig"] = Buffer.from(signature).toString("base64");
+        return config;
+    });
+    return instance;
+}

package/dist/caip2-mappings.d.ts

@@ -0,0 +1,59 @@
+interface SubmissionConfig {
+    chain: string;
+    network: string;
+}
+/**
+ * User-friendly enum for CAIP-2 network identifiers
+ * Use these constants instead of hardcoding network IDs
+ */
+export declare enum NetworkId {
+    SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+    SOLANA_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+    SOLANA_TESTNET = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z",
+    ETHEREUM_MAINNET = "eip155:1",
+    ETHEREUM_GOERLI = "eip155:5",
+    ETHEREUM_SEPOLIA = "eip155:11155111",
+    POLYGON_MAINNET = "eip155:137",
+    POLYGON_MUMBAI = "eip155:80001",
+    OPTIMISM_MAINNET = "eip155:10",
+    OPTIMISM_GOERLI = "eip155:420",
+    ARBITRUM_ONE = "eip155:42161",
+    ARBITRUM_GOERLI = "eip155:421613",
+    BASE_MAINNET = "eip155:8453",
+    BASE_GOERLI = "eip155:84531",
+    BASE_SEPOLIA = "eip155:84532",
+    BITCOIN_MAINNET = "bip122:000000000019d6689c085ae165831e93",
+    BITCOIN_TESTNET = "bip122:000000000933ea01ad0ee984209779ba",
+    SUI_MAINNET = "sui:35834a8a",
+    SUI_TESTNET = "sui:4c78adac"
+}
+/**
+ * Derive SubmissionConfig from a CAIP-2 network ID
+ * @param networkId - CAIP-2 compliant network ID (e.g., 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
+ * @returns SubmissionConfig if network supports transaction submission, undefined otherwise
+ */
+export declare function deriveSubmissionConfig(networkId: string): SubmissionConfig | undefined;
+/**
+ * Check if a network ID supports transaction submission
+ * @param networkId - CAIP-2 compliant network ID
+ * @returns true if the network supports transaction submission
+ */
+export declare function supportsTransactionSubmission(networkId: string): boolean;
+/**
+ * Get network description for a CAIP-2 network ID
+ * @param networkId - CAIP-2 compliant network ID
+ * @returns Network description or undefined if not found
+ */
+export declare function getNetworkDescription(networkId: string): string | undefined;
+/**
+ * List all supported CAIP-2 network IDs
+ * @returns Array of supported network IDs
+ */
+export declare function getSupportedNetworkIds(): string[];
+/**
+ * Get all networks for a specific chain
+ * @param chain - Chain name (e.g., 'solana', 'ethereum')
+ * @returns Array of network IDs for the specified chain
+ */
+export declare function getNetworkIdsByChain(chain: string): string[];
+export {};

package/dist/caip2-mappings.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkId = void 0;
+exports.deriveSubmissionConfig = deriveSubmissionConfig;
+exports.supportsTransactionSubmission = supportsTransactionSubmission;
+exports.getNetworkDescription = getNetworkDescription;
+exports.getSupportedNetworkIds = getSupportedNetworkIds;
+exports.getNetworkIdsByChain = getNetworkIdsByChain;
+/**
+ * User-friendly enum for CAIP-2 network identifiers
+ * Use these constants instead of hardcoding network IDs
+ */
+var NetworkId;
+(function (NetworkId) {
+    // Solana Networks
+    NetworkId["SOLANA_MAINNET"] = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    NetworkId["SOLANA_DEVNET"] = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    NetworkId["SOLANA_TESTNET"] = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+    // Ethereum Networks
+    NetworkId["ETHEREUM_MAINNET"] = "eip155:1";
+    NetworkId["ETHEREUM_GOERLI"] = "eip155:5";
+    NetworkId["ETHEREUM_SEPOLIA"] = "eip155:11155111";
+    // Polygon Networks
+    NetworkId["POLYGON_MAINNET"] = "eip155:137";
+    NetworkId["POLYGON_MUMBAI"] = "eip155:80001";
+    // Optimism Networks
+    NetworkId["OPTIMISM_MAINNET"] = "eip155:10";
+    NetworkId["OPTIMISM_GOERLI"] = "eip155:420";
+    // Arbitrum Networks
+    NetworkId["ARBITRUM_ONE"] = "eip155:42161";
+    NetworkId["ARBITRUM_GOERLI"] = "eip155:421613";
+    // Base Networks
+    NetworkId["BASE_MAINNET"] = "eip155:8453";
+    NetworkId["BASE_GOERLI"] = "eip155:84531";
+    NetworkId["BASE_SEPOLIA"] = "eip155:84532";
+    // Bitcoin Networks (for future support)
+    NetworkId["BITCOIN_MAINNET"] = "bip122:000000000019d6689c085ae165831e93";
+    NetworkId["BITCOIN_TESTNET"] = "bip122:000000000933ea01ad0ee984209779ba";
+    // Sui Networks (for future support)
+    NetworkId["SUI_MAINNET"] = "sui:35834a8a";
+    NetworkId["SUI_TESTNET"] = "sui:4c78adac";
+})(NetworkId || (exports.NetworkId = NetworkId = {}));
+const CAIP2_NETWORK_MAPPINGS = {
+    // Solana networks
+    'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': {
+        chain: 'solana',
+        network: 'mainnet',
+        description: 'Solana Mainnet-Beta'
+    },
+    'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1': {
+        chain: 'solana',
+        network: 'devnet',
+        description: 'Solana Devnet'
+    },
+    'solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z': {
+        chain: 'solana',
+        network: 'testnet',
+        description: 'Solana Testnet'
+    },
+    // Ethereum/EVM networks
+    'eip155:1': {
+        chain: 'ethereum',
+        network: 'mainnet',
+        description: 'Ethereum Mainnet'
+    },
+    'eip155:5': {
+        chain: 'ethereum',
+        network: 'goerli',
+        description: 'Goerli Testnet'
+    },
+    'eip155:11155111': {
+        chain: 'ethereum',
+        network: 'sepolia',
+        description: 'Sepolia Testnet'
+    },
+    'eip155:137': {
+        chain: 'polygon',
+        network: 'mainnet',
+        description: 'Polygon Mainnet'
+    },
+    'eip155:80001': {
+        chain: 'polygon',
+        network: 'mumbai',
+        description: 'Polygon Mumbai Testnet'
+    },
+    'eip155:10': {
+        chain: 'optimism',
+        network: 'mainnet',
+        description: 'Optimism Mainnet'
+    },
+    'eip155:420': {
+        chain: 'optimism',
+        network: 'goerli',
+        description: 'Optimism Goerli Testnet'
+    },
+    'eip155:42161': {
+        chain: 'arbitrum',
+        network: 'mainnet',
+        description: 'Arbitrum One'
+    },
+    'eip155:421613': {
+        chain: 'arbitrum',
+        network: 'goerli',
+        description: 'Arbitrum Goerli'
+    },
+    'eip155:8453': {
+        chain: 'base',
+        network: 'mainnet',
+        description: 'Base Mainnet'
+    },
+    'eip155:84531': {
+        chain: 'base',
+        network: 'goerli',
+        description: 'Base Goerli Testnet'
+    },
+    'eip155:84532': {
+        chain: 'base',
+        network: 'sepolia',
+        description: 'Base Sepolia Testnet'
+    },
+    // Bitcoin networks (for future support)
+    'bip122:000000000019d6689c085ae165831e93': {
+        chain: 'bitcoin',
+        network: 'mainnet',
+        description: 'Bitcoin Mainnet'
+    },
+    'bip122:000000000933ea01ad0ee984209779ba': {
+        chain: 'bitcoin',
+        network: 'testnet',
+        description: 'Bitcoin Testnet'
+    },
+    // Sui networks (for future support)
+    'sui:35834a8a': {
+        chain: 'sui',
+        network: 'mainnet',
+        description: 'Sui Mainnet'
+    },
+    'sui:4c78adac': {
+        chain: 'sui',
+        network: 'testnet',
+        description: 'Sui Testnet'
+    },
+};
+/**
+ * Derive SubmissionConfig from a CAIP-2 network ID
+ * @param networkId - CAIP-2 compliant network ID (e.g., 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
+ * @returns SubmissionConfig if network supports transaction submission, undefined otherwise
+ */
+function deriveSubmissionConfig(networkId) {
+    const mapping = CAIP2_NETWORK_MAPPINGS[networkId];
+    if (!mapping) {
+        // Network not found in mappings - cannot derive submission config
+        return undefined;
+    }
+    return {
+        chain: mapping.chain,
+        network: mapping.network
+    };
+}
+/**
+ * Check if a network ID supports transaction submission
+ * @param networkId - CAIP-2 compliant network ID
+ * @returns true if the network supports transaction submission
+ */
+function supportsTransactionSubmission(networkId) {
+    return networkId in CAIP2_NETWORK_MAPPINGS;
+}
+/**
+ * Get network description for a CAIP-2 network ID
+ * @param networkId - CAIP-2 compliant network ID
+ * @returns Network description or undefined if not found
+ */
+function getNetworkDescription(networkId) {
+    return CAIP2_NETWORK_MAPPINGS[networkId]?.description;
+}
+/**
+ * List all supported CAIP-2 network IDs
+ * @returns Array of supported network IDs
+ */
+function getSupportedNetworkIds() {
+    return Object.keys(CAIP2_NETWORK_MAPPINGS);
+}
+/**
+ * Get all networks for a specific chain
+ * @param chain - Chain name (e.g., 'solana', 'ethereum')
+ * @returns Array of network IDs for the specified chain
+ */
+function getNetworkIdsByChain(chain) {
+    return Object.entries(CAIP2_NETWORK_MAPPINGS)
+        .filter(([_, mapping]) => mapping.chain.toLowerCase() === chain.toLowerCase())
+        .map(([networkId]) => networkId);
+}

package/dist/constants.d.ts

@@ -0,0 +1,27 @@
+import { DerivationInfoCurveEnum, DerivationInfoAddressFormatEnum, Algorithm } from '@phantom/openapi-wallet-service';
+/**
+ * Default derivation paths for different blockchain networks
+ */
+export declare enum DerivationPath {
+    Solana = "m/44'/501'/0'/0'",
+    Ethereum = "m/44'/60'/0'/0",
+    Bitcoin = "m/84'/0'/0'/0",
+    Sui = "m/44'/784'/0'/0'/0'"
+}
+/**
+ * Helper function to get derivation path based on network ID
+ */
+export declare function getDerivationPathForNetwork(networkId: string): string;
+/**
+ * Network configuration
+ */
+export interface NetworkConfig {
+    derivationPath: string;
+    curve: DerivationInfoCurveEnum;
+    algorithm: Algorithm;
+    addressFormat: DerivationInfoAddressFormatEnum;
+}
+/**
+ * Get complete network configuration
+ */
+export declare function getNetworkConfig(networkId: string): NetworkConfig;

package/dist/constants.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DerivationPath = void 0;
+exports.getDerivationPathForNetwork = getDerivationPathForNetwork;
+exports.getNetworkConfig = getNetworkConfig;
+const openapi_wallet_service_1 = require("@phantom/openapi-wallet-service");
+/**
+ * Default derivation paths for different blockchain networks
+ */
+var DerivationPath;
+(function (DerivationPath) {
+    // Solana - BIP44 standard for Solana (coin type 501)
+    DerivationPath["Solana"] = "m/44'/501'/0'/0'";
+    // Ethereum - BIP44 standard for Ethereum and all EVM-compatible chains (coin type 60)
+    DerivationPath["Ethereum"] = "m/44'/60'/0'/0";
+    // Bitcoin - BIP44 standard for Bitcoin (coin type 0)
+    DerivationPath["Bitcoin"] = "m/84'/0'/0'/0";
+    // Sui - BIP44 standard for Sui (coin type 784)
+    DerivationPath["Sui"] = "m/44'/784'/0'/0'/0'";
+})(DerivationPath || (exports.DerivationPath = DerivationPath = {}));
+/**
+ * Helper function to get derivation path based on network ID
+ */
+function getDerivationPathForNetwork(networkId) {
+    // Extract the chain name from network ID format (e.g., "solana:mainnet" -> "solana")
+    const network = networkId.split(':')[0].toLowerCase();
+    switch (network) {
+        case 'solana':
+            return DerivationPath.Solana;
+        case 'sui':
+            return DerivationPath.Sui;
+        case 'bitcoin':
+        case 'btc':
+            return DerivationPath.Bitcoin;
+        case 'eip155': // EVM chains use eip155 prefix
+        case 'ethereum':
+        case 'eth':
+        default:
+            // Default to Ethereum path for all EVM-compatible chains
+            return DerivationPath.Ethereum;
+    }
+}
+/**
+ * Get complete network configuration
+ */
+function getNetworkConfig(networkId) {
+    const network = networkId.split(':')[0].toLowerCase();
+    switch (network) {
+        case 'solana':
+            return {
+                derivationPath: DerivationPath.Solana,
+                curve: openapi_wallet_service_1.DerivationInfoCurveEnum.ed25519,
+                algorithm: openapi_wallet_service_1.Algorithm.ed25519,
+                addressFormat: openapi_wallet_service_1.DerivationInfoAddressFormatEnum.solana
+            };
+        case 'sui':
+            return {
+                derivationPath: DerivationPath.Sui,
+                curve: openapi_wallet_service_1.DerivationInfoCurveEnum.ed25519,
+                algorithm: openapi_wallet_service_1.Algorithm.ed25519,
+                addressFormat: openapi_wallet_service_1.DerivationInfoAddressFormatEnum.sui,
+            };
+        case 'bitcoin':
+        case 'btc':
+            return {
+                derivationPath: DerivationPath.Bitcoin,
+                curve: openapi_wallet_service_1.DerivationInfoCurveEnum.secp256k1,
+                algorithm: openapi_wallet_service_1.Algorithm.secp256k1,
+                addressFormat: openapi_wallet_service_1.DerivationInfoAddressFormatEnum.bitcoinSegwit // Bitcoin uses a different format, but for SDK consistency we use Ethereum format
+            };
+        default:
+            // All EVM-compatible chains (Ethereum, Polygon, BSC, Arbitrum, etc.)
+            return {
+                derivationPath: DerivationPath.Ethereum,
+                curve: openapi_wallet_service_1.DerivationInfoCurveEnum.secp256k1,
+                algorithm: openapi_wallet_service_1.Algorithm.secp256k1,
+                addressFormat: openapi_wallet_service_1.DerivationInfoAddressFormatEnum.ethereum // EVM chains use Ethereum address format
+            };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { ServerSDKConfig, CreateWalletResult, Transaction, SignedTransaction } from "./types";
+export interface SubmissionConfig {
+    chain: string;
+    network: string;
+}
+export { NetworkId, deriveSubmissionConfig, supportsTransactionSubmission, getNetworkDescription, getSupportedNetworkIds, getNetworkIdsByChain } from "./caip2-mappings";
+export declare class ServerSDK {
+    private config;
+    private kmsApi;
+    private signingKeypair;
+    constructor(config: ServerSDKConfig);
+    createWallet(walletName?: string): Promise<CreateWalletResult>;
+    signAndSendTransaction(walletId: string, transaction: Transaction, networkId: string): Promise<SignedTransaction>;
+    getWalletAddresses(walletId: string, derivationPaths?: string[]): Promise<{
+        addressType: string;
+        address: string;
+    }[]>;
+    signMessage(walletId: string, message: string, networkId: string): Promise<string>;
+}
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,211 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerSDK = exports.getNetworkIdsByChain = exports.getSupportedNetworkIds = exports.getNetworkDescription = exports.supportsTransactionSubmission = exports.deriveSubmissionConfig = exports.NetworkId = void 0;
+const auth_1 = require("./auth");
+const constants_1 = require("./constants");
+const caip2_mappings_1 = require("./caip2-mappings");
+const bs58_1 = __importDefault(require("bs58"));
+const openapi_wallet_service_1 = require("@phantom/openapi-wallet-service");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+// Export CAIP-2 utilities and enums
+var caip2_mappings_2 = require("./caip2-mappings");
+Object.defineProperty(exports, "NetworkId", { enumerable: true, get: function () { return caip2_mappings_2.NetworkId; } });
+Object.defineProperty(exports, "deriveSubmissionConfig", { enumerable: true, get: function () { return caip2_mappings_2.deriveSubmissionConfig; } });
+Object.defineProperty(exports, "supportsTransactionSubmission", { enumerable: true, get: function () { return caip2_mappings_2.supportsTransactionSubmission; } });
+Object.defineProperty(exports, "getNetworkDescription", { enumerable: true, get: function () { return caip2_mappings_2.getNetworkDescription; } });
+Object.defineProperty(exports, "getSupportedNetworkIds", { enumerable: true, get: function () { return caip2_mappings_2.getSupportedNetworkIds; } });
+Object.defineProperty(exports, "getNetworkIdsByChain", { enumerable: true, get: function () { return caip2_mappings_2.getNetworkIdsByChain; } });
+class ServerSDK {
+    constructor(config) {
+        this.config = config;
+        if (!config.organizationId || !config.apiBaseUrl) {
+            throw new Error("organizationId and apiBaseUrl are required");
+        }
+        // Decode the private key from base58
+        const privateKeyBytes = bs58_1.default.decode(config.apiPrivateKey);
+        this.signingKeypair = tweetnacl_1.default.sign.keyPair.fromSecretKey(privateKeyBytes);
+        // Create authenticated axios instance
+        const authenticatedAxios = (0, auth_1.createAuthenticatedAxiosInstance)(this.signingKeypair);
+        // Configure the KMS API client with authentication
+        const configuration = new openapi_wallet_service_1.Configuration({
+            basePath: config.apiBaseUrl,
+        });
+        // Pass the authenticated axios instance to the KMS API
+        this.kmsApi = new openapi_wallet_service_1.KMSRPCApi(configuration, config.apiBaseUrl, authenticatedAxios);
+    }
+    async createWallet(walletName) {
+        try {
+            // Create wallet request
+            const walletRequest = {
+                organizationId: this.config.organizationId,
+                walletName: walletName || `Wallet ${Date.now()}`,
+                accounts: [constants_1.DerivationPath.Solana, constants_1.DerivationPath.Ethereum, constants_1.DerivationPath.Bitcoin, constants_1.DerivationPath.Sui],
+            };
+            console.log("Creating wallet with request:", walletRequest);
+            const request = {
+                method: openapi_wallet_service_1.CreateWalletMethodEnum.createWallet,
+                params: walletRequest,
+                timestampMs: Date.now(),
+            };
+            const response = await this.kmsApi.postKmsRpc(request);
+            const walletResult = response.data.result;
+            console.log("Wallet created successfully:", walletResult);
+            // Fetch the accounts
+            const requestAccounts = {
+                method: openapi_wallet_service_1.GetAccountsMethodEnum.getAccounts,
+                params: {
+                    accounts: [constants_1.DerivationPath.Solana, constants_1.DerivationPath.Ethereum, constants_1.DerivationPath.Bitcoin, constants_1.DerivationPath.Sui],
+                    organizationId: this.config.organizationId,
+                    walletId: walletResult.walletId,
+                },
+                timestampMs: Date.now(),
+            };
+            console.log("Fetching accounts for wallet:", walletResult.walletId);
+            const accountsResponse = await this.kmsApi.postKmsRpc(requestAccounts);
+            console.log("Accounts fetched successfully:", accountsResponse.data.result);
+            const accountsResult = accountsResponse.data.result;
+            return {
+                walletId: walletResult.walletId,
+                addresses: accountsResult.map(account => ({
+                    addressType: account.addressFormat,
+                    address: account.publicKey,
+                })),
+            };
+        }
+        catch (error) {
+            console.error("Failed to create wallet:", error.response?.data || error.message);
+            throw new Error(`Failed to create wallet: ${error.response?.data?.message || error.message}`);
+        }
+    }
+    async signAndSendTransaction(walletId, transaction, networkId) {
+        try {
+            // Encode the Uint8Array as a base64 string
+            const encodedTransaction = Buffer.from(transaction).toString('base64');
+            const submissionConfig = (0, caip2_mappings_1.deriveSubmissionConfig)(networkId);
+            // If we don't have a submission config, the transaction will only be signed, not submitted
+            if (!submissionConfig) {
+                console.warn(`No submission config available for network ${networkId}. Transaction will be signed but not submitted.`);
+            }
+            // For Solana transactions
+            if (networkId.startsWith("solana:")) {
+                // Get network configuration
+                const networkConfig = (0, constants_1.getNetworkConfig)(networkId);
+                const derivationInfo = {
+                    derivationPath: networkConfig.derivationPath,
+                    curve: networkConfig.curve,
+                    addressFormat: networkConfig.addressFormat,
+                };
+                // Sign transaction request - only include submissionConfig if available
+                const signRequest = {
+                    organizationId: this.config.organizationId,
+                    walletId: walletId,
+                    transaction: encodedTransaction,
+                    derivationInfo: derivationInfo,
+                };
+                // Add submission config if available
+                if (submissionConfig) {
+                    signRequest.submissionConfig = submissionConfig;
+                }
+                const request = {
+                    method: openapi_wallet_service_1.SignTransactionMethodEnum.signTransaction,
+                    params: signRequest,
+                    timestampMs: Date.now(),
+                };
+                const response = await this.kmsApi.postKmsRpc(request);
+                const result = response.data.result;
+                return {
+                    rawTransaction: result.transaction, // Base64 encoded signed transaction
+                };
+            }
+            else {
+                // For EVM chains (future implementation)
+                throw new Error("EVM transaction signing not yet implemented");
+            }
+        }
+        catch (error) {
+            console.error("Failed to sign and send transaction:", error.response?.data || error.message);
+            throw new Error(`Failed to sign and send transaction: ${error.response?.data?.message || error.message}`);
+        }
+    }
+    async getWalletAddresses(walletId, derivationPaths) {
+        try {
+            const paths = derivationPaths || [
+                constants_1.DerivationPath.Solana,
+                constants_1.DerivationPath.Ethereum,
+                constants_1.DerivationPath.Bitcoin,
+                constants_1.DerivationPath.Sui,
+            ];
+            const requestAccounts = {
+                method: openapi_wallet_service_1.GetAccountsMethodEnum.getAccounts,
+                params: {
+                    accounts: paths,
+                    organizationId: this.config.organizationId,
+                    walletId: walletId,
+                },
+                timestampMs: Date.now(),
+            };
+            const accountsResponse = await this.kmsApi.postKmsRpc(requestAccounts);
+            const accountsResult = accountsResponse.data.result;
+            return accountsResult.map(account => ({
+                addressType: account.addressFormat,
+                address: account.publicKey,
+            }));
+        }
+        catch (error) {
+            console.error("Failed to get wallet addresses:", error.response?.data || error.message);
+            throw new Error(`Failed to get wallet addresses: ${error.response?.data?.message || error.message}`);
+        }
+    }
+    async signMessage(walletId, message, networkId) {
+        try {
+            // Convert message to byte array
+            const messageBytes = Array.from(Buffer.from(message, "utf8"));
+            // Get network configuration
+            const networkConfig = (0, constants_1.getNetworkConfig)(networkId);
+            const derivationInfo = {
+                derivationPath: networkConfig.derivationPath,
+                curve: networkConfig.curve,
+                addressFormat: networkConfig.addressFormat,
+            };
+            const signRequest = {
+                organizationId: this.config.organizationId,
+                walletId: walletId,
+                payload: messageBytes,
+                algorithm: networkConfig.algorithm,
+                derivationInfo: derivationInfo,
+            };
+            const request = {
+                method: openapi_wallet_service_1.SignRawPayloadMethodEnum.signRawPayload,
+                params: signRequest,
+                timestampMs: Date.now(),
+            };
+            const response = await this.kmsApi.postKmsRpc(request);
+            const result = response.data.result;
+            // Return the base64 encoded signature
+            return result.signature;
+        }
+        catch (error) {
+            console.error("Failed to sign message:", error.response?.data || error.message);
+            throw new Error(`Failed to sign message: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+exports.ServerSDK = ServerSDK;
+__exportStar(require("./types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+import { DerivationInfoAddressFormatEnum } from "@phantom/openapi-wallet-service";
+export interface ServerSDKConfig {
+    apiPrivateKey: string;
+    organizationId: string;
+    apiBaseUrl: string;
+    solanaRpcUrl?: string;
+}
+export interface WalletAddress {
+    addressType: DerivationInfoAddressFormatEnum;
+    address: string;
+}
+export interface CreateWalletResult {
+    walletId: string;
+    addresses: WalletAddress[];
+}
+export type Transaction = Uint8Array;
+export interface SignedTransaction {
+    rawTransaction: string;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@phantom/server-sdk",
+  "version": "0.0.2",
+  "description": "Server SDK for Phantom Wallet",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.0",
+    "dotenv": "^16.4.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "@phantom/openapi-wallet-service": "^0.1.5",
+    "axios": "^1.10.0",
+    "bs58": "^6.0.0",
+    "tweetnacl": "^1.0.3"
+  },
+  "files": [
+    "dist"
+  ]
+}