@dfns/lib-polymesh 0.7.2-beta.1

package/index.d.ts

@@ -0,0 +1,38 @@
+import { DfnsApiClient } from '@dfns/sdk';
+import { PolkadotSigner, SignerPayloadRaw, SignerPayloadJSON, SignerResult, SigningManager } from '@polymeshassociation/signing-manager-types';
+import { Registry } from '@polkadot/types/types';
+export type DfnsWalletOptions = {
+    walletId: string;
+    dfnsClient: DfnsApiClient;
+    registry: Registry;
+};
+export declare class DfnsSigningManager implements SigningManager {
+    private externalSigner;
+    private _ss58Format;
+    constructor(dfnsSigner: DfnsWallet);
+    /**
+     * Set the SS58 format in which addresses will be encoded
+     */
+    setSs58Format(ss58Format: number): void;
+    get ss58Format(): number;
+    getAccounts(): Promise<string[]>;
+    /**
+     * Return a signer object that uses the underlying keyring pairs to sign
+     */
+    getExternalSigner(): PolkadotSigner;
+}
+export declare class DfnsWallet implements PolkadotSigner {
+    address: string;
+    network: string;
+    private id;
+    private readonly dfnsClient;
+    private readonly walletId;
+    private readonly registry;
+    private constructor();
+    static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
+    signRaw(raw: SignerPayloadRaw): Promise<SignerResult>;
+    signPayload(signerPayload: SignerPayloadJSON): Promise<SignerResult>;
+    private signMessage;
+    private formatSignature;
+    private validateAddress;
+}

package/index.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsWallet = exports.DfnsSigningManager = void 0;
+const sdk_1 = require("@dfns/sdk");
+const types_1 = require("@polkadot/types");
+const Ss58PrefixMap = {
+    ['Polymesh']: 12,
+    ['PolymeshTestnet']: 42,
+};
+const assertSignResponseSuccessful = (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 DfnsSigningManager {
+    constructor(dfnsSigner) {
+        this.externalSigner = dfnsSigner;
+        this._ss58Format = Ss58PrefixMap[dfnsSigner.network];
+    }
+    /**
+     * Set the SS58 format in which addresses will be encoded
+     */
+    setSs58Format(ss58Format) {
+        this._ss58Format = ss58Format;
+    }
+    get ss58Format() {
+        return this._ss58Format;
+    }
+    async getAccounts() {
+        return [this.externalSigner.address];
+    }
+    /**
+     * Return a signer object that uses the underlying keyring pairs to sign
+     */
+    getExternalSigner() {
+        return this.externalSigner;
+    }
+}
+exports.DfnsSigningManager = DfnsSigningManager;
+class DfnsWallet {
+    constructor(address, network, options) {
+        this.address = address;
+        this.network = network;
+        this.dfnsClient = options.dfnsClient;
+        this.walletId = options.walletId;
+        this.registry = options.registry;
+    }
+    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 !== 'Polymesh' && res.network !== 'PolymeshTestnet') {
+            throw new sdk_1.DfnsError(-1, 'wallet is not bound to a Polymesh network', {
+                walletId,
+                network: res.network,
+            });
+        }
+        return new DfnsWallet(res.address, res.network, options);
+    }
+    async signRaw(raw) {
+        const signature = await this.signMessage(raw.data, raw.address);
+        return { id: ++this.id, signature: signature };
+    }
+    async signPayload(signerPayload) {
+        this.validateAddress(signerPayload.address);
+        const { transactionVersion, specVersion, ...rest } = signerPayload;
+        const genericPayload = new types_1.GenericSignerPayload(this.registry, {
+            ...rest,
+            runtimeVersion: { specVersion, transactionVersion },
+        });
+        const response = await this.dfnsClient.wallets.generateSignature({
+            walletId: this.walletId,
+            body: {
+                kind: 'SignerPayload',
+                payload: genericPayload.toHex()
+            }
+        });
+        assertSignResponseSuccessful(response);
+        const signature = this.formatSignature(response.signature.encoded);
+        return { id: ++this.id, signature };
+    }
+    async signMessage(data, address) {
+        this.validateAddress(address);
+        const response = await this.dfnsClient.wallets.generateSignature({
+            walletId: this.walletId,
+            body: { kind: 'Message', message: data }
+        });
+        assertSignResponseSuccessful(response);
+        return this.formatSignature(response.signature.encoded);
+    }
+    formatSignature(signature) {
+        // Add hex prefix and append 0 byte to indicate an ed25519 signature
+        return signature.replace(/^0x/, "0x00");
+    }
+    validateAddress(givenAddress) {
+        if (this.address !== givenAddress) {
+            throw new sdk_1.DfnsError(-1, 'address does not match the wallet used to initialize DfnsWallet', {
+                expectedAddress: this.address,
+                givenAddress,
+            });
+        }
+    }
+}
+exports.DfnsWallet = DfnsWallet;

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@dfns/lib-polymesh",
+  "version": "0.7.2-beta.1",
+  "peerDependencies": {
+    "@polkadot/api": "11.2.1",
+    "@polymeshassociation/signing-manager-types": "3.4.0",
+    "@dfns/sdk": "0.7.2-beta.1"
+  },
+  "dependencies": {
+    "@polkadot/types": "11.2.1",
+    "@polkadot/util": "12.6.2",
+    "buffer": "6.0.3",
+    "cross-fetch": "3.1.6"
+  },
+  "main": "./index.js",
+  "type": "commonjs"
+}