dequanto 0.1.39 → 0.1.45

package/src/utils/$secret.ts

@@ -1,14 +1,14 @@
 import { $machine } from './$machine';
 
 export namespace $secret {
-    export async function getPin(parameters?: { pin?: string }) {
+    export async function getPin(parameters?: { pin?: string, machineKey?: string }) {
 
         let pin = parameters?.pin ?? getPinFromCli() ?? getPinFromEnv();
         if (pin == null || pin.length === 0) {
             return null;
         }
-        let id = await $machine.id();
-        return `${id}:${pin}`;
+        let machineKey = parameters?.machineKey ?? getMachineKeyFromCli() ?? getMachineKeyFromEnv() ?? await $machine.id();
+        return `${machineKey}:${pin}`;
     }
 
     function getPinFromCli () {
@@ -24,4 +24,17 @@ export namespace $secret {
     function getPinFromEnv () {
         return process.env.PIN;
     }
+    function getMachineKeyFromCli () {
+        let args = process.argv;
+        for (let i = 0; i < args.length - 1; i++) {
+            let key = args[i].replace(/^\-+/, '');
+            if (key === 'machineKey' || key ==='machine-key') {
+                return args[i + 1];
+            }
+        }
+        return null;
+    }
+    function getMachineKeyFromEnv () {
+        return process.env.MACHINE_KEY;
+    }
 }

package/src/utils/$sig.ts

@@ -24,30 +24,29 @@ export namespace $sig {
         if (account.key != null) {
             return await KeyUtils.withKey(account, account => $ec.$eip191.signTypedData(typedData, account));
         }
-        return $rpc.signTypedData(rpc, typedData, account);
+        let signer = await $rpc.ensureRpcSigner(account, rpc);
+        return $rpc.signTypedData(signer, typedData, account);
     }
     export async function sign(message: string | Uint8Array, account: TEth.EoAccount, rpc?: Rpc): Promise<TSignature> {
         if (account.key != null) {
             return await KeyUtils.withKey(account, account => $ec.sign(message, account));
         }
-        return $rpc.sign(rpc, message, account);
+        let signer = await $rpc.ensureRpcSigner(account, rpc);
+        return $rpc.sign(signer, message, account);
     }
     export async function signMessage(message: string | Uint8Array, account: TEth.EoAccount, mix?: Rpc | Web3Client): Promise<TSignature> {
         if (account.key != null) {
             return await KeyUtils.withKey(account, account => $ec.$eip191.signMessage(message, account));
         }
-        let rpc = 'getRpc' in mix
-            ? await mix.getRpc()
-            : mix;
-        return $rpc.signMessage(rpc, message, account);
+        let signer = await $rpc.ensureRpcSigner(account, mix);
+        return $rpc.signMessage(signer, message, account);
     }
     export async function signTx(tx: TEth.TxLike, account: TEth.EoAccount, rpc?: Rpc): Promise<TEth.Hex> {
         tx.from ??= account.address;
 
         if ($hex.isEmpty(account.key)) {
-            $require.notNull(rpc, `The account has no private key locally, and the RPC handler is not provided`);
-
-            return $rpc.signTx(rpc, tx);
+            let signer = await $rpc.ensureRpcSigner(account, rpc);
+            return $rpc.signTx(signer, tx);
         }
         return await KeyUtils.withKey(account, account => $ec.signTx(tx, account));
     }
@@ -70,6 +69,16 @@ export namespace $sig {
     }
 
     export namespace $rpc {
+
+        export async function ensureRpcSigner (account: TEth.EoAccount, mix: Rpc | Web3Client): Promise<Rpc> {
+            if (account.signer) {
+                return account.signer as any;
+            }
+            $require.notNull(mix, `Rpc signer is not provided for ${account.address}`);
+            let rpc = 'getRpc' in mix ? await mix.getRpc() : mix;
+            return rpc;
+        }
+
         export async function signTx(rpc: Rpc, tx: TEth.TxLike): Promise<TEth.Hex> {
             let body = {
                 type: $hex.ensure(tx.type),
@@ -264,7 +273,7 @@ export namespace $sig {
             let r = '0x' + signature.substring(2, 2 + 64);
             let s = '0x' + signature.substring(2 + 64, 2 + 64 + 64);
             let v = '0x' + signature.substring(2 + 64 + 64);
-            return { r, s, v } as TSignature;
+            return { r, s, v, signature } as TSignature;
         }
 
         export function toUint8Array(message: string | Uint8Array, opts?: { encoding?: 'utf8' | 'hex' }): Uint8Array {

package/src/wallets/EIP6963ProviderFactory.ts

@@ -0,0 +1,252 @@
+import alot from 'alot';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TEth } from '@dequanto/models/TEth';
+import { $address } from '@dequanto/utils/$address';
+import { $ref, TGlobal } from '@dequanto/utils/$ref';
+import { $require } from '@dequanto/utils/$require';
+import { class_EventEmitter } from 'atma-utils';
+import { IEIP6963Provider } from '@dequanto/rpc/transports/compatibility/IEIP6963Provider';
+
+// Interface for provider information following EIP-6963.
+interface EIP6963ProviderInfo {
+    rdns?: string; // Unique identifier for the wallet e.g io.metamask, io.metamask.flask
+    uuid: string; // Globally unique ID to differentiate between provider sessions for the lifetime of the page
+    name: string; // Human-readable name of the wallet
+    icon?: string; // URL to the wallet's icon
+    chainId?: number;
+}
+
+// Interface for Ethereum providers based on the EIP-1193 standard.
+
+// Interface detailing the structure of provider information and its Ethereum provider.
+export interface EIP6963ProviderDetail {
+    info: EIP6963ProviderInfo; // The provider's info
+    provider: IEIP6963Provider; // The EIP-1193 compatible provider
+    accounts?: TEth.Address[]; // Optional: Array of connected Ethereum accounts
+}
+
+// Type representing the event structure for announcing a provider based on EIP-6963.
+type EIP6963AnnounceProviderEvent = {
+    detail: EIP6963ProviderDetail
+}
+
+
+interface IProviderEvents {
+    onProviderRegistered: (detail: EIP6963ProviderDetail) => void;
+    onProviderConnected: (detail: EIP6963ProviderDetail, chainId: number) => void;
+
+    onAccountsConnected: (detail: EIP6963ProviderDetail, accounts: TAddress[]) => void;
+    onAccountsDisconnected: (detail: EIP6963ProviderDetail) => void;
+
+
+    onChainChanged: (detail: EIP6963ProviderDetail, chainId: number) => void;
+    onAccountsChanged: (detail: EIP6963ProviderDetail, accounts: TEth.Address[]) => void;
+}
+
+
+export class EIP6963ProviderFactory extends class_EventEmitter<IProviderEvents> {
+
+    private listeners = {} as Record<string, {
+        accountsChanged,
+        chainChanged,
+        connect,
+        disconnect
+    }>
+
+    providers: EIP6963ProviderDetail[] = []
+    selected: EIP6963ProviderDetail;
+
+    global: TGlobal = $ref.getGlobal()
+
+    constructor () {
+        super();
+
+        this.onAnnounceProvider = this.onAnnounceProvider.bind(this);
+        this.listenToNewProvider();
+        this.requestProvider();
+    }
+
+    isConnected (address?: TEth.Address) {
+        let has = this.providers.some(x => {
+            return address != null
+                ? x.accounts?.some(account => $address.eq(account, address) )
+                : x.accounts?.length > 0;
+        });
+        return has;
+    }
+
+    async connect (id?: string) {
+        let provider = this.getProviderOrFirst(id);
+        $require.notNull(provider, `Wallet not found`);
+        this.selected = provider;
+        let accounts = await this.requestAccounts();
+        return accounts;
+    }
+
+    disconnect () {
+        let selected = this.selected;
+        this.selected = null;
+        this.emit('onAccountsDisconnected', selected);
+    }
+
+    useProvider (id: string) {
+        this.selected = this.getProvider(id);
+    }
+
+    getProviders () {
+        return this.providers;
+    }
+
+    async requestAccounts (id?: string): Promise<TEth.Address[]> {
+        let provider = await this.getProvider(id);
+        let accounts: TEth.Address[] = await this.selected.provider.request({ method: 'eth_requestAccounts' });
+        if (accounts?.length > 0) {
+            let arr = [
+                ...(provider.accounts ?? []),
+                ...(accounts),
+            ]
+            .filter(Boolean)
+            .map(String) as TEth.Address[];
+
+            provider.accounts = alot(arr).distinct().toArray();
+            this.emit('onAccountsConnected', provider, provider.accounts);
+        }
+        return provider.accounts;
+    }
+
+    private requestProvider () {
+        if (typeof this.global.ethereum?.request === 'function') {
+            this.onAnnounceProvider({
+                detail: {
+                    info: {
+                        rdns: 'injected',
+                        uuid: 'injected',
+                        name: 'Browser Wallet'
+                    },
+                    provider: this.global.ethereum,
+                }
+            });
+        }
+        this.global.dispatchEvent(new CustomEvent('eip6963:requestProvider'));
+
+    }
+    private listenToNewProvider () {
+        this.global.addEventListener('eip6963:announceProvider',  this.onAnnounceProvider as any);
+    }
+
+    private async onAnnounceProvider (event: EIP6963AnnounceProviderEvent) {
+        let injectedProvider = this.providers.find(x => x.info?.rdns === 'injected');
+        if (injectedProvider) {
+            // Remove directly injected provider
+            this.providers = this.providers.filter(x => x.info?.rdns !== 'injected');
+            this.removeEventListeners(injectedProvider);
+        }
+
+        let { detail } = event;
+        let { info, provider } = detail;
+        if (this.providers.some(x => this.getId(x.info) === this.getId(info))) {
+            return;
+        }
+
+        let providerDetails = { info, provider, accounts: [] };
+        this.providers.push(providerDetails);
+        this.addEventListeners(providerDetails);
+
+        try {
+            const accounts = await provider.request({ method: 'eth_accounts' })
+            if (accounts?.length > 0) {
+                providerDetails.accounts = accounts;
+                this.emit('onAccountsConnected', providerDetails, accounts);
+            }
+        } catch (error) {
+            // We load the accounts just in case if user has already connected previously, otherwise silently ignore the error
+        }
+        try {
+            const chainId = await provider.request({ method: 'eth_chainId' })
+            providerDetails.info.chainId = Number(chainId);
+        } catch (error) {
+            // silently ignore the error
+        }
+
+        this.emit('onProviderRegistered', providerDetails);
+    }
+
+    getProviderOrFirst (id?: string) {
+        if (id == null) {
+            return this.providers[0];
+        }
+        let provider = this.providers.find(x => this.getId(x.info) === id);
+        return provider;
+    }
+    getProvider (id?: string, optional?: boolean) {
+        if (id == null) {
+            optional !== true && $require.notNull(this.selected, `Wallet is not connected`);
+            return this.selected;
+        }
+        let provider = this.providers.find(x => this.getId(x.info) === id);
+        optional !== true && $require.notNull(provider, `Wallet is not found by ID ${id}`);
+        return provider;
+    }
+
+    private getId (info: EIP6963ProviderInfo | null) {
+        return info?.rdns ?? info?.name;
+    }
+
+    private addEventListeners (providerDetails: EIP6963ProviderDetail) {
+        let id = this.getId(providerDetails.info);
+        if (id in this.listeners) {
+            return;
+        }
+        const fns = {
+            accountsChanged: accounts => {
+                providerDetails.accounts = accounts;
+                this.emit('onAccountsChanged', providerDetails, accounts as TEth.Address[]);
+            },
+            chainChanged: chainId => {
+                this.emit('onChainChanged', providerDetails, Number(chainId));
+            },
+            disconnect: () => {
+                this.emit('onAccountsDisconnected', providerDetails);
+            },
+            connect: (info) => {
+                this.emit('onProviderConnected', providerDetails, info.chainId);
+            },
+        }
+        let boundFnKey: 'on' | 'addEventListener';
+        let provider = providerDetails.provider;
+
+        if (typeof provider.on === 'function') {
+            boundFnKey = 'on';
+        } else if (typeof (provider as any).addEventListener === 'function') {
+            boundFnKey = 'addEventListener';
+        }
+        if (boundFnKey == null) {
+            return;
+        }
+        for (let event in fns) {
+            provider[boundFnKey](event, fns[event]);
+        }
+        this.listeners[id] = fns;
+    }
+
+    private removeEventListeners (providerDetails: EIP6963ProviderDetail) {
+        let id = this.getId(providerDetails.info);
+        if (id in this.listeners === false) {
+            return;
+        }
+
+        let unboundFnKey: 'removeListener' | 'removeEventListener';
+        let provider = providerDetails.provider;
+        if (typeof provider.removeListener === 'function') {
+            unboundFnKey = 'removeListener';
+        } else if (typeof (provider as any).removeEventListener === 'function') {
+            unboundFnKey = 'removeEventListener';
+        }
+
+        let fns = this.listeners[id];
+        for (let event in fns) {
+            provider[unboundFnKey](event as any, fns[event]);
+        }
+        delete this.listeners[id];
+    }
+}

package/src/wallets/Signer.ts

@@ -0,0 +1,32 @@
+import { TEth } from '@dequanto/models/TEth';
+import { Rpc, RpcTypes } from '@dequanto/rpc/Rpc';
+
+
+export class Signer implements TEth.IRpcSigner {
+    constructor(public opts: {
+        rpc?: Rpc,
+    } & Partial<TEth.IRpcSigner> ) {
+
+    }
+    eth_sign(account: TEth.Address, data: TEth.Hex): Promise<TEth.Hex> {
+        return this.call('eth_sign', [account, data]);
+    }
+    eth_signTransaction(tx: TEth.TxLike): Promise<TEth.Hex> {
+        return this.call('eth_signTransaction', [tx]);
+    }
+    eth_signTypedData_v4(address: TEth.Address, typedData: Partial<RpcTypes.TypedData>): Promise<TEth.Hex> {
+        return this.call('eth_signTypedData_v4', [address, typedData]);
+    }
+    personal_sign(challenge: string, address: TEth.Address): Promise<TEth.Hex> {
+        return this.call('personal_sign', [challenge, address]);
+    }
+
+    protected call (method: keyof TEth.IRpcSigner, params: any[]): Promise<any> {
+        let fn = this.opts[method] ?? this.opts.rpc[method];
+
+        if (typeof fn === 'function') {
+            return (fn as any)(...params);
+        }
+        throw new Error(`Method ${method} not found in Signer`);
+    }
+}

package/lib/cjs/wallets/WalletBsc.js

@@ -1,19 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WalletBsc = void 0;
-const a_di_1 = __importDefault(require("a-di"));
-const BscWeb3Client_1 = require("../clients/BscWeb3Client.js");
-const Wallet_1 = require("./Wallet.js");
-const Bscscan_1 = require("../explorer/Bscscan.js");
-/** @deprecated use generic Wallet.ts */
-class WalletBsc extends Wallet_1.Wallet {
-    constructor(account) {
-        super(account, a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client), a_di_1.default.resolve(Bscscan_1.Bscscan));
-    }
-}
-exports.WalletBsc = WalletBsc;
-//# sourceMappingURL=WalletBsc.js.map
-//# sourceMappingURL=WalletBsc.ts.map

package/lib/cjs/wallets/WalletBsc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WalletBsc.js","sourceRoot":"","sources":["../../../src/wallets/WalletBsc.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAsB;AACtB,mEAAgE;AAChE,qCAAkC;AAClC,wDAAqD;AAIrD,wCAAwC;AACxC,MAAa,SAAU,SAAQ,eAAM;IACjC,YAAa,OAAmD;QAC5D,KAAK,CAAC,OAAO,EAAE,cAAE,CAAC,OAAO,CAAC,6BAAa,CAAC,EAAE,cAAE,CAAC,OAAO,CAAC,iBAAO,CAAC,CAAC,CAAC;IACnE,CAAC;CACJ;AAJD,8BAIC"}

package/lib/esm/wallets/WalletBsc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WalletBsc.js","sourceRoot":"","sources":["../../../src/wallets/WalletBsc.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAsB;AACtB,mEAAgE;AAChE,qCAAkC;AAClC,wDAAqD;AAIrD,wCAAwC;AACxC,MAAa,SAAU,SAAQ,eAAM;IACjC,YAAa,OAAmD;QAC5D,KAAK,CAAC,OAAO,EAAE,cAAE,CAAC,OAAO,CAAC,6BAAa,CAAC,EAAE,cAAE,CAAC,OAAO,CAAC,iBAAO,CAAC,CAAC,CAAC;IACnE,CAAC;CACJ;AAJD,8BAIC"}

package/lib/esm/wallets/WalletBsc.mjs

@@ -1,12 +0,0 @@
-import di from 'a-di';
-import { BscWeb3Client } from '../clients/BscWeb3Client.mjs';
-import { Wallet } from './Wallet.mjs';
-import { Bscscan } from '../explorer/Bscscan.mjs';
-/** @deprecated use generic Wallet.ts */
-export class WalletBsc extends Wallet {
-    constructor(account) {
-        super(account, di.resolve(BscWeb3Client), di.resolve(Bscscan));
-    }
-}
-//# sourceMappingURL=WalletBsc.js.map
-//# sourceMappingURL=WalletBsc.ts.map

package/lib/types/wallets/WalletBsc.d.ts

@@ -1,10 +0,0 @@
-import { Wallet } from './Wallet';
-import { TPlatform } from '../models/TPlatform';
-import { TAddress } from '../models/TAddress';
-/** @deprecated use generic Wallet.ts */
-export declare class WalletBsc extends Wallet {
-    constructor(account: {
-        platform: TPlatform;
-        address: TAddress;
-    });
-}

package/src/wallets/WalletBsc.ts

@@ -1,13 +0,0 @@
-import di from 'a-di';
-import { BscWeb3Client } from '@dequanto/clients/BscWeb3Client';
-import { Wallet } from './Wallet';
-import { Bscscan } from '@dequanto/explorer/Bscscan';
-import { TPlatform } from '@dequanto/models/TPlatform';
-import { TAddress } from '@dequanto/models/TAddress';
-
-/** @deprecated use generic Wallet.ts */
-export class WalletBsc extends Wallet {
-    constructor (account: { platform: TPlatform, address: TAddress },) {
-        super(account, di.resolve(BscWeb3Client), di.resolve(Bscscan));
-    }
-}