@dfns/lib-ethersjs6 0.1.2 → 0.1.3-rc.2

package/index.d.ts

@@ -3,16 +3,22 @@ import { AbstractSigner, Provider, Signer, TransactionRequest, TypedDataDomain,
 export type DfnsWalletOptions = {
     walletId: string;
     dfnsClient: DfnsApiClient;
+    /** @deprecated transaction signing is now synchronous. polling is deprecated. */
     maxRetries?: number;
+    /** @deprecated transaction signing is now synchronous. polling is deprecated. */
     retryInterval?: number;
 };
 export declare class DfnsWallet extends AbstractSigner {
-    private address?;
     private options;
+    private address?;
+    private metadata?;
+    /** @deprecated use DfnsWallet.init(options) instead */
     constructor(options: DfnsWalletOptions, provider?: Provider | null);
+    static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
     connect(provider: Provider | null): Signer;
+    private getCachedMetadata;
     getAddress(): Promise<string>;
-    waitForSignature(signatureId: string): Promise<string>;
+    private signHash;
     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

@@ -1,59 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfnsWallet = void 0;
-const Wallets_1 = require("@dfns/sdk/codegen/datamodel/Wallets");
+const sdk_1 = require("@dfns/sdk");
 const ethers_1 = require("ethers");
-const sleep = (interval = 0) => new Promise((resolve) => setTimeout(resolve, interval));
+const assertSigned = (res) => {
+    if (res.status === 'Failed') {
+        throw new sdk_1.DfnsError(-1, 'signing failed', res);
+    }
+    else if (res.status !== 'Signed') {
+        throw new sdk_1.DfnsError(-1, 'cannot complete signing synchronously because this wallet action requires policy approval', res);
+    }
+};
+const combineSignature = (res) => {
+    if (!res.signature) {
+        throw new sdk_1.DfnsError(-1, 'signature missing', res);
+    }
+    const { r, s, recid } = res.signature;
+    return ethers_1.Signature.from({
+        r,
+        s,
+        v: recid ? 0x1c : 0x1b,
+    }).serialized;
+};
+const boundToEvmNetwork = (wallet) => {
+    // if the address is evm format, it's a wallet bound to evm network. prefer to
+    // sign the full transaction instead of the hash of the transaction
+    return wallet.address ? !!wallet.address.match(/^0x[0-9a-fA-F]{40}$/) : false;
+};
+const fetchWalletMetadata = async (options) => {
+    const { walletId, dfnsClient } = options;
+    const wallet = await dfnsClient.wallets.getWallet({ walletId });
+    if (wallet.status !== 'Active') {
+        throw new sdk_1.DfnsError(-1, 'wallet not active', { walletId, status: wallet.status });
+    }
+    const { scheme, curve } = wallet.signingKey;
+    if (scheme !== 'ECDSA') {
+        throw new sdk_1.DfnsError(-1, 'key scheme is not ECDSA', { walletId, scheme });
+    }
+    if (curve !== 'secp256k1') {
+        throw new sdk_1.DfnsError(-1, 'key curve is not secp256k1', { walletId, curve });
+    }
+    return {
+        boundToEvmNetwork: boundToEvmNetwork(wallet),
+        ...wallet,
+    };
+};
 class DfnsWallet extends ethers_1.AbstractSigner {
+    /** @deprecated use DfnsWallet.init(options) instead */
     constructor(options, provider) {
         super(provider);
-        this.options = {
-            ...options,
-            maxRetries: options.maxRetries ?? 3,
-            retryInterval: options.retryInterval ?? 1000,
-        };
+        this.options = options;
+    }
+    static async init(options) {
+        const metadata = await fetchWalletMetadata(options);
+        const wallet = new DfnsWallet(options);
+        wallet.metadata = metadata;
+        return wallet;
     }
     connect(provider) {
-        return new DfnsWallet(this.options, provider);
+        const copy = new DfnsWallet(this.options, provider);
+        copy.address = this.address;
+        copy.metadata = this.metadata;
+        return copy;
+    }
+    async getCachedMetadata() {
+        if (!this.metadata) {
+            this.metadata = await fetchWalletMetadata(this.options);
+        }
+        return this.metadata;
     }
     async getAddress() {
         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 (${res.signingKey?.scheme}) or curve (${res.signingKey?.curve})`);
-            }
-            if (res.address) {
-                this.address = (0, ethers_1.getAddress)(res.address);
-            }
-            else {
-                this.address = (0, ethers_1.computeAddress)('0x' + res.signingKey.publicKey);
-            }
+            const metadata = await this.getCachedMetadata();
+            this.address = metadata.boundToEvmNetwork
+                ? (0, ethers_1.getAddress)(metadata.address)
+                : (0, ethers_1.computeAddress)('0x' + metadata.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;
-        }
-        const waitedSeconds = Math.floor((this.options.maxRetries * retryInterval) / 1000);
-        throw new Error(`Signature request ${signatureId} took more than ${waitedSeconds}s to complete, stopping polling. Please update options "maxRetries" or "retryIntervals" to wait longer.`);
+    async signHash(hash) {
+        const { walletId, dfnsClient } = this.options;
+        const res = await dfnsClient.wallets.generateSignature({
+            walletId,
+            body: { kind: 'Hash', hash },
+        });
+        assertSigned(res);
+        return combineSignature(res);
     }
     async signTransaction(tx) {
         // replace any Addressable or ENS name with an address
@@ -74,21 +106,39 @@ class DfnsWallet extends ethers_1.AbstractSigner {
             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;
+        const metadata = await this.getCachedMetadata();
+        if (metadata.boundToEvmNetwork) {
+            const res = await this.options.dfnsClient.wallets.generateSignature({
+                walletId: metadata.id,
+                body: { kind: 'Transaction', transaction: btx.unsignedSerialized },
+            });
+            assertSigned(res);
+            if (!res.signedData) {
+                throw new sdk_1.DfnsError(-1, 'signedData missing', res);
+            }
+            return res.signedData;
+        }
+        else {
+            btx.signature = await this.signHash(btx.unsignedHash);
+            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);
+        const metadata = await this.getCachedMetadata();
+        if (metadata.boundToEvmNetwork) {
+            if (typeof message === 'string') {
+                message = (0, ethers_1.toUtf8Bytes)(message);
+            }
+            const res = await this.options.dfnsClient.wallets.generateSignature({
+                walletId: metadata.id,
+                body: { kind: 'Message', message: (0, ethers_1.hexlify)(message) },
+            });
+            assertSigned(res);
+            return combineSignature(res);
+        }
+        else {
+            return this.signHash((0, ethers_1.hashMessage)(message));
+        }
     }
     async signTypedData(domain, types, value) {
         // Populate any ENS names
@@ -101,15 +151,29 @@ class DfnsWallet extends ethers_1.AbstractSigner {
                 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);
+        const metadata = await this.getCachedMetadata();
+        if (metadata.boundToEvmNetwork) {
+            const res = await this.options.dfnsClient.wallets.generateSignature({
+                walletId: metadata.id,
+                body: {
+                    kind: 'Eip712',
+                    types,
+                    domain: {
+                        name: populated.domain.name ?? undefined,
+                        version: populated.domain.version ?? undefined,
+                        chainId: populated.domain.chainId ? (0, ethers_1.getNumber)(populated.domain.chainId) : undefined,
+                        verifyingContract: populated.domain.verifyingContract ?? undefined,
+                        salt: populated.domain.salt ? (0, ethers_1.hexlify)(populated.domain.salt) : undefined,
+                    },
+                    message: populated.value,
+                },
+            });
+            assertSigned(res);
+            return combineSignature(res);
+        }
+        else {
+            return this.signHash(ethers_1.TypedDataEncoder.hash(populated.domain, types, populated.value));
+        }
     }
 }
 exports.DfnsWallet = DfnsWallet;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@dfns/lib-ethersjs6",
-  "version": "0.1.2",
+  "version": "0.1.3-rc.2",
   "dependencies": {
     "buffer": "6.0.3",
     "cross-fetch": "3.1.6",
-    "ethers": "6.6.1",
+    "ethers": "6.9.0",
     "uuid": "9.0.0"
   },
   "peerDependencies": {
-    "@dfns/sdk": "0.1.2"
+    "@dfns/sdk": "0.1.3-rc.2"
   },
   "main": "./index.js",
   "type": "commonjs"