@dfns/lib-taquito 0.2.1

package/addHexPrefix.d.ts

@@ -0,0 +1 @@
+export declare function addHexPrefix(inputString: string): string;

package/addHexPrefix.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHexPrefix = void 0;
+function addHexPrefix(inputString) {
+    return inputString.startsWith('0x') ? inputString : '0x' + inputString;
+}
+exports.addHexPrefix = addHexPrefix;

package/constant.d.ts

@@ -0,0 +1 @@
+export declare const TxWatermark: Uint8Array;

package/constant.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxWatermark = void 0;
+exports.TxWatermark = new Uint8Array([3]);

package/index.d.ts

@@ -0,0 +1,25 @@
+import { DfnsApiClient } from '@dfns/sdk';
+import { Signer } from '@taquito/taquito';
+export type DfnsWalletOptions = {
+    walletId: string;
+    dfnsClient: DfnsApiClient;
+};
+export declare class DfnsWallet implements Signer {
+    private metadata;
+    private readonly dfnsClient;
+    private tezosPubKey;
+    private constructor();
+    static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
+    get address(): string;
+    publicKey(): Promise<string>;
+    publicKeyHash(): Promise<string>;
+    secretKey(): Promise<string | undefined>;
+    sign(op: string, magicByte?: Uint8Array | undefined): Promise<{
+        bytes: string;
+        sig: string;
+        prefixSig: string;
+        sbytes: string;
+    }>;
+    private generateSignatureForTransaction;
+    private generateSignatureForHash;
+}

package/index.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsWallet = void 0;
+const sdk_1 = require("@dfns/sdk");
+const utils_1 = require("@taquito/utils");
+const constant_1 = require("./constant");
+const blake2b_1 = require("@stablelib/blake2b");
+const uint8ArraysEqual_1 = require("./uint8ArraysEqual");
+const addHexPrefix_1 = require("./addHexPrefix");
+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);
+    }
+};
+class DfnsWallet {
+    constructor(metadata, options) {
+        this.metadata = metadata;
+        this.dfnsClient = options.dfnsClient;
+        // get the public key encoded with the right tezos prefix.
+        this.tezosPubKey = (0, utils_1.b58cencode)(metadata.signingKey.publicKey, utils_1.prefix[metadata.signingKey.scheme === 'EdDSA' ? utils_1.Prefix.EDPK : utils_1.Prefix.SPPK]);
+    }
+    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 (res.network !== 'Tezos' && res.network !== 'TezosGhostnet') {
+            throw new sdk_1.DfnsError(-1, 'wallet is not bound to Tezos or TezosGhostnet', { walletId, network: res.network });
+        }
+        return new DfnsWallet(res, options);
+    }
+    get address() {
+        // Tezos-bound wallets will have a tezos address
+        return this.metadata.address;
+    }
+    // publicKey implements the Taquito Signer interface
+    async publicKey() {
+        return this.tezosPubKey;
+    }
+    // publicKeyHash implements the Taquito Signer interface
+    async publicKeyHash() {
+        return this.metadata.address;
+    }
+    // secretKey implements the Taquito Signer interface
+    async secretKey() {
+        return undefined;
+    }
+    // sign implements the Taquito Signer interface
+    async sign(op, magicByte) {
+        let res;
+        if ((0, uint8ArraysEqual_1.uint8ArraysEqual)(magicByte, constant_1.TxWatermark)) {
+            res = await this.generateSignatureForTransaction(op);
+        }
+        else {
+            res = await this.generateSignatureForHash(op, magicByte);
+        }
+        assertSigned(res);
+        const signature = res.signature.encoded.replace(/^0x/, '');
+        const sigPrefix = this.metadata.signingKey.scheme === 'ECDSA' ? utils_1.prefix.spsig : utils_1.prefix.edsig;
+        return {
+            bytes: op,
+            sig: (0, utils_1.b58cencode)(signature, utils_1.prefix.sig),
+            sbytes: res.signedData.replace(/^0x/, ''),
+            prefixSig: (0, utils_1.b58cencode)(signature, sigPrefix),
+        };
+    }
+    async generateSignatureForTransaction(transaction) {
+        return await this.dfnsClient.wallets.generateSignature({
+            walletId: this.metadata.id,
+            body: { kind: 'Transaction', transaction: (0, addHexPrefix_1.addHexPrefix)(transaction) },
+        });
+    }
+    async generateSignatureForHash(op, magicByte) {
+        let data = (0, utils_1.hex2buf)(op);
+        if (magicByte) {
+            data = (0, utils_1.mergebuf)(magicByte, data);
+        }
+        const bytesHash = (0, blake2b_1.hash)(data, 32);
+        return await this.dfnsClient.wallets.generateSignature({
+            walletId: this.metadata.id,
+            body: { kind: 'Hash', hash: (0, addHexPrefix_1.addHexPrefix)((0, utils_1.buf2hex)(bytesHash)) },
+        });
+    }
+}
+exports.DfnsWallet = DfnsWallet;

package/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@dfns/lib-taquito",
+  "version": "0.2.1",
+  "main": "./index.js",
+  "type": "commonjs"
+}

package/uint8ArraysEqual.d.ts

@@ -0,0 +1 @@
+export declare function uint8ArraysEqual(arr1: Uint8Array | undefined, arr2: Uint8Array | undefined): boolean;

package/uint8ArraysEqual.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint8ArraysEqual = void 0;
+function uint8ArraysEqual(arr1, arr2) {
+    if (!arr1 && !arr2) {
+        return true;
+    }
+    if ((!arr1 && arr2) || (arr1 && !arr2) || arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; i++) {
+        if (arr1[i] !== arr2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.uint8ArraysEqual = uint8ArraysEqual;