@shadow-corp/nearconnect 1.0.0

package/build/wallets/privileged/ledger.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Ledger Wallet Implementation
+ *
+ * Privileged wallet that runs in main thread with WebHID access
+ */
+import { type LedgerConfig, type LedgerDeviceInfo, type HardwareWaitingEvent, type HardwareConfirmEvent, type HardwareRejectedEvent } from '../../hardware/types';
+import type { Network, Transaction } from '../../types';
+export interface LedgerWalletAccount {
+    accountId: string;
+    publicKey?: string;
+}
+export interface LedgerTransactionResult {
+    transaction: {
+        hash: string;
+        signerId: string;
+        receiverId: string;
+    };
+    transaction_outcome: {
+        id: string;
+        outcome: {
+            status: unknown;
+            logs: string[];
+            gas_burnt: number;
+        };
+    };
+    receipts_outcome: Array<{
+        id: string;
+        outcome: {
+            status: unknown;
+            logs: string[];
+        };
+    }>;
+    status: {
+        SuccessValue?: string;
+        Failure?: unknown;
+    };
+}
+export interface LedgerSignedTransaction {
+    hash: string;
+    signedTransaction: Uint8Array;
+}
+export interface LedgerSignMessageParams {
+    message: string;
+    recipient: string;
+    nonce: Uint8Array;
+    callbackUrl?: string;
+}
+export interface LedgerSignedMessage {
+    accountId: string;
+    publicKey: string;
+    signature: string;
+    message: string;
+}
+type EventCallback<T> = (data: T) => void;
+type EventUnsubscribe = () => void;
+export declare class LedgerWallet {
+    readonly id = "ledger";
+    readonly type: "privileged";
+    private app;
+    private accounts;
+    private derivationPath;
+    private networkId;
+    private rpcUrl;
+    private listeners;
+    constructor(config: {
+        network: Network;
+        ledger?: LedgerConfig | boolean;
+        rpcUrl?: string;
+    });
+    static isSupported(): boolean;
+    static getManifest(): {
+        id: string;
+        version: string;
+        name: string;
+        description: string;
+        iconUrl: string;
+        website: string;
+        type: "privileged";
+        hardwareType: "ledger";
+        features: {
+            signMessage: boolean;
+            signTransaction: boolean;
+            signAndSendTransaction: boolean;
+            signAndSendTransactions: boolean;
+        };
+    };
+    onWaiting(callback: EventCallback<HardwareWaitingEvent>): EventUnsubscribe;
+    onConfirm(callback: EventCallback<HardwareConfirmEvent>): EventUnsubscribe;
+    onRejected(callback: EventCallback<HardwareRejectedEvent>): EventUnsubscribe;
+    onConnected(callback: EventCallback<{
+        device: LedgerDeviceInfo;
+    }>): EventUnsubscribe;
+    onDisconnected(callback: EventCallback<void>): EventUnsubscribe;
+    private emitWaiting;
+    private emitConfirm;
+    private emitRejected;
+    private emitConnected;
+    private emitDisconnected;
+    isConnected(): boolean;
+    getAccounts(): Promise<LedgerWalletAccount[]>;
+    signIn(): Promise<LedgerWalletAccount[]>;
+    signOut(): Promise<void>;
+    private disconnect;
+    signTransaction(tx: Transaction): Promise<LedgerSignedTransaction>;
+    signAndSendTransaction(tx: Transaction): Promise<LedgerTransactionResult>;
+    signAndSendTransactions(txs: Transaction[]): Promise<LedgerTransactionResult[]>;
+    signMessage(params: LedgerSignMessageParams): Promise<LedgerSignedMessage>;
+    private getDefaultRpcUrl;
+    private publicKeyToImplicitAccountId;
+    private serializeTransaction;
+    private borshSerializeTransaction;
+    private borshString;
+    private uint64LE;
+    private borshActions;
+    private borshAction;
+    private createSignedTransaction;
+    private computeTransactionHash;
+    private broadcastTransaction;
+    private getAccessKey;
+    private getRecentBlockHash;
+    private writeUint32LE;
+    private bytesToHex;
+    private bytesToBase64;
+    private bytesToBase58;
+    private base58ToBytes;
+}
+export declare function createLedgerWallet(config: {
+    network: Network;
+    ledger?: LedgerConfig | boolean;
+    rpcUrl?: string;
+}): LedgerWallet;
+export {};

package/build/wallets/privileged/ledger.js

@@ -0,0 +1,563 @@
+"use strict";
+/**
+ * Ledger Wallet Implementation
+ *
+ * Privileged wallet that runs in main thread with WebHID access
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerWallet = void 0;
+exports.createLedgerWallet = createLedgerWallet;
+const near_app_1 = require("../../hardware/near-app");
+const types_1 = require("../../hardware/types");
+const errors_1 = require("../../hardware/errors");
+// =============================================================================
+// Ledger Wallet
+// =============================================================================
+class LedgerWallet {
+    id = 'ledger';
+    type = 'privileged';
+    app = null;
+    accounts = [];
+    derivationPath;
+    networkId;
+    rpcUrl;
+    // Event listeners
+    listeners = {
+        waiting: new Set(),
+        confirm: new Set(),
+        rejected: new Set(),
+        connected: new Set(),
+        disconnected: new Set(),
+    };
+    constructor(config) {
+        this.networkId = config.network;
+        this.rpcUrl = config.rpcUrl || this.getDefaultRpcUrl(config.network);
+        // Parse config
+        const ledgerConfig = typeof config.ledger === 'boolean'
+            ? { enabled: config.ledger }
+            : config.ledger;
+        this.derivationPath = ledgerConfig?.derivationPath || types_1.DEFAULT_DERIVATION_PATH;
+    }
+    // ===========================================================================
+    // Static Methods
+    // ===========================================================================
+    static isSupported() {
+        return near_app_1.LedgerNearApp.isSupported();
+    }
+    static getManifest() {
+        return {
+            id: 'ledger',
+            version: '1.0.0',
+            name: 'Ledger',
+            description: 'Connect your Ledger hardware wallet',
+            iconUrl: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCIgdmlld0JveD0iMCAwIDEyOCAxMjgiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxyZWN0IHdpZHRoPSIxMjgiIGhlaWdodD0iMTI4IiByeD0iMjQiIGZpbGw9ImJsYWNrIi8+CjxwYXRoIGQ9Ik0zOC40IDc5LjJWODkuNkg3OS4yVjc5LjJIMzguNFoiIGZpbGw9IndoaXRlIi8+CjxwYXRoIGQ9Ik0zOC40IDM4LjRWNjguOEg0OC44VjQ4LjhINjguOFYzOC40SDM4LjRaIiBmaWxsPSJ3aGl0ZSIvPgo8cGF0aCBkPSJNNzkuMiAzOC40Vjc5LjJIODkuNlYzOC40SDc5LjJaIiBmaWxsPSJ3aGl0ZSIvPgo8L3N2Zz4K',
+            website: 'https://ledger.com',
+            type: 'privileged',
+            hardwareType: 'ledger',
+            features: {
+                signMessage: true,
+                signTransaction: true,
+                signAndSendTransaction: true,
+                signAndSendTransactions: true,
+            },
+        };
+    }
+    // ===========================================================================
+    // Event Methods
+    // ===========================================================================
+    onWaiting(callback) {
+        this.listeners.waiting.add(callback);
+        return () => this.listeners.waiting.delete(callback);
+    }
+    onConfirm(callback) {
+        this.listeners.confirm.add(callback);
+        return () => this.listeners.confirm.delete(callback);
+    }
+    onRejected(callback) {
+        this.listeners.rejected.add(callback);
+        return () => this.listeners.rejected.delete(callback);
+    }
+    onConnected(callback) {
+        this.listeners.connected.add(callback);
+        return () => this.listeners.connected.delete(callback);
+    }
+    onDisconnected(callback) {
+        this.listeners.disconnected.add(callback);
+        return () => this.listeners.disconnected.delete(callback);
+    }
+    emitWaiting(data) {
+        this.listeners.waiting.forEach((cb) => { try {
+            cb(data);
+        }
+        catch (e) {
+            console.error('Error in waiting listener:', e);
+        } });
+    }
+    emitConfirm(data) {
+        this.listeners.confirm.forEach((cb) => { try {
+            cb(data);
+        }
+        catch (e) {
+            console.error('Error in confirm listener:', e);
+        } });
+    }
+    emitRejected(data) {
+        this.listeners.rejected.forEach((cb) => { try {
+            cb(data);
+        }
+        catch (e) {
+            console.error('Error in rejected listener:', e);
+        } });
+    }
+    emitConnected(data) {
+        this.listeners.connected.forEach((cb) => { try {
+            cb(data);
+        }
+        catch (e) {
+            console.error('Error in connected listener:', e);
+        } });
+    }
+    emitDisconnected() {
+        this.listeners.disconnected.forEach((cb) => { try {
+            cb();
+        }
+        catch (e) {
+            console.error('Error in disconnected listener:', e);
+        } });
+    }
+    // ===========================================================================
+    // Connection Methods
+    // ===========================================================================
+    isConnected() {
+        return this.app !== null && this.app.isConnected() && this.accounts.length > 0;
+    }
+    async getAccounts() {
+        return this.accounts;
+    }
+    async signIn() {
+        this.emitWaiting({
+            walletId: this.id,
+            action: 'connect',
+            message: 'Please connect and unlock your Ledger device, then open the NEAR app',
+        });
+        try {
+            this.app = await near_app_1.LedgerNearApp.connect();
+            const deviceInfo = await this.app.getDeviceInfo();
+            this.emitConfirm({ walletId: this.id, action: 'connect' });
+            this.emitConnected({ device: deviceInfo });
+            this.emitWaiting({
+                walletId: this.id,
+                action: 'get_public_key',
+                message: 'Please verify your address on the Ledger device',
+            });
+            const { address } = await this.app.getPublicKey(this.derivationPath, true);
+            this.emitConfirm({ walletId: this.id, action: 'get_public_key' });
+            // Derive account ID from public key (implicit account)
+            const accountId = this.publicKeyToImplicitAccountId(address);
+            this.accounts = [{
+                    accountId,
+                    publicKey: address,
+                }];
+            return this.accounts;
+        }
+        catch (error) {
+            this.emitRejected({
+                walletId: this.id,
+                action: 'connect',
+                reason: error instanceof Error ? error.message : 'Connection failed',
+            });
+            await this.disconnect();
+            throw error;
+        }
+    }
+    async signOut() {
+        await this.disconnect();
+    }
+    async disconnect() {
+        if (this.app) {
+            await this.app.disconnect();
+            this.app = null;
+        }
+        this.accounts = [];
+        this.emitDisconnected();
+    }
+    // ===========================================================================
+    // Transaction Methods
+    // ===========================================================================
+    async signTransaction(tx) {
+        if (!this.app || !this.isConnected()) {
+            throw (0, errors_1.createHardwareError)(types_1.HardwareErrorCode.DEVICE_NOT_FOUND, 'Ledger not connected');
+        }
+        const account = this.accounts[0];
+        if (!account) {
+            throw (0, errors_1.createHardwareError)(types_1.HardwareErrorCode.DEVICE_NOT_FOUND, 'No account connected');
+        }
+        this.emitWaiting({
+            walletId: this.id,
+            action: 'sign',
+            message: 'Please review and approve the transaction on your Ledger',
+        });
+        try {
+            const signerId = tx.signerId || account.accountId;
+            const txBytes = await this.serializeTransaction({
+                ...tx,
+                signerId,
+            });
+            const { signature } = await this.app.signTransaction(this.derivationPath, txBytes);
+            this.emitConfirm({ walletId: this.id, action: 'sign' });
+            const signedTx = this.createSignedTransaction(txBytes, signature);
+            return {
+                hash: await this.computeTransactionHash(txBytes),
+                signedTransaction: signedTx,
+            };
+        }
+        catch (error) {
+            const isRejection = (0, errors_1.isHardwareError)(error) && error.code === types_1.HardwareErrorCode.USER_REJECTED;
+            this.emitRejected({
+                walletId: this.id,
+                action: 'sign',
+                reason: isRejection ? 'User rejected on device' :
+                    (error instanceof Error ? error.message : 'Signing failed'),
+            });
+            throw error;
+        }
+    }
+    async signAndSendTransaction(tx) {
+        const signed = await this.signTransaction(tx);
+        return this.broadcastTransaction(signed.signedTransaction);
+    }
+    async signAndSendTransactions(txs) {
+        const results = [];
+        for (const tx of txs) {
+            const result = await this.signAndSendTransaction(tx);
+            results.push(result);
+        }
+        return results;
+    }
+    // ===========================================================================
+    // Message Signing (NEP-413)
+    // ===========================================================================
+    async signMessage(params) {
+        if (!this.app || !this.isConnected()) {
+            throw (0, errors_1.createHardwareError)(types_1.HardwareErrorCode.DEVICE_NOT_FOUND, 'Ledger not connected');
+        }
+        const account = this.accounts[0];
+        if (!account) {
+            throw (0, errors_1.createHardwareError)(types_1.HardwareErrorCode.DEVICE_NOT_FOUND, 'No account connected');
+        }
+        this.emitWaiting({
+            walletId: this.id,
+            action: 'sign_message',
+            message: 'Please review and approve the message on your Ledger',
+        });
+        try {
+            const { signature } = await this.app.signMessage(this.derivationPath, params.message, params.nonce, params.recipient, params.callbackUrl);
+            this.emitConfirm({ walletId: this.id, action: 'sign_message' });
+            return {
+                accountId: account.accountId,
+                publicKey: account.publicKey,
+                signature: this.bytesToBase64(signature),
+                message: params.message,
+            };
+        }
+        catch (error) {
+            const isRejection = (0, errors_1.isHardwareError)(error) && error.code === types_1.HardwareErrorCode.USER_REJECTED;
+            this.emitRejected({
+                walletId: this.id,
+                action: 'sign_message',
+                reason: isRejection ? 'User rejected on device' :
+                    (error instanceof Error ? error.message : 'Signing failed'),
+            });
+            throw error;
+        }
+    }
+    // ===========================================================================
+    // Helper Methods
+    // ===========================================================================
+    getDefaultRpcUrl(network) {
+        return network === 'mainnet'
+            ? 'https://rpc.mainnet.near.org'
+            : 'https://rpc.testnet.near.org';
+    }
+    publicKeyToImplicitAccountId(publicKey) {
+        const key = publicKey.replace('ed25519:', '');
+        const bytes = this.base58ToBytes(key);
+        return this.bytesToHex(bytes);
+    }
+    async serializeTransaction(tx) {
+        const accessKey = await this.getAccessKey(tx.signerId, this.accounts[0].publicKey);
+        const nonce = accessKey.nonce + 1;
+        const blockHash = await this.getRecentBlockHash();
+        const txData = {
+            signerId: tx.signerId,
+            publicKey: this.accounts[0].publicKey,
+            nonce,
+            receiverId: tx.receiverId,
+            blockHash,
+            actions: tx.actions,
+        };
+        return this.borshSerializeTransaction(txData);
+    }
+    borshSerializeTransaction(tx) {
+        const chunks = [];
+        // Signer ID
+        chunks.push(this.borshString(tx.signerId));
+        // Public key (enum + 32 bytes)
+        const pubKeyBytes = this.base58ToBytes(tx.publicKey.replace('ed25519:', ''));
+        const pubKey = new Uint8Array(33);
+        pubKey[0] = 0; // ED25519 = 0
+        pubKey.set(pubKeyBytes, 1);
+        chunks.push(pubKey);
+        // Nonce (u64 LE)
+        chunks.push(this.uint64LE(tx.nonce));
+        // Receiver ID
+        chunks.push(this.borshString(tx.receiverId));
+        // Block hash (32 bytes)
+        chunks.push(tx.blockHash);
+        // Actions
+        chunks.push(this.borshActions(tx.actions));
+        // Concatenate
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+    borshString(str) {
+        const bytes = new TextEncoder().encode(str);
+        const result = new Uint8Array(4 + bytes.length);
+        this.writeUint32LE(result, 0, bytes.length);
+        result.set(bytes, 4);
+        return result;
+    }
+    uint64LE(value) {
+        const result = new Uint8Array(8);
+        let v = BigInt(value);
+        for (let i = 0; i < 8; i++) {
+            result[i] = Number(v & BigInt(0xff));
+            v >>= BigInt(8);
+        }
+        return result;
+    }
+    borshActions(actions) {
+        const chunks = [];
+        const length = new Uint8Array(4);
+        this.writeUint32LE(length, 0, actions.length);
+        chunks.push(length);
+        for (const action of actions) {
+            chunks.push(this.borshAction(action));
+        }
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+    borshAction(action) {
+        const actionObj = action;
+        const actionType = Object.keys(actionObj)[0];
+        const actionData = actionObj[actionType];
+        const actionTypes = {
+            CreateAccount: 0,
+            DeployContract: 1,
+            FunctionCall: 2,
+            Transfer: 3,
+            Stake: 4,
+            AddKey: 5,
+            DeleteKey: 6,
+            DeleteAccount: 7,
+        };
+        const typeIndex = actionTypes[actionType];
+        if (typeIndex === undefined) {
+            throw new Error(`Unknown action type: ${actionType}`);
+        }
+        const chunks = [];
+        chunks.push(new Uint8Array([typeIndex]));
+        switch (actionType) {
+            case 'Transfer': {
+                const data = actionData;
+                const deposit = BigInt(data.deposit || '0');
+                const depositBytes = new Uint8Array(16);
+                let d = deposit;
+                for (let i = 0; i < 16; i++) {
+                    depositBytes[i] = Number(d & BigInt(0xff));
+                    d >>= BigInt(8);
+                }
+                chunks.push(depositBytes);
+                break;
+            }
+            case 'FunctionCall': {
+                const data = actionData;
+                chunks.push(this.borshString(data.methodName));
+                const argsJson = JSON.stringify(data.args);
+                const argsBytes = new TextEncoder().encode(argsJson);
+                const argsLength = new Uint8Array(4);
+                this.writeUint32LE(argsLength, 0, argsBytes.length);
+                chunks.push(argsLength);
+                chunks.push(argsBytes);
+                chunks.push(this.uint64LE(Number(data.gas)));
+                const deposit = BigInt(data.deposit || '0');
+                const depositBytes = new Uint8Array(16);
+                let d = deposit;
+                for (let i = 0; i < 16; i++) {
+                    depositBytes[i] = Number(d & BigInt(0xff));
+                    d >>= BigInt(8);
+                }
+                chunks.push(depositBytes);
+                break;
+            }
+        }
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+    createSignedTransaction(txBytes, signature) {
+        const sigStruct = new Uint8Array(65);
+        sigStruct[0] = 0; // ED25519 = 0
+        sigStruct.set(signature, 1);
+        const result = new Uint8Array(txBytes.length + sigStruct.length);
+        result.set(txBytes, 0);
+        result.set(sigStruct, txBytes.length);
+        return result;
+    }
+    async computeTransactionHash(txBytes) {
+        const hashBuffer = await crypto.subtle.digest('SHA-256', txBytes);
+        return this.bytesToBase58(new Uint8Array(hashBuffer));
+    }
+    async broadcastTransaction(signedTx) {
+        const response = await fetch(this.rpcUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'broadcast_tx_commit',
+                params: [this.bytesToBase64(signedTx)],
+            }),
+        });
+        const result = await response.json();
+        if (result.error) {
+            throw new Error(result.error.message || 'Transaction broadcast failed');
+        }
+        return result.result;
+    }
+    async getAccessKey(accountId, publicKey) {
+        const response = await fetch(this.rpcUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'query',
+                params: {
+                    request_type: 'view_access_key',
+                    finality: 'final',
+                    account_id: accountId,
+                    public_key: publicKey,
+                },
+            }),
+        });
+        const result = await response.json();
+        if (result.error) {
+            throw new Error(result.error.message || 'Failed to get access key');
+        }
+        return result.result;
+    }
+    async getRecentBlockHash() {
+        const response = await fetch(this.rpcUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'block',
+                params: { finality: 'final' },
+            }),
+        });
+        const result = await response.json();
+        if (result.error) {
+            throw new Error(result.error.message || 'Failed to get block');
+        }
+        const hashBase58 = result.result.header.hash;
+        return this.base58ToBytes(hashBase58);
+    }
+    // ===========================================================================
+    // Encoding Utilities
+    // ===========================================================================
+    writeUint32LE(buffer, offset, value) {
+        buffer[offset] = value & 0xff;
+        buffer[offset + 1] = (value >> 8) & 0xff;
+        buffer[offset + 2] = (value >> 16) & 0xff;
+        buffer[offset + 3] = (value >> 24) & 0xff;
+    }
+    bytesToHex(bytes) {
+        return Array.from(bytes)
+            .map(b => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
+    bytesToBase64(bytes) {
+        return btoa(String.fromCharCode(...bytes));
+    }
+    bytesToBase58(bytes) {
+        const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+        let num = BigInt(0);
+        for (const byte of bytes) {
+            num = num * BigInt(256) + BigInt(byte);
+        }
+        let result = '';
+        while (num > 0) {
+            const remainder = Number(num % BigInt(58));
+            num = num / BigInt(58);
+            result = ALPHABET[remainder] + result;
+        }
+        for (const byte of bytes) {
+            if (byte === 0) {
+                result = '1' + result;
+            }
+            else {
+                break;
+            }
+        }
+        return result;
+    }
+    base58ToBytes(str) {
+        const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+        let num = BigInt(0);
+        for (const char of str) {
+            const index = ALPHABET.indexOf(char);
+            if (index === -1)
+                throw new Error(`Invalid base58 character: ${char}`);
+            num = num * BigInt(58) + BigInt(index);
+        }
+        const bytes = [];
+        while (num > 0) {
+            bytes.unshift(Number(num % BigInt(256)));
+            num = num / BigInt(256);
+        }
+        for (const char of str) {
+            if (char === '1') {
+                bytes.unshift(0);
+            }
+            else {
+                break;
+            }
+        }
+        return new Uint8Array(bytes);
+    }
+}
+exports.LedgerWallet = LedgerWallet;
+function createLedgerWallet(config) {
+    return new LedgerWallet(config);
+}
+//# sourceMappingURL=ledger.js.map