@dfns/lib-ethersjs6 0.1.0-beta.1

package/index.d.ts

@@ -0,0 +1,19 @@
+import { DfnsApiClient } from '@dfns/sdk';
+import { AbstractSigner, Provider, Signer, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
+export type DfnsWalletOptions = {
+    walletId: string;
+    dfnsClient: DfnsApiClient;
+    maxRetries?: number;
+    retryInterval?: number;
+};
+export declare class DfnsWallet extends AbstractSigner {
+    private address?;
+    private options;
+    constructor(options: DfnsWalletOptions, provider?: Provider | null);
+    connect(provider: Provider | null): Signer;
+    getAddress(): Promise<string>;
+    waitForSignature(signatureId: string): Promise<string>;
+    signTransaction(tx: 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,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsWallet = void 0;
+const Wallets_1 = require("@dfns/sdk/codegen/datamodel/Wallets");
+const ethers_1 = require("ethers");
+const sleep = (interval = 0) => new Promise((resolve) => setTimeout(resolve, interval));
+class DfnsWallet extends ethers_1.AbstractSigner {
+    constructor(options, provider) {
+        var _a, _b;
+        super(provider);
+        this.options = {
+            ...options,
+            maxRetries: (_a = options.maxRetries) !== null && _a !== void 0 ? _a : 3,
+            retryInterval: (_b = options.retryInterval) !== null && _b !== void 0 ? _b : 1000,
+        };
+    }
+    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, ethers_1.getAddress)(res.address);
+            }
+            else {
+                this.address = (0, ethers_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 ethers_1.Signature.from({
+                    r: res.signature.r,
+                    s: res.signature.s,
+                    v: res.signature.recid ? 0x1c : 0x1b,
+                }).serialized;
+            }
+            else if (res.status === Wallets_1.SignatureStatus.Failed) {
+                break;
+            }
+            maxRetries -= 1;
+        }
+        throw new Error(`signature ${signatureId} not available`);
+    }
+    async signTransaction(tx) {
+        // replace any Addressable or ENS name with an address
+        const { to, from } = await (0, ethers_1.resolveProperties)({
+            to: tx.to ? (0, ethers_1.resolveAddress)(tx.to, this.provider) : undefined,
+            from: tx.from ? (0, ethers_1.resolveAddress)(tx.from, this.provider) : undefined,
+        });
+        if (to != null) {
+            tx.to = to;
+        }
+        if (from != null) {
+            tx.from = from;
+        }
+        if (tx.from != null) {
+            if ((0, ethers_1.getAddress)(tx.from) !== (await this.getAddress())) {
+                throw new Error('transaction from address mismatch');
+            }
+            delete tx.from;
+        }
+        const btx = ethers_1.Transaction.from(tx);
+        const { walletId, dfnsClient } = this.options;
+        const res = await dfnsClient.wallets.generateSignature({
+            walletId,
+            body: { kind: Wallets_1.SignatureKind.Hash, hash: btx.unsignedHash },
+        });
+        btx.signature = await this.waitForSignature(res.id);
+        return btx.serialized;
+    }
+    async signMessage(message) {
+        const { walletId, dfnsClient } = this.options;
+        const res = await dfnsClient.wallets.generateSignature({
+            walletId,
+            body: { kind: Wallets_1.SignatureKind.Hash, hash: (0, ethers_1.hashMessage)(message) },
+        });
+        return this.waitForSignature(res.id);
+    }
+    async signTypedData(domain, types, value) {
+        // Populate any ENS names
+        const populated = await ethers_1.TypedDataEncoder.resolveNames(domain, types, value, async (name) => {
+            if (!this.provider) {
+                throw new Error('cannot resolve ENS names without a provider');
+            }
+            const address = await this.provider.resolveName(name);
+            if (!address)
+                throw new Error(`unconfigured ENS name ${name}`);
+            return address;
+        });
+        const { walletId, dfnsClient } = this.options;
+        const res = await dfnsClient.wallets.generateSignature({
+            walletId,
+            body: {
+                kind: Wallets_1.SignatureKind.Hash,
+                hash: ethers_1.TypedDataEncoder.hash(populated.domain, types, populated.value),
+            },
+        });
+        return this.waitForSignature(res.id);
+    }
+}
+exports.DfnsWallet = DfnsWallet;

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@dfns/lib-ethersjs6",
+  "version": "0.1.0-beta.1",
+  "dependencies": {
+    "buffer": "6.0.3",
+    "cross-fetch": "3.1.6",
+    "ethers": "6.6.1",
+    "uuid": "9.0.0"
+  },
+  "peerDependencies": {
+    "@dfns/sdk": "0.1.0-beta.1"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}