Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

@fastlane-labs/atlas-config

Package Overview
Dependencies
Maintainers
0
Versions
6
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@fastlane-labs/atlas-config - npm Package Compare versions

Comparing version 0.1.3 to 1.3.0

dist/chain-configs-multi-version.json

13

dist/index.d.ts

@@ -1,12 +0,17 @@

import type { ChainConfig, PartialChainConfig } from './types';
import type { ChainConfig, VersionConfig, PartialChainConfig } from './types';
export declare const chainConfig: {
[chainId: string]: ChainConfig;
};
export declare function getChainConfig(chainId: number): ChainConfig;
export declare function getChainConfig(chainId: number, version?: string): VersionConfig;
export declare function getSupportedChainIds(): number[];
export declare function getAllChainConfigs(): ChainConfig[];
export declare function getVersionsForChain(chainId: number): string[];
export declare function getAllChainConfigs(): {
chainId: number;
version: string;
config: VersionConfig;
}[];
export declare function mergeChainConfigs(providedConfigs: {
[chainId: string]: PartialChainConfig | ChainConfig;
[chainId: string]: PartialChainConfig;
}): {
[chainId: string]: ChainConfig;
};

@@ -7,55 +7,145 @@ "use strict";

exports.getSupportedChainIds = getSupportedChainIds;
exports.getVersionsForChain = getVersionsForChain;
exports.getAllChainConfigs = getAllChainConfigs;
exports.mergeChainConfigs = mergeChainConfigs;
let config;
let config = {};
try {
config = require('chain-config.json');
}
catch (e) {
try {
config = require('./chain-config.json');
// Try different possible paths for the config file
const paths = [
'../configs/chain-configs-multi-version.json',
'./chain-configs-multi-version.json',
'chain-configs-multi-version.json'
];
for (const path of paths) {
try {
config = require(path);
break;
}
catch (e) {
continue;
}
}
catch (e) {
console.error('Error loading ./chain-config.json:', e);
config = {};
if (Object.keys(config).length === 0) {
throw new Error('Could not load config file');
}
}
catch (e) {
console.error('Error loading chain-configs-multi-version.json:', e);
}
exports.chainConfig = config;
function getChainConfig(chainId) {
const config = exports.chainConfig[chainId.toString()];
if (!config) {
function getChainConfig(chainId, version) {
const chainConf = exports.chainConfig[chainId.toString()];
if (!chainConf) {
throw new Error(`Chain configuration not found for chainId: ${chainId}`);
}
return config;
// If version is not specified, return the latest version
if (!version) {
const versions = Object.keys(chainConf).sort((a, b) => {
return parseFloat(b) - parseFloat(a);
});
version = versions[0];
}
const versionConfig = chainConf[version];
if (!versionConfig) {
throw new Error(`Version ${version} not found for chainId: ${chainId}`);
}
return versionConfig;
}
// New function to return all supported chainIds
function getSupportedChainIds() {
return Object.keys(exports.chainConfig).map(Number);
}
// New function to return all chain configs as a list
function getVersionsForChain(chainId) {
const chainConf = exports.chainConfig[chainId.toString()];
if (!chainConf) {
return [];
}
return Object.keys(chainConf);
}
function getAllChainConfigs() {
return Object.values(exports.chainConfig);
const configs = [];
for (const [chainId, chainConf] of Object.entries(exports.chainConfig)) {
for (const [version, versionConfig] of Object.entries(chainConf)) {
configs.push({
chainId: Number(chainId),
version,
config: versionConfig
});
}
}
return configs;
}
// Updated function to merge provided chain configs with the original
function isFullVersionConfig(config) {
const hasAllContracts = typeof config.contracts === 'object' &&
config.contracts !== null &&
Object.entries(config.contracts).every(([key, value]) => value !== null &&
typeof value === 'object' &&
'address' in value &&
typeof value.address === 'string') &&
['atlas', 'atlasVerification', 'sorter', 'simulator', 'multicall3'].every(key => key in config.contracts);
const hasValidEip712Domain = typeof config.eip712Domain === 'object' &&
config.eip712Domain !== null &&
typeof config.eip712Domain.name === 'string' &&
typeof config.eip712Domain.version === 'string' &&
typeof config.eip712Domain.chainId === 'number' &&
typeof config.eip712Domain.verifyingContract === 'string';
return hasAllContracts && hasValidEip712Domain;
}
function convertPartialContractConfig(partialConfig) {
const result = {};
for (const [key, value] of Object.entries(partialConfig)) {
if (value && 'address' in value) {
result[key] = value.address;
}
}
return result;
}
function convertToVersionConfig(config) {
return {
contracts: {
atlas: config.contracts.atlas.address,
atlasVerification: config.contracts.atlasVerification.address,
sorter: config.contracts.sorter.address,
simulator: config.contracts.simulator.address,
multicall3: config.contracts.multicall3.address
},
eip712Domain: config.eip712Domain
};
}
function mergeChainConfigs(providedConfigs) {
const mergedConfig = Object.assign({}, exports.chainConfig);
for (const [chainId, providedConfig] of Object.entries(providedConfigs)) {
if (mergedConfig[chainId]) {
// Existing chain
if (isFullChainConfig(providedConfig)) {
// Prioritize new complete config
mergedConfig[chainId] = providedConfig;
}
else {
// Merge partial config
mergedConfig[chainId] = Object.assign(Object.assign(Object.assign({}, mergedConfig[chainId]), providedConfig), { contracts: Object.assign(Object.assign({}, mergedConfig[chainId].contracts), providedConfig.contracts), eip712Domain: Object.assign(Object.assign({}, mergedConfig[chainId].eip712Domain), providedConfig.eip712Domain) });
}
const mergedConfig = { ...exports.chainConfig };
for (const [chainId, providedVersions] of Object.entries(providedConfigs)) {
if (!mergedConfig[chainId]) {
mergedConfig[chainId] = {};
}
else {
// New chain: ensure full config is provided
if (isFullChainConfig(providedConfig)) {
mergedConfig[chainId] = providedConfig;
for (const [version, providedVersionConfig] of Object.entries(providedVersions)) {
if (mergedConfig[chainId][version]) {
// Existing version
if (isFullVersionConfig(providedVersionConfig)) {
// Prioritize new complete config
mergedConfig[chainId][version] = convertToVersionConfig(providedVersionConfig);
}
else {
// Merge partial config
const currentConfig = mergedConfig[chainId][version];
mergedConfig[chainId][version] = {
...currentConfig,
contracts: {
...currentConfig.contracts,
...(providedVersionConfig.contracts ? convertPartialContractConfig(providedVersionConfig.contracts) : {})
},
eip712Domain: {
...currentConfig.eip712Domain,
...providedVersionConfig.eip712Domain
}
};
}
}
else {
throw new Error(`Full chain configuration must be provided for new chainId: ${chainId}`);
// New version: ensure full config is provided
if (isFullVersionConfig(providedVersionConfig)) {
mergedConfig[chainId][version] = convertToVersionConfig(providedVersionConfig);
}
else {
throw new Error(`Full version configuration must be provided for new version ${version} on chainId: ${chainId}`);
}
}

@@ -66,15 +156,1 @@ }

}
// Helper function to check if a provided config is a full ChainConfig
function isFullChainConfig(config) {
return (typeof config.contracts === 'object' &&
typeof config.contracts.atlas === 'string' &&
typeof config.contracts.atlasVerification === 'string' &&
typeof config.contracts.sorter === 'string' &&
typeof config.contracts.simulator === 'string' &&
typeof config.contracts.multicall3 === 'string' &&
typeof config.eip712Domain === 'object' &&
typeof config.eip712Domain.name === 'string' &&
typeof config.eip712Domain.version === 'string' &&
typeof config.eip712Domain.chainId === 'number' &&
typeof config.eip712Domain.verifyingContract === 'string');
}

@@ -0,19 +1,34 @@

export type ContractConfig = {
atlas: string;
atlasVerification: string;
sorter: string;
simulator: string;
multicall3: string;
};
export type EIP712Domain = {
name: string;
version: string;
chainId: number;
verifyingContract: string;
};
export type VersionConfig = {
contracts: ContractConfig;
eip712Domain: EIP712Domain;
};
export type ChainConfig = {
contracts: {
atlas: string;
atlasVerification: string;
sorter: string;
simulator: string;
multicall3: string;
};
eip712Domain: {
name: string;
version: string;
chainId: number;
verifyingContract: string;
};
[version: string]: VersionConfig;
};
export type ContractAddressConfig = {
address: string;
};
export type PartialContractConfig = {
[K in keyof ContractConfig]?: ContractAddressConfig;
};
export type PartialEIP712Domain = Partial<EIP712Domain>;
export type PartialVersionConfig = {
contracts?: PartialContractConfig;
eip712Domain?: PartialEIP712Domain;
};
export type PartialChainConfig = {
contracts?: Partial<ChainConfig['contracts']>;
eip712Domain?: Partial<ChainConfig['eip712Domain']>;
[version: string]: PartialVersionConfig;
};
{
"name": "@fastlane-labs/atlas-config",
"version": "0.1.3",
"version": "1.3.0",
"description": "A configuration package for Atlas Protocol",
"main": "dist/index.js",
"types": "dist/index.d.ts",
"scripts": {
"clean": "rimraf dist",
"build": "pnpm clean && tsc && cp ../configs/chain-configs-multi-version.json dist/",
"test": "jest",
"test:watch": "jest --watch",
"prepublishOnly": "npm run build"
},
"files": [

@@ -26,14 +33,10 @@ "dist"

"devDependencies": {
"@jest/globals": "^29.7.0",
"@types/jest": "^29.5.13",
"@types/node": "^22.7.5",
"@jest/globals": "^29.7.0",
"jest": "^29.5.0",
"rimraf": "^5.0.10",
"ts-jest": "^29.2.5",
"typescript": "^5.0.4"
},
"dependencies": {},
"scripts": {
"build": "tsc && cp ../configs/chain-config.json dist/",
"test": "jest"
}
}
}
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc