@onekeyfe/onekey-cosmos-provider 2.2.61 → 2.2.63

package/dist/OnekeyCosmosProvider.d.ts

@@ -40,6 +40,10 @@ export type CosmosRequest = {
     'signEthereum': (chainId: string, signer: string, data: string | Uint8Array, type: EthSignType) => Promise<string>;
     'getChainInfosWithoutEndpoints': () => Promise<ChainInfoWithoutEndpoints[]>;
     'getChainInfoWithoutEndpoints': (chainId: string) => Promise<ChainInfoWithoutEndpoints>;
+    'getEnigmaPubKey': (chainId: string) => Promise<string>;
+    'enigmaEncrypt': (chainId: string, contractCodeHash: string, msg: object) => Promise<string>;
+    'enigmaDecrypt': (chainId: string, ciphertext: string, nonce: string) => Promise<string>;
+    'enigmaGetTxEncryptionKey': (chainId: string, nonce: string) => Promise<string>;
 };
 export type PROVIDER_EVENTS_STRINGS = keyof typeof PROVIDER_EVENTS;
 export interface IProviderCosmos {
@@ -69,6 +73,16 @@ export interface IProviderCosmos {
     getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner;
     getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner>;
     getChainInfosWithoutEndpoints(): Promise<ChainInfoWithoutEndpoints[]>;
+    getEnigmaUtils(chainId: string): {
+        getPubkey: () => Promise<Uint8Array>;
+        encrypt: (contractCodeHash: string, msg: object) => Promise<Uint8Array>;
+        decrypt: (ciphertext: Uint8Array, nonce: Uint8Array) => Promise<Uint8Array>;
+        getTxEncryptionKey: (nonce: Uint8Array) => Promise<Uint8Array>;
+    };
+    getEnigmaPubKey(chainId: string): Promise<Uint8Array>;
+    enigmaEncrypt(chainId: string, contractCodeHash: string, msg: object): Promise<Uint8Array>;
+    enigmaDecrypt(chainId: string, ciphertext: Uint8Array, nonce: Uint8Array): Promise<Uint8Array>;
+    getEnigmaTxEncryptionKey(chainId: string, nonce: Uint8Array): Promise<Uint8Array>;
 }
 export type OneKeySuiProviderProps = IInpageProviderConfig & {
     timeout?: number;
@@ -118,5 +132,15 @@ declare class ProviderCosmos extends ProviderCosmosBase implements IProviderCosm
     getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner>;
     getChainInfosWithoutEndpoints(): Promise<ChainInfoWithoutEndpoints[]>;
     getChainInfoWithoutEndpoints(chainId: string): Promise<ChainInfoWithoutEndpoints>;
+    getEnigmaPubKey(chainId: string): Promise<Uint8Array>;
+    enigmaEncrypt(chainId: string, contractCodeHash: string, msg: object): Promise<Uint8Array>;
+    enigmaDecrypt(chainId: string, ciphertext: Uint8Array, nonce: Uint8Array): Promise<Uint8Array>;
+    getEnigmaTxEncryptionKey(chainId: string, nonce: Uint8Array): Promise<Uint8Array>;
+    getEnigmaUtils(chainId: string): {
+        getPubkey: () => Promise<Uint8Array>;
+        encrypt: (contractCodeHash: string, msg: object) => Promise<Uint8Array>;
+        decrypt: (ciphertext: Uint8Array, nonce: Uint8Array) => Promise<Uint8Array>;
+        getTxEncryptionKey: (nonce: Uint8Array) => Promise<Uint8Array>;
+    };
 }
 export { ProviderCosmos };

package/dist/OnekeyCosmosProvider.js

@@ -325,5 +325,65 @@ class ProviderCosmos extends ProviderCosmosBase {
             });
         });
     }
+    getEnigmaPubKey(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hex = yield this._callBridge({
+                method: 'getEnigmaPubKey',
+                // @ts-expect-error
+                params: { chainId },
+            });
+            return hexToBytes(hex);
+        });
+    }
+    enigmaEncrypt(chainId, contractCodeHash, msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hex = yield this._callBridge({
+                method: 'enigmaEncrypt',
+                // @ts-expect-error
+                params: { chainId, contractCodeHash, msg },
+            });
+            return hexToBytes(hex);
+        });
+    }
+    enigmaDecrypt(chainId, ciphertext, nonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hex = yield this._callBridge({
+                method: 'enigmaDecrypt',
+                // @ts-expect-error
+                params: {
+                    chainId,
+                    ciphertext: bytesToHex(ciphertext),
+                    nonce: bytesToHex(nonce),
+                },
+            });
+            return hexToBytes(hex);
+        });
+    }
+    getEnigmaTxEncryptionKey(chainId, nonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hex = yield this._callBridge({
+                method: 'enigmaGetTxEncryptionKey',
+                // @ts-expect-error
+                params: { chainId, nonce: bytesToHex(nonce) },
+            });
+            return hexToBytes(hex);
+        });
+    }
+    getEnigmaUtils(chainId) {
+        return {
+            getPubkey: () => __awaiter(this, void 0, void 0, function* () {
+                return this.getEnigmaPubKey(chainId);
+            }),
+            encrypt: (contractCodeHash, msg) => __awaiter(this, void 0, void 0, function* () {
+                return this.enigmaEncrypt(chainId, contractCodeHash, msg);
+            }),
+            decrypt: (ciphertext, nonce) => __awaiter(this, void 0, void 0, function* () {
+                return this.enigmaDecrypt(chainId, ciphertext, nonce);
+            }),
+            getTxEncryptionKey: (nonce) => __awaiter(this, void 0, void 0, function* () {
+                return this.getEnigmaTxEncryptionKey(chainId, nonce);
+            }),
+        };
+    }
 }
 export { ProviderCosmos };

package/dist/cjs/OnekeyCosmosProvider.js

@@ -331,5 +331,65 @@ class ProviderCosmos extends ProviderCosmosBase_1.ProviderCosmosBase {
             });
         });
     }
+    getEnigmaPubKey(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hex = yield this._callBridge({
+                method: 'getEnigmaPubKey',
+                // @ts-expect-error
+                params: { chainId },
+            });
+            return (0, cross_inpage_provider_core_1.hexToBytes)(hex);
+        });
+    }
+    enigmaEncrypt(chainId, contractCodeHash, msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hex = yield this._callBridge({
+                method: 'enigmaEncrypt',
+                // @ts-expect-error
+                params: { chainId, contractCodeHash, msg },
+            });
+            return (0, cross_inpage_provider_core_1.hexToBytes)(hex);
+        });
+    }
+    enigmaDecrypt(chainId, ciphertext, nonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hex = yield this._callBridge({
+                method: 'enigmaDecrypt',
+                // @ts-expect-error
+                params: {
+                    chainId,
+                    ciphertext: (0, cross_inpage_provider_core_1.bytesToHex)(ciphertext),
+                    nonce: (0, cross_inpage_provider_core_1.bytesToHex)(nonce),
+                },
+            });
+            return (0, cross_inpage_provider_core_1.hexToBytes)(hex);
+        });
+    }
+    getEnigmaTxEncryptionKey(chainId, nonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hex = yield this._callBridge({
+                method: 'enigmaGetTxEncryptionKey',
+                // @ts-expect-error
+                params: { chainId, nonce: (0, cross_inpage_provider_core_1.bytesToHex)(nonce) },
+            });
+            return (0, cross_inpage_provider_core_1.hexToBytes)(hex);
+        });
+    }
+    getEnigmaUtils(chainId) {
+        return {
+            getPubkey: () => __awaiter(this, void 0, void 0, function* () {
+                return this.getEnigmaPubKey(chainId);
+            }),
+            encrypt: (contractCodeHash, msg) => __awaiter(this, void 0, void 0, function* () {
+                return this.enigmaEncrypt(chainId, contractCodeHash, msg);
+            }),
+            decrypt: (ciphertext, nonce) => __awaiter(this, void 0, void 0, function* () {
+                return this.enigmaDecrypt(chainId, ciphertext, nonce);
+            }),
+            getTxEncryptionKey: (nonce) => __awaiter(this, void 0, void 0, function* () {
+                return this.getEnigmaTxEncryptionKey(chainId, nonce);
+            }),
+        };
+    }
 }
 exports.ProviderCosmos = ProviderCosmos;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/onekey-cosmos-provider",
-  "version": "2.2.61",
+  "version": "2.2.63",
   "keywords": [
     "cross-inpage-provider"
   ],
@@ -27,10 +27,10 @@
     "start": "tsc --watch"
   },
   "dependencies": {
-    "@onekeyfe/cross-inpage-provider-core": "2.2.61",
-    "@onekeyfe/cross-inpage-provider-errors": "2.2.61",
-    "@onekeyfe/cross-inpage-provider-types": "2.2.61",
-    "@onekeyfe/extension-bridge-injected": "2.2.61",
+    "@onekeyfe/cross-inpage-provider-core": "2.2.63",
+    "@onekeyfe/cross-inpage-provider-errors": "2.2.63",
+    "@onekeyfe/cross-inpage-provider-types": "2.2.63",
+    "@onekeyfe/extension-bridge-injected": "2.2.63",
     "eth-rpc-errors": "^4.0.3",
     "lodash-es": "^4.17.21",
     "long": "^4.0.0",
@@ -40,5 +40,5 @@
     "@types/lodash-es": "^4.17.12",
     "@types/long": "^4.0.0"
   },
-  "gitHead": "1e98fecc19bda6cea42ecd616f3e432749f6dd0d"
+  "gitHead": "321fff7491b90508f1adb921307e01539a867152"
 }