@portal-hq/web 3.8.0 → 3.9.0

package/lib/commonjs/integrations/security/blockaid/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class Blockaid {
+    constructor({ mpc }) {
+        this.mpc = mpc;
+    }
+    /**
+     * Scans an EVM transaction for security risks using Blockaid.
+     * @param params - The parameters for the EVM transaction scan request.
+     * @returns A `BlockaidScanEvmTxResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanEVMTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanEvmTx(params);
+        });
+    }
+    /**
+     * Scans a Solana transaction for security risks using Blockaid.
+     * @param params - The parameters for the Solana transaction scan request.
+     * @returns A `BlockaidScanSolanaTxResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanSolanaTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanSolanaTx(params);
+        });
+    }
+    /**
+     * Scans an address for security risks using Blockaid.
+     * @param params - The parameters for the address scan request.
+     * @returns A `BlockaidAddressScanResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanAddress(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanAddress(params);
+        });
+    }
+    /**
+     * Scans tokens for security risks using Blockaid.
+     * @param params - The parameters for the token scan request.
+     * @returns A `BlockaidBulkTokenScanResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanTokens(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanTokens(params);
+        });
+    }
+    /**
+     * Scans a URL for malicious content using Blockaid.
+     * @param params - The parameters for the URL scan request.
+     * @returns A `BlockaidSiteScanResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanURL(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanUrl(params);
+        });
+    }
+}
+exports.default = Blockaid;

package/lib/commonjs/integrations/security/blockaid/index.test.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * @jest-environment jsdom
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = __importDefault(require("."));
+const mpc_1 = __importDefault(require("../../../mpc"));
+const portal_1 = __importDefault(require("../../../__mocks/portal/portal"));
+const constants_1 = require("../../../__mocks/constants");
+describe('Blockaid', () => {
+    let blockaid;
+    let mpc;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portal_1.default.host = constants_1.mockHost;
+        mpc = new mpc_1.default({
+            portal: portal_1.default,
+        });
+        blockaid = new _1.default({ mpc });
+    });
+    describe('scanEVMTx', () => {
+        it('should call mpc.blockaidScanEvmTx with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'blockaidScanEvmTx')
+                .mockResolvedValue(constants_1.mockBlockaidScanEvmTxResponse);
+            const result = yield blockaid.scanEVMTx(constants_1.mockBlockaidScanEvmTxRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockBlockaidScanEvmTxRequest);
+            expect(result).toEqual(constants_1.mockBlockaidScanEvmTxResponse);
+        }));
+        it('should propagate errors from mpc.blockaidScanEvmTx', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'blockaidScanEvmTx').mockRejectedValue(error);
+            yield expect(blockaid.scanEVMTx(constants_1.mockBlockaidScanEvmTxRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanSolanaTx', () => {
+        it('should call mpc.blockaidScanSolanaTx with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'blockaidScanSolanaTx')
+                .mockResolvedValue(constants_1.mockBlockaidScanSolanaTxResponse);
+            const result = yield blockaid.scanSolanaTx(constants_1.mockBlockaidScanSolanaTxRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockBlockaidScanSolanaTxRequest);
+            expect(result).toEqual(constants_1.mockBlockaidScanSolanaTxResponse);
+        }));
+        it('should propagate errors from mpc.blockaidScanSolanaTx', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'blockaidScanSolanaTx').mockRejectedValue(error);
+            yield expect(blockaid.scanSolanaTx(constants_1.mockBlockaidScanSolanaTxRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanAddress', () => {
+        it('should call mpc.blockaidScanAddress with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'blockaidScanAddress')
+                .mockResolvedValue(constants_1.mockBlockaidScanAddressResponse);
+            const result = yield blockaid.scanAddress(constants_1.mockBlockaidScanAddressRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockBlockaidScanAddressRequest);
+            expect(result).toEqual(constants_1.mockBlockaidScanAddressResponse);
+        }));
+        it('should propagate errors from mpc.blockaidScanAddress', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'blockaidScanAddress').mockRejectedValue(error);
+            yield expect(blockaid.scanAddress(constants_1.mockBlockaidScanAddressRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanTokens', () => {
+        it('should call mpc.blockaidScanTokens with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'blockaidScanTokens')
+                .mockResolvedValue(constants_1.mockBlockaidScanTokensResponse);
+            const result = yield blockaid.scanTokens(constants_1.mockBlockaidScanTokensRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockBlockaidScanTokensRequest);
+            expect(result).toEqual(constants_1.mockBlockaidScanTokensResponse);
+        }));
+        it('should propagate errors from mpc.blockaidScanTokens', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'blockaidScanTokens').mockRejectedValue(error);
+            yield expect(blockaid.scanTokens(constants_1.mockBlockaidScanTokensRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanURL', () => {
+        it('should call mpc.blockaidScanUrl with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'blockaidScanUrl')
+                .mockResolvedValue(constants_1.mockBlockaidScanUrlResponse);
+            const result = yield blockaid.scanURL(constants_1.mockBlockaidScanUrlRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockBlockaidScanUrlRequest);
+            expect(result).toEqual(constants_1.mockBlockaidScanUrlResponse);
+        }));
+        it('should propagate errors from mpc.blockaidScanUrl', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'blockaidScanUrl').mockRejectedValue(error);
+            yield expect(blockaid.scanURL(constants_1.mockBlockaidScanUrlRequest)).rejects.toThrow('Test error');
+        }));
+    });
+});

package/lib/commonjs/integrations/security/index.js

@@ -3,13 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const blockaid_1 = __importDefault(require("./blockaid"));
 const hypernative_1 = __importDefault(require("./hypernative"));
 /**
- * This class is a container for the Hypernative class.
+ * This class is a container for the Hypernative and Blockaid classes.
  * In the future, Security domain logic should be here.
  */
 class Security {
     constructor({ mpc }) {
+        this.blockaid = new blockaid_1.default({ mpc });
         this.hypernative = new hypernative_1.default({ mpc });
     }
 }

package/lib/commonjs/mpc/index.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MpcErrorCodes = exports.MpcError = void 0;
 const errors_1 = require("./errors");
 const index_1 = require("../index");
-const WEB_SDK_VERSION = '3.8.0';
+const WEB_SDK_VERSION = '3.9.0';
 class Mpc {
     get ready() {
         return this._ready;
@@ -597,6 +597,59 @@ class Mpc {
             });
         });
     }
+    /*******************************
+     * Blockaid Security Methods
+     *******************************/
+    blockaidScanEvmTx(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:blockaid:scanEvmTx',
+                errorMessage: 'portal:blockaid:scanEvmTxError',
+                resultMessage: 'portal:blockaid:scanEvmTxResult',
+                data,
+            });
+        });
+    }
+    blockaidScanSolanaTx(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:blockaid:scanSolanaTx',
+                errorMessage: 'portal:blockaid:scanSolanaTxError',
+                resultMessage: 'portal:blockaid:scanSolanaTxResult',
+                data,
+            });
+        });
+    }
+    blockaidScanAddress(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:blockaid:scanAddress',
+                errorMessage: 'portal:blockaid:scanAddressError',
+                resultMessage: 'portal:blockaid:scanAddressResult',
+                data,
+            });
+        });
+    }
+    blockaidScanTokens(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:blockaid:scanTokens',
+                errorMessage: 'portal:blockaid:scanTokensError',
+                resultMessage: 'portal:blockaid:scanTokensResult',
+                data,
+            });
+        });
+    }
+    blockaidScanUrl(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:blockaid:scanUrl',
+                errorMessage: 'portal:blockaid:scanUrlError',
+                resultMessage: 'portal:blockaid:scanUrlResult',
+                data,
+            });
+        });
+    }
     /***************************
      * Private Methods
      ***************************/

package/lib/commonjs/mpc/index.test.js

@@ -3287,4 +3287,332 @@ describe('Mpc', () => {
             });
         });
     });
+    /*******************************
+     * Blockaid Security Methods Tests
+     *******************************/
+    describe('blockaidScanEvmTx', () => {
+        const args = constants_1.mockBlockaidScanEvmTxRequest;
+        const res = constants_1.mockBlockaidScanEvmTxResponse;
+        it('should successfully scan EVM transaction with Blockaid', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanEvmTx');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanEvmTxResult',
+                        data: res,
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanEvmTx(args)
+                .then((data) => {
+                expect(data).toEqual(res);
+                done();
+            })
+                .catch((_) => {
+                expect(0).toEqual(1);
+                done();
+            });
+        });
+        it('should error out if the iframe sends an error message', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanEvmTx');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanEvmTxError',
+                        data: {
+                            code: 1,
+                            message: 'test',
+                        },
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanEvmTx(args)
+                .then(() => {
+                expect(0).toEqual(1);
+                done();
+            })
+                .catch((e) => {
+                expect(e).toBeInstanceOf(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('blockaidScanSolanaTx', () => {
+        const args = constants_1.mockBlockaidScanSolanaTxRequest;
+        const res = constants_1.mockBlockaidScanSolanaTxResponse;
+        it('should successfully scan Solana transaction with Blockaid', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanSolanaTx');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanSolanaTxResult',
+                        data: res,
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanSolanaTx(args)
+                .then((data) => {
+                expect(data).toEqual(res);
+                done();
+            })
+                .catch((_) => {
+                expect(0).toEqual(1);
+                done();
+            });
+        });
+        it('should error out if the iframe sends an error message', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanSolanaTx');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanSolanaTxError',
+                        data: {
+                            code: 1,
+                            message: 'test',
+                        },
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanSolanaTx(args)
+                .then(() => {
+                expect(0).toEqual(1);
+                done();
+            })
+                .catch((e) => {
+                expect(e).toBeInstanceOf(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('blockaidScanAddress', () => {
+        const args = constants_1.mockBlockaidScanAddressRequest;
+        const res = constants_1.mockBlockaidScanAddressResponse;
+        it('should successfully scan address with Blockaid', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanAddress');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanAddressResult',
+                        data: res,
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanAddress(args)
+                .then((data) => {
+                expect(data).toEqual(res);
+                done();
+            })
+                .catch((_) => {
+                expect(0).toEqual(1);
+                done();
+            });
+        });
+        it('should error out if the iframe sends an error message', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanAddress');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanAddressError',
+                        data: {
+                            code: 1,
+                            message: 'test',
+                        },
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanAddress(args)
+                .then(() => {
+                expect(0).toEqual(1);
+                done();
+            })
+                .catch((e) => {
+                expect(e).toBeInstanceOf(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('blockaidScanTokens', () => {
+        const args = constants_1.mockBlockaidScanTokensRequest;
+        const res = constants_1.mockBlockaidScanTokensResponse;
+        it('should successfully scan tokens with Blockaid', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanTokens');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanTokensResult',
+                        data: res,
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanTokens(args)
+                .then((data) => {
+                expect(data).toEqual(res);
+                done();
+            })
+                .catch((_) => {
+                expect(0).toEqual(1);
+                done();
+            });
+        });
+        it('should error out if the iframe sends an error message', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanTokens');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanTokensError',
+                        data: {
+                            code: 1,
+                            message: 'test',
+                        },
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanTokens(args)
+                .then(() => {
+                expect(0).toEqual(1);
+                done();
+            })
+                .catch((e) => {
+                expect(e).toBeInstanceOf(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('blockaidScanUrl', () => {
+        const args = constants_1.mockBlockaidScanUrlRequest;
+        const res = constants_1.mockBlockaidScanUrlResponse;
+        it('should successfully scan URL with Blockaid', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanUrl');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanUrlResult',
+                        data: res,
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanUrl(args)
+                .then((data) => {
+                expect(data).toEqual(res);
+                done();
+            })
+                .catch((_) => {
+                expect(0).toEqual(1);
+                done();
+            });
+        });
+        it('should error out if the iframe sends an error message', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:blockaid:scanUrl');
+                expect(data).toEqual(args);
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:blockaid:scanUrlError',
+                        data: {
+                            code: 1,
+                            message: 'test',
+                        },
+                    },
+                }));
+            });
+            mpc
+                .blockaidScanUrl(args)
+                .then(() => {
+                expect(0).toEqual(1);
+                done();
+            })
+                .catch((e) => {
+                expect(e).toBeInstanceOf(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
 });

package/lib/commonjs/shared/types/blockaid.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Blockaid integration types
+ *
+ * Types for Blockaid security scanning and validation services
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonjs/shared/types/index.js

@@ -28,3 +28,4 @@ __exportStar(require("./yieldxyz"), exports);
 __exportStar(require("./zero-x"), exports);
 __exportStar(require("./lifi"), exports);
 __exportStar(require("./hypernative"), exports);
+__exportStar(require("./blockaid"), exports);

package/lib/esm/integrations/security/blockaid/index.js

@@ -0,0 +1,69 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export default class Blockaid {
+    constructor({ mpc }) {
+        this.mpc = mpc;
+    }
+    /**
+     * Scans an EVM transaction for security risks using Blockaid.
+     * @param params - The parameters for the EVM transaction scan request.
+     * @returns A `BlockaidScanEvmTxResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanEVMTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanEvmTx(params);
+        });
+    }
+    /**
+     * Scans a Solana transaction for security risks using Blockaid.
+     * @param params - The parameters for the Solana transaction scan request.
+     * @returns A `BlockaidScanSolanaTxResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanSolanaTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanSolanaTx(params);
+        });
+    }
+    /**
+     * Scans an address for security risks using Blockaid.
+     * @param params - The parameters for the address scan request.
+     * @returns A `BlockaidAddressScanResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanAddress(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanAddress(params);
+        });
+    }
+    /**
+     * Scans tokens for security risks using Blockaid.
+     * @param params - The parameters for the token scan request.
+     * @returns A `BlockaidBulkTokenScanResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanTokens(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanTokens(params);
+        });
+    }
+    /**
+     * Scans a URL for malicious content using Blockaid.
+     * @param params - The parameters for the URL scan request.
+     * @returns A `BlockaidSiteScanResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanURL(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.blockaidScanUrl(params);
+        });
+    }
+}