@dfns/lib-near 0.7.6

package/index.d.ts

@@ -0,0 +1,22 @@
+import { DfnsApiClient } from '@dfns/sdk';
+import { PublicKey } from '@near-js/crypto';
+import { SignedMessage, Signer } from '@near-js/signers';
+import { Transaction, SignedTransaction, DelegateAction, SignedDelegate } from '@near-js/transactions';
+export declare const hexToBuffer: (hex: string) => Buffer;
+export type DfnsWalletOptions = {
+    walletId: string;
+    dfnsClient: DfnsApiClient;
+};
+export declare class DfnsWallet implements Signer {
+    private metadata;
+    private readonly dfnsClient;
+    static supportedNetworks: string[];
+    private constructor();
+    getPublicKey(): Promise<PublicKey>;
+    get address(): string;
+    get publicKeyHex(): string;
+    signNep413Message(_message: string, _accountId: string, _recipient: string, _nonce: Uint8Array, _callbackUrl?: string): Promise<SignedMessage>;
+    signTransaction(transaction: Transaction): Promise<[Uint8Array, SignedTransaction]>;
+    signDelegateAction(_delegateAction: DelegateAction): Promise<[Uint8Array, SignedDelegate]>;
+    static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
+}

package/index.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsWallet = exports.hexToBuffer = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const sdk_1 = require("@dfns/sdk");
+const crypto_1 = require("@near-js/crypto");
+const transactions_1 = require("@near-js/transactions");
+const utils_1 = require("@near-js/utils");
+const sha2_1 = require("@noble/hashes/sha2");
+const hexToBuffer = (hex) => {
+    return Buffer.from(stripHexPrefix(hex), 'hex');
+};
+exports.hexToBuffer = hexToBuffer;
+const stripHexPrefix = (hex) => {
+    return hex.replace(/^0x/, '');
+};
+const assertSigned = (response) => {
+    if (response.status === 'Failed') {
+        throw new sdk_1.DfnsError(-1, 'signing failed', response);
+    }
+    else if (response.status !== 'Signed') {
+        throw new sdk_1.DfnsError(-1, 'cannot complete signing synchronously because this wallet action requires policy approval', response);
+    }
+    else if (!response.signature || !response.signature.encoded) {
+        throw new sdk_1.DfnsError(-1, 'signature missing', response);
+    }
+};
+class DfnsWallet {
+    constructor(metadata, options) {
+        this.metadata = metadata;
+        this.dfnsClient = options.dfnsClient;
+    }
+    async getPublicKey() {
+        const publicKeyBytes = Buffer.from(this.metadata.signingKey.publicKey, 'hex');
+        return new crypto_1.PublicKey({
+            keyType: crypto_1.KeyType.ED25519,
+            data: (0, exports.hexToBuffer)(this.metadata.address),
+        });
+    }
+    get address() {
+        if (!this.metadata.address) {
+            throw new sdk_1.DfnsError(-1, 'wallet address missing from metadata');
+        }
+        return this.metadata.address;
+    }
+    get publicKeyHex() {
+        return this.metadata.signingKey.publicKey;
+    }
+    signNep413Message(_message, _accountId, _recipient, _nonce, _callbackUrl) {
+        throw new Error('Method not implemented.');
+    }
+    async signTransaction(transaction) {
+        const res = await this.dfnsClient.wallets.generateSignature({
+            walletId: this.metadata.id,
+            body: {
+                kind: 'Transaction',
+                transaction: '0x' + Buffer.from(transaction.encode()).toString('hex'),
+            },
+        });
+        assertSigned(res);
+        if (!res.signedData) {
+            throw new sdk_1.DfnsError(-1, 'signedData missing', res);
+        }
+        const signedTransaction = transactions_1.SignedTransaction.decode((0, exports.hexToBuffer)(res.signedData));
+        const txHash = (0, utils_1.baseEncode)((0, sha2_1.sha256)((0, transactions_1.encodeTransaction)(signedTransaction.transaction)));
+        return [
+            (0, exports.hexToBuffer)(txHash),
+            signedTransaction,
+        ];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    signDelegateAction(_delegateAction) {
+        throw new Error('Method not implemented.');
+    }
+    static async init(options) {
+        const { walletId, dfnsClient } = options;
+        const res = await dfnsClient.wallets.getWallet({ walletId });
+        if (res.status !== 'Active') {
+            throw new sdk_1.DfnsError(-1, 'wallet not active', { walletId, status: res.status });
+        }
+        if (!DfnsWallet.supportedNetworks.includes(res.network)) {
+            throw new sdk_1.DfnsError(-1, 'wallet is not bound to a Near compatible network', {
+                walletId,
+                network: res.network,
+            });
+        }
+        if (!res.address) {
+            throw new sdk_1.DfnsError(-1, 'wallet address missing', { walletId });
+        }
+        return new DfnsWallet(res, options);
+    }
+}
+exports.DfnsWallet = DfnsWallet;
+DfnsWallet.supportedNetworks = ['Near', 'NearTestnet'];

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@dfns/lib-near",
+  "version": "0.7.6",
+  "peerDependencies": {
+    "near-api-js": "^6.0.0",
+    "@dfns/sdk": "0.7.6"
+  },
+  "dependencies": {
+    "@near-js/crypto": "2.2.4",
+    "@near-js/signers": "2.2.4",
+    "@near-js/transactions": "2.2.4",
+    "@near-js/utils": "2.2.4",
+    "@noble/hashes": "1.8.0",
+    "buffer": "6.0.3",
+    "cross-fetch": "3.1.6"
+  },
+  "main": "./index.js",
+  "type": "commonjs"
+}