@socket.tech/dl-common 1.0.3-test.4 → 1.0.3-test.41

package/dist/models/transaction.js

@@ -0,0 +1,280 @@
+"use strict";
+// import { IntegrationTypes } from "@socket.tech/dl-core";
+// import { DataTypes, Model } from "sequelize";
+// import { toLowerCase } from "../utils";
+// import {Project} from "@socket.tech/socket-plugs";
+// export enum SealRelayStatus {
+//   SEALED = "SEALED",
+//   SEALING = "SEALING",
+//   NO = "NO",
+//   SEAL_FAILED = "SEAL_FAILED",
+// }
+// export enum PacketTripRelayStatus {
+//   IS_TRIPPING = "IS_TRIPPING",
+//   NO = "NO",
+//   TRIPPING_FAILED = "TRIPPING_FAILED",
+//   TRIPPED = "TRIPPED",
+// }
+// export enum ProposeRelayStatus {
+//   PROPOSED = "PROPOSED",
+//   PROPOSING = "PROPOSING",
+//   CONFIRMING = "CONFIRMING",
+//   NO = "NO",
+//   PROPOSE_FAILED = "PROPOSE_FAILED",
+//   CONFIRM_FAILED = "CONFIRM_FAILED",
+// }
+// export enum TxType {
+//   SUPERBRIDGE = "SUPERBRIDGE",
+//   SUPERTOKEN = "SUPERTOKEN"
+// }
+// export class Transaction extends Model {
+//   declare id: number;
+//   srcChainSlug: number;
+//   dstChainSlug: number;
+//   from: string;
+//   to:string;
+//   amount:number;
+//   token: string;
+//   tokenAddress: string;
+//   srcPlug: string;
+//   dstPlug: string;
+//   usdAmount: number;
+//   type: TxType;
+//   project: Project;
+//   srcTxHash: string;
+//   txTime: string;
+//   root: string;
+//   rootSealed: string;
+//   sealer: string;
+//   sealTxHash: string;
+//   sealTxId: string;
+//   sealSignature: string;
+//   sealTime: number;
+//   sealRelayStatus: SealRelayStatus;
+//   packetTripTime: number;
+//   packetTripTxnHash: string;
+//   packetTripErrorMessage: string;
+//   isPacketTripped: boolean;
+//   packetTripRelayStatus: PacketTripRelayStatus;
+//   // proposeTxId, proposeTxHash refers to the proposal sent by us. For details of other proposals, see Proposal table.
+//   proposeTxId: string;
+//   proposeTxHash: string;
+//   proposeRelayStatus: ProposeRelayStatus;
+//   selectedProposalCount: number;
+//   // attestTxId, attestTxHash refers to the attestation sent by us. For details of other attestations, see Attestation table.
+//   attestTxId: string;
+//   attestTxHash: string;
+//   attestRelayStatus: AttestRelayStatus;
+//   outboundTxHash: string;
+//   outboundTime: number;
+//   sealIndexTime: number;
+//   proposeTime: number;
+//   attestTime: number;
+//   packetTripTxHash: string;
+//   isFilled: boolean;
+//   isSealed: boolean;
+//   isProposed: boolean;
+//   isAttested: boolean;
+//   isVerified: boolean;
+//   isFullyExecuted: boolean;
+//   tripreason: TripReason;
+//   executionWaitTime: number;
+// }
+// export const PacketModel = {
+//   id: {
+//     type: DataTypes.INTEGER,
+//     autoIncrement: true,
+//   },
+//   srcChainSlug: {
+//     type: DataTypes.BIGINT,
+//   },
+//   dstChainSlug: {
+//     type: DataTypes.BIGINT,
+//   },
+//   srcCapacitor: {
+//     type: DataTypes.STRING,
+//   },
+//   dstSwitchboard: {
+//     type: DataTypes.STRING,
+//   },
+//   switchboardId: {
+//     type: DataTypes.STRING,
+//   },
+//   integrationType: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(IntegrationTypes)],
+//     defaultValue: IntegrationTypes.unknown,
+//   },
+//   packetId: {
+//     type: DataTypes.STRING,
+//     primaryKey: true,
+//   },
+//   capacitorPacketCount: {
+//     type: DataTypes.STRING,
+//   },
+//   root: {
+//     type: DataTypes.STRING,
+//   },
+//   rootSealed: {
+//     type: DataTypes.STRING,
+//   },
+//   isFilled: {
+//     type: DataTypes.BOOLEAN,
+//   },
+//   isSealed: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   isProposed: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   isAttested: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   isVerified: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   isFullyExecuted: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   sealer: {
+//     type: DataTypes.STRING,
+//   },
+//   sealRelayStatus: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(SealRelayStatus)],
+//     defaultValue: SealRelayStatus.NO,
+//   },
+//   sealTxId: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   sealTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   outboundTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   outboundTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   proposeTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   attestTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   sealTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   sealIndexTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   sealSignature: {
+//     type: DataTypes.STRING,
+//   },
+//   packetTripRelayStatus: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(PacketTripRelayStatus)],
+//     defaultValue: PacketTripRelayStatus.NO,
+//   },
+//   packetTripTxId: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   packetTripTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   packetTripErrorMessage: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   packetTripTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   isPacketTripped: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   proposeTxId: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   proposeTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   proposeRelayStatus: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(ProposeRelayStatus)],
+//     defaultValue: ProposeRelayStatus.NO,
+//   },
+//   selectedProposalCount: {
+//     type: DataTypes.INTEGER,
+//   },
+//   executionWaitTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   attestTxId: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   attestTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   tripReason: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(TripReason)],
+//     defaultValue: TripReason.NO,
+//   },
+//   // packetTripTxHash: {
+//   //   type: DataTypes.STRING,
+//   //   defaultValue: "",
+//   // },
+//   attestRelayStatus: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(AttestRelayStatus)],
+//     defaultValue: AttestRelayStatus.NO,
+//   },
+// };
+// function processStrings(packet: Packet): Packet {
+//   if (packet.packetId) packet.packetId = toLowerCase(packet.packetId);
+//   if (packet.root) packet.root = toLowerCase(packet.root);
+//   if (packet.rootSealed) packet.rootSealed = toLowerCase(packet.rootSealed);
+//   if (packet.sealer) packet.sealer = toLowerCase(packet.sealer);
+//   if (packet.outboundTxHash) {
+//     packet.outboundTxHash = toLowerCase(packet.outboundTxHash);
+//   }
+//   if (packet.sealTxHash) packet.sealTxHash = toLowerCase(packet.sealTxHash);
+//   if (packet.sealSignature) {
+//     packet.sealSignature = toLowerCase(packet.sealSignature);
+//   }
+//   if (packet.dstSwitchboard) {
+//     packet.dstSwitchboard = toLowerCase(packet.dstSwitchboard);
+//   }
+//   if (packet.switchboardId) {
+//     packet.switchboardId = toLowerCase(packet.switchboardId);
+//   }
+//   if (packet.packetTripTxHash) {
+//     packet.packetTripTxHash = toLowerCase(packet.packetTripTxHash);
+//   }
+//   return packet;
+// }
+// export const addPacketHooks = () => {
+//   Packet.beforeBulkCreate((packet, options) => {
+//     for (let index = 0; index < packet.length; index++) {
+//       packet[index] = processStrings(packet[index]);
+//     }
+//   });
+//   Packet.beforeSave((packet, options) => {
+//     packet = processStrings(packet);
+//   });
+// };

package/dist/services/eventBridgeService.d.ts

@@ -0,0 +1,8 @@
+export type EventBridgeEntry = {
+    eventBus: string;
+    source: string;
+    detailType: string;
+    data: Object;
+};
+export declare const initEventBridgeClient: (region?: string) => void;
+export declare const sendEvents: (events: EventBridgeEntry[]) => Promise<import("@aws-sdk/client-eventbridge").PutEventsCommandOutput>;

package/dist/services/eventBridgeService.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendEvents = exports.initEventBridgeClient = void 0;
+const client_eventbridge_1 = require("@aws-sdk/client-eventbridge");
+let client;
+const initEventBridgeClient = (region = "us-east-1") => {
+    client = new client_eventbridge_1.EventBridgeClient({ region });
+};
+exports.initEventBridgeClient = initEventBridgeClient;
+const sendEvents = async (events) => {
+    // async/await.
+    try {
+        if (!client) {
+            throw new Error("EventBridge client is not initialized. Call initEventBridgeClient first.");
+        }
+        let entries = events.map((event) => {
+            let { eventBus, source, detailType, data } = event;
+            return {
+                Source: source,
+                DetailType: detailType,
+                Detail: JSON.stringify(data),
+                EventBusName: eventBus,
+            };
+        });
+        const params = {
+            Entries: entries,
+        };
+        const command = new client_eventbridge_1.PutEventsCommand(params);
+        return await client.send(command);
+        // process data.
+    }
+    catch (error) {
+        throw error;
+    }
+    finally {
+        // finally.
+    }
+};
+exports.sendEvents = sendEvents;

package/dist/services/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./queueService";
 export * from "./cacheService";
+export * from "./eventBridgeService";

package/dist/services/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./queueService"), exports);
 __exportStar(require("./cacheService"), exports);
+__exportStar(require("./eventBridgeService"), exports);
 // export * from "./apiService";

package/dist/services/queueService.d.ts

@@ -1,10 +1,10 @@
 export declare const initQueue: (region: string) => void;
 export declare const sendStandardSqsMessage: (queueUrl: string, data: any, DelaySeconds?: number) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
-export declare const sendStandardBatchMessages: (QueueUrl: string, dataArray: any[], DelaySecondsArray?: number[]) => Promise<import("@aws-sdk/client-sqs").SendMessageBatchCommandOutput>;
+export declare const sendStandardBatchMessages: (QueueUrl: string, dataArray: any[], DelaySecondsArray?: number[]) => Promise<void>;
 export declare const sendFifoSqsMessage: (queueUrl: string, data: any, MessageGroupId: string) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
 declare const _default: {
     sendStandardSqsMessage: (queueUrl: string, data: any, DelaySeconds?: number) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
     sendFifoSqsMessage: (queueUrl: string, data: any, MessageGroupId: string) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
-    sendStandardBatchMessages: (QueueUrl: string, dataArray: any[], DelaySecondsArray?: number[]) => Promise<import("@aws-sdk/client-sqs").SendMessageBatchCommandOutput>;
+    sendStandardBatchMessages: (QueueUrl: string, dataArray: any[], DelaySecondsArray?: number[]) => Promise<void>;
 };
 export default _default;

package/dist/services/queueService.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendFifoSqsMessage = exports.sendStandardBatchMessages = exports.sendStandardSqsMessage = exports.initQueue = void 0;
 const client_sqs_1 = require("@aws-sdk/client-sqs");
+const utils_1 = require("../utils");
 let client;
 const initQueue = (region) => {
     client = new client_sqs_1.SQSClient({ region });
@@ -19,21 +20,28 @@ const sendStandardSqsMessage = async (queueUrl, data, DelaySeconds = 0) => {
 };
 exports.sendStandardSqsMessage = sendStandardSqsMessage;
 const sendStandardBatchMessages = async (QueueUrl, dataArray, DelaySecondsArray = []) => {
-    let Entries = [];
-    for (let i = 0; i < dataArray.length; i++) {
-        Entries.push({
-            MessageBody: JSON.stringify(dataArray[i]),
-            Id: i,
-            DelaySeconds: DelaySecondsArray[i] ? DelaySecondsArray[i] : 0,
-        });
+    var _a;
+    const dataChunks = [...(0, utils_1.chunks)(dataArray, 10)];
+    const delayChunks = [...(0, utils_1.chunks)(DelaySecondsArray, 10)];
+    for (let i = 0; i < dataChunks.length; i++) {
+        let Entries = [];
+        let currentDataArray = dataChunks[i];
+        let currentDelayArray = delayChunks[i];
+        for (let j = 0; j < currentDataArray.length; j++) {
+            Entries.push({
+                MessageBody: JSON.stringify(currentDataArray[j]),
+                Id: String(i) + "-" + String(j),
+                DelaySeconds: (_a = currentDelayArray[j]) !== null && _a !== void 0 ? _a : 0,
+            });
+        }
+        let sqsOrderData = {
+            Entries,
+            QueueUrl,
+        };
+        // Send the order data to the SQS queue
+        const command = new client_sqs_1.SendMessageBatchCommand(sqsOrderData);
+        await client.send(command);
     }
-    let sqsOrderData = {
-        Entries,
-        QueueUrl,
-    };
-    // Send the order data to the SQS queue
-    const command = new client_sqs_1.SendMessageBatchCommand(sqsOrderData);
-    return await client.send(command);
 };
 exports.sendStandardBatchMessages = sendStandardBatchMessages;
 const sendFifoSqsMessage = async (queueUrl, data, MessageGroupId) => {

package/dist/utils/ethersAwsKmsSigner.d.ts

@@ -1,2 +1,2 @@
-import { AwsKmsSigner } from "ethers-aws-kms-signer";
-export declare const getAwsKmsSigner: (keyId: string, region?: string) => Promise<AwsKmsSigner>;
+import { KmsEthersSigner } from "./signer/kms-ethers-signer";
+export declare const getAwsKmsSigner: (keyId: string, region?: string) => Promise<KmsEthersSigner>;

package/dist/utils/ethersAwsKmsSigner.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAwsKmsSigner = void 0;
-const ethers_aws_kms_signer_1 = require("ethers-aws-kms-signer");
+const kms_ethers_signer_1 = require("./signer/kms-ethers-signer");
 const getAwsKmsSigner = async (keyId, region = "us-east-1") => {
     try {
         const kmsCredentials = {
-            region,
+            kmsClientConfig: {
+                signingRegion: region,
+                region,
+            },
             keyId,
         };
-        let signer = new ethers_aws_kms_signer_1.AwsKmsSigner(kmsCredentials);
+        let signer = new kms_ethers_signer_1.KmsEthersSigner(kmsCredentials);
         let signerAddress = await signer.getAddress();
         // logger.info(` keyid ${keyId} ${signerAddress}`);
         if (!signerAddress) {

package/dist/utils/extraUtils.d.ts

@@ -5,6 +5,7 @@ export declare const isEmpty: (data: any) => boolean;
 export declare const checkMissingFields: (fields: {
     [key: string]: any;
 }) => void;
+export declare const checkEnvValue: (key: string) => string;
 export declare const checkMissingFieldsAndType: (fields: {
     [key: string]: any;
 }, types?: {

package/dist/utils/extraUtils.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.responseBody = exports.filterFields = exports.removeFields = exports.checkObjectFieldsAndType = exports.checkMissingFieldsAndType = exports.checkMissingFields = exports.isEmpty = void 0;
-const __1 = require("..");
+exports.responseBody = exports.filterFields = exports.removeFields = exports.checkObjectFieldsAndType = exports.checkMissingFieldsAndType = exports.checkEnvValue = exports.checkMissingFields = exports.isEmpty = void 0;
+const constants_1 = require("../constants");
 /**
  * defining functions.
  */
@@ -18,18 +18,26 @@ const checkMissingFields = (fields) => {
     for (const field in fields) {
         let value = fields[field];
         if (!value) {
-            throw (0, __1.BadRequestError)(`missing field : ${field}`);
+            throw (0, constants_1.BadRequestError)(`missing field : ${field}`);
         }
     }
 };
 exports.checkMissingFields = checkMissingFields;
+const checkEnvValue = (key) => {
+    let value = process.env[key];
+    if (!value) {
+        throw (0, constants_1.InternalServerError)(`${key} not found`);
+    }
+    return value;
+};
+exports.checkEnvValue = checkEnvValue;
 const checkMissingFieldsAndType = (fields, types = {}) => {
     for (const field in fields) {
         if ((0, exports.isEmpty)(fields[field])) {
-            throw (0, __1.BadRequestError)(`missing field : ${field}`);
+            throw (0, constants_1.BadRequestError)(`missing field : ${field}`);
         }
         if (types[field] && typeof fields[field] !== types[field]) {
-            throw (0, __1.BadRequestError)(`Type of ${field} expected : "${types[field]}", got : "${typeof fields[field]}"`);
+            throw (0, constants_1.BadRequestError)(`Type of ${field} expected : "${types[field]}", got : "${typeof fields[field]}"`);
         }
     }
 };
@@ -38,13 +46,13 @@ const checkObjectFieldsAndType = (data, types = {}, prefix = "") => {
     let keys = Object.keys(types);
     for (const key of keys) {
         if ((0, exports.isEmpty)(data[key])) {
-            throw (0, __1.BadRequestError)(`missing field : ${prefix}.${key}`);
+            throw (0, constants_1.BadRequestError)(`missing field : ${prefix}.${key}`);
         }
         if (typeof data[key] === "object") {
             (0, exports.checkObjectFieldsAndType)(data[key], types[key], `${prefix}.${key}`);
         }
         else if (typeof data[key] !== types[key]) {
-            throw (0, __1.BadRequestError)(`Type of ${prefix}.${key} expected : "${types[key]}", got : "${typeof data[key]}"`);
+            throw (0, constants_1.BadRequestError)(`Type of ${prefix}.${key} expected : "${types[key]}", got : "${typeof data[key]}"`);
         }
     }
 };

package/dist/utils/index.d.ts

@@ -6,6 +6,8 @@ export * from "./address";
 export * from "./dataStructHelper";
 export * from "./extraUtils";
 export * from "./time";
+export * from "./signer";
 export * from "./ethersAwsKmsSigner";
 export * from "./secretManagerService";
 export * from "./eventGetter";
+export * from "./s3Service";

package/dist/utils/index.js

@@ -22,6 +22,8 @@ __exportStar(require("./address"), exports);
 __exportStar(require("./dataStructHelper"), exports);
 __exportStar(require("./extraUtils"), exports);
 __exportStar(require("./time"), exports);
+__exportStar(require("./signer"), exports);
 __exportStar(require("./ethersAwsKmsSigner"), exports);
 __exportStar(require("./secretManagerService"), exports);
 __exportStar(require("./eventGetter"), exports);
+__exportStar(require("./s3Service"), exports);

package/dist/utils/relaySigner.d.ts

@@ -2,17 +2,15 @@ import { Provider, TransactionRequest, TransactionResponse } from "@ethersprojec
 import { Signer } from "@ethersproject/abstract-signer";
 import { Bytes } from "@ethersproject/bytes";
 import { Deferrable } from "@ethersproject/properties";
-import { ChainSlug } from "@socket.tech/dl-core";
 export declare class SocketRelaySigner extends Signer {
     readonly provider: Provider;
-    readonly chainSlug: ChainSlug;
+    readonly chainId: number;
     readonly relayUrl: string;
     readonly relayerAPIKey: string;
     readonly sequential: boolean;
     readonly isCritical: boolean;
     readonly metadata: object;
-    readonly source: string;
-    constructor(provider: Provider, chainSlug: ChainSlug, relayUrl: string, relayerAPIKey: string, sequential?: boolean, isCritical?: boolean, metadata?: object, source?: string);
+    constructor(provider: Provider, chainId: number, relayUrl: string, relayerAPIKey: string, sequential?: boolean, isCritical?: boolean, metadata?: object);
     getAddress(): Promise<string>;
     signMessage(message: string | Bytes): Promise<string>;
     connect(provider: Provider): SocketRelaySigner;

package/dist/utils/relaySigner.js

@@ -3,21 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SocketRelaySigner = void 0;
 const abstract_signer_1 = require("@ethersproject/abstract-signer");
 const axios_1 = require("./axios");
-const dl_core_1 = require("@socket.tech/dl-core");
 class SocketRelaySigner extends abstract_signer_1.Signer {
-    constructor(provider, chainSlug, relayUrl, relayerAPIKey, sequential = false, 
+    constructor(provider, chainId, relayUrl, relayerAPIKey, sequential = false, 
     // if isCritical is set to true, will try multiple relayers
     // to get the transaction included
-    isCritical = false, metadata = {}, source = "Attester") {
+    isCritical = false, metadata = {}) {
         super();
         this.provider = provider;
-        this.chainSlug = chainSlug;
+        this.chainId = chainId;
         this.relayUrl = relayUrl;
         this.relayerAPIKey = relayerAPIKey;
         this.sequential = sequential;
         this.isCritical = isCritical;
         this.metadata = metadata;
-        this.source = source;
     }
     async getAddress() {
         // some random address
@@ -27,13 +25,13 @@ class SocketRelaySigner extends abstract_signer_1.Signer {
         throw new Error(" signMessage not Implemented");
     }
     connect(provider) {
-        return new SocketRelaySigner(provider, this.chainSlug, this.relayUrl, this.relayerAPIKey, this.sequential, this.isCritical, this.metadata);
+        return new SocketRelaySigner(provider, this.chainId, this.relayUrl, this.relayerAPIKey, this.sequential, this.isCritical, this.metadata);
     }
     setCritical(isCritical) {
-        return new SocketRelaySigner(this.provider, this.chainSlug, this.relayUrl, this.relayerAPIKey, this.sequential, isCritical, this.metadata);
+        return new SocketRelaySigner(this.provider, this.chainId, this.relayUrl, this.relayerAPIKey, this.sequential, isCritical, this.metadata);
     }
     addMetadata(metadata) {
-        return new SocketRelaySigner(this.provider, this.chainSlug, this.relayUrl, this.relayerAPIKey, this.sequential, this.isCritical, metadata);
+        return new SocketRelaySigner(this.provider, this.chainId, this.relayUrl, this.relayerAPIKey, this.sequential, this.isCritical, metadata);
     }
     async signTransaction(transaction) {
         throw new Error(" signTransaction not Implemented");
@@ -45,10 +43,9 @@ class SocketRelaySigner extends abstract_signer_1.Signer {
             if (!this.relayUrl)
                 throw new Error("relayUrl not provided");
             let payload = {
-                chainId: dl_core_1.ChainSlugToId[this.chainSlug],
+                chainId: this.chainId,
                 sequential: this.sequential,
                 isCritical: this.isCritical,
-                source: this.source,
                 metadata: this.metadata,
                 ...transaction,
             };

package/dist/utils/s3Service.d.ts

@@ -0,0 +1,5 @@
+import { DeploymentMode } from "@socket.tech/dl-core";
+import { Accounts } from "..";
+export declare const initS3Client: (region: string) => Promise<void>;
+export declare const getFileFromS3: (bucket: string, filePath: string) => Promise<any>;
+export declare const getS3Config: (deploymentMode: DeploymentMode, region?: string, account?: Accounts.dl | Accounts.ll) => Promise<any>;

package/dist/utils/s3Service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getS3Config = exports.getFileFromS3 = exports.initS3Client = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const dl_core_1 = require("@socket.tech/dl-core");
+const __1 = require("..");
+// Set your AWS credentials and region
+let s3Client;
+const initS3Client = async (region) => {
+    s3Client = new client_s3_1.S3Client({
+        region,
+    });
+};
+exports.initS3Client = initS3Client;
+const getFileFromS3 = async (bucket, filePath) => {
+    var _a;
+    try {
+        // Create an S3 GET operation command
+        const getObjectCommand = new client_s3_1.GetObjectCommand({
+            Bucket: bucket,
+            Key: filePath,
+        });
+        // Execute the command and get the response
+        const s3Response = await s3Client.send(getObjectCommand);
+        const jsonStr = await ((_a = s3Response.Body) === null || _a === void 0 ? void 0 : _a.transformToString());
+        let response;
+        if (jsonStr)
+            response = JSON.parse(jsonStr);
+        return response;
+    }
+    catch (error) {
+        console.error("Error downloading file from S3:", error);
+        throw error;
+    }
+};
+exports.getFileFromS3 = getFileFromS3;
+const getS3Config = async (deploymentMode, region = "us-east-1", account = __1.Accounts.dl) => {
+    const S3_BUCKET_NAME = deploymentMode == dl_core_1.DeploymentMode.PROD
+        ? `socket-${account}-` + deploymentMode
+        : `socket-ll-` + deploymentMode;
+    const S3_RPC_CONFIG_FILE_PATH = deploymentMode + "RpcConfig.json";
+    (0, exports.initS3Client)(region);
+    return await (0, exports.getFileFromS3)(S3_BUCKET_NAME, S3_RPC_CONFIG_FILE_PATH);
+};
+exports.getS3Config = getS3Config;

package/dist/utils/signer/adapter.d.ts

@@ -0,0 +1,18 @@
+import type { Signer as ISigner } from "./signer";
+import { Signer } from "@ethersproject/abstract-signer";
+import { Deferrable } from "@ethersproject/properties";
+import { Bytes } from "@ethersproject/bytes";
+import type { Provider, TransactionRequest } from "@ethersproject/abstract-provider";
+export type AdapterConfig = {
+    signer: ISigner;
+    version: string;
+};
+export declare class Adapter extends Signer {
+    private readonly signer;
+    private readonly logger;
+    constructor(config: AdapterConfig, provider?: Provider);
+    getAddress(): Promise<string>;
+    signMessage(message: Bytes | string): Promise<string>;
+    signTransaction(deferrableTransaction: Deferrable<TransactionRequest>): Promise<string>;
+    connect(provider: Provider): Adapter;
+}