@dfns/lib-ethersjs5 0.1.0-beta.1

package/index.d.ts

@@ -0,0 +1,20 @@
+import { DfnsApiClient } from '@dfns/sdk';
+import { Provider, TransactionRequest } from '@ethersproject/abstract-provider';
+import { Signer, TypedDataDomain, TypedDataField, TypedDataSigner } from '@ethersproject/abstract-signer';
+export type DfnsWalletOptions = {
+    walletId: string;
+    dfnsClient: DfnsApiClient;
+    maxRetries?: number;
+    retryInterval?: number;
+};
+export declare class DfnsWallet extends Signer implements TypedDataSigner {
+    private address?;
+    private options;
+    constructor(options: DfnsWalletOptions, provider?: Provider | null);
+    connect(provider: Provider | null): Signer;
+    getAddress(): Promise<string>;
+    waitForSignature(signatureId: string): Promise<string>;
+    signTransaction(transaction: TransactionRequest): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    _signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<string>;
+}

package/index.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsWallet = void 0;
+const Wallets_1 = require("@dfns/sdk/codegen/datamodel/Wallets");
+const address_1 = require("@ethersproject/address");
+const abstract_signer_1 = require("@ethersproject/abstract-signer");
+const bytes_1 = require("@ethersproject/bytes");
+const hash_1 = require("@ethersproject/hash");
+const keccak256_1 = require("@ethersproject/keccak256");
+const properties_1 = require("@ethersproject/properties");
+const transactions_1 = require("@ethersproject/transactions");
+const sleep = (interval = 0) => new Promise((resolve) => setTimeout(resolve, interval));
+class DfnsWallet extends abstract_signer_1.Signer {
+    constructor(options, provider) {
+        var _a, _b;
+        super();
+        this.options = {
+            ...options,
+            maxRetries: (_a = options.maxRetries) !== null && _a !== void 0 ? _a : 3,
+            retryInterval: (_b = options.retryInterval) !== null && _b !== void 0 ? _b : 1000,
+        };
+        (0, properties_1.defineReadOnly)(this, 'provider', provider || undefined);
+    }
+    connect(provider) {
+        return new DfnsWallet(this.options, provider);
+    }
+    async getAddress() {
+        var _a, _b;
+        if (!this.address) {
+            const { walletId, dfnsClient } = this.options;
+            const res = await dfnsClient.wallets.getWallet({ walletId });
+            if (!res.signingKey || res.signingKey.scheme !== Wallets_1.KeyScheme.ECDSA || res.signingKey.curve !== Wallets_1.KeyCurve.secp256k1) {
+                throw new Error(`wallet ${walletId} has incompatible scheme (${(_a = res.signingKey) === null || _a === void 0 ? void 0 : _a.scheme}) or curve (${(_b = res.signingKey) === null || _b === void 0 ? void 0 : _b.curve})`);
+            }
+            if (res.address) {
+                this.address = (0, address_1.getAddress)(res.address);
+            }
+            else {
+                this.address = (0, transactions_1.computeAddress)('0x' + res.signingKey.publicKey);
+            }
+        }
+        return this.address;
+    }
+    async waitForSignature(signatureId) {
+        const { walletId, dfnsClient, retryInterval } = this.options;
+        let maxRetries = this.options.maxRetries;
+        while (maxRetries > 0) {
+            await sleep(retryInterval);
+            const res = await dfnsClient.wallets.getSignature({ walletId, signatureId });
+            if (res.status === Wallets_1.SignatureStatus.Signed) {
+                if (!res.signature)
+                    break;
+                return (0, bytes_1.joinSignature)({
+                    r: res.signature.r,
+                    s: res.signature.s,
+                    recoveryParam: res.signature.recid,
+                });
+            }
+            else if (res.status === Wallets_1.SignatureStatus.Failed) {
+                break;
+            }
+            maxRetries -= 1;
+        }
+        throw new Error(`signature ${signatureId} not available`);
+    }
+    async signTransaction(transaction) {
+        return (0, properties_1.resolveProperties)(transaction).then(async (tx) => {
+            if (tx.from != null) {
+                if ((0, address_1.getAddress)(tx.from) !== (await this.getAddress())) {
+                    throw new Error('transaction from address mismatch');
+                }
+                delete tx.from;
+            }
+            const { walletId, dfnsClient } = this.options;
+            const res = await dfnsClient.wallets.generateSignature({
+                walletId,
+                body: { kind: Wallets_1.SignatureKind.Hash, hash: (0, keccak256_1.keccak256)((0, transactions_1.serialize)(tx)) },
+            });
+            const signature = await this.waitForSignature(res.id);
+            return (0, transactions_1.serialize)(tx, signature);
+        });
+    }
+    async signMessage(message) {
+        const { walletId, dfnsClient } = this.options;
+        const res = await dfnsClient.wallets.generateSignature({
+            walletId,
+            body: { kind: Wallets_1.SignatureKind.Hash, hash: (0, hash_1.hashMessage)(message) },
+        });
+        return this.waitForSignature(res.id);
+    }
+    async _signTypedData(domain, types, value) {
+        // Populate any ENS names
+        const populated = await hash_1._TypedDataEncoder.resolveNames(domain, types, value, async (name) => {
+            if (!this.provider) {
+                throw new Error('cannot resolve ENS names without a provider');
+            }
+            const resolved = await this.provider.resolveName(name);
+            if (!resolved)
+                throw new Error(`unconfigured ENS name ${name}`);
+            return resolved;
+        });
+        const { walletId, dfnsClient } = this.options;
+        const res = await dfnsClient.wallets.generateSignature({
+            walletId,
+            body: {
+                kind: Wallets_1.SignatureKind.Hash,
+                hash: hash_1._TypedDataEncoder.hash(populated.domain, types, populated.value),
+            },
+        });
+        return this.waitForSignature(res.id);
+    }
+}
+exports.DfnsWallet = DfnsWallet;

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@dfns/lib-ethersjs5",
+  "version": "0.1.0-beta.1",
+  "dependencies": {
+    "@ethersproject/abstract-provider": "5.7.0",
+    "@ethersproject/abstract-signer": "5.7.0",
+    "@ethersproject/address": "5.7.0",
+    "@ethersproject/bytes": "5.7.0",
+    "@ethersproject/hash": "5.7.0",
+    "@ethersproject/keccak256": "5.7.0",
+    "@ethersproject/properties": "5.7.0",
+    "@ethersproject/transactions": "5.7.0",
+    "buffer": "6.0.3",
+    "cross-fetch": "3.1.6",
+    "uuid": "9.0.0"
+  },
+  "peerDependencies": {
+    "@dfns/sdk": "0.1.0-beta.1"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}