@bosonprotocol/core-sdk 1.29.0-ludo.1 → 1.29.0

package/dist/esm/utils/graphql.js

@@ -1,7 +1,7 @@
-import { GraphQLClient } from "graphql-request";
-import { getSdk } from "../subgraph";
-export function getSubgraphSdk(subgraphUrl) {
-    const client = new GraphQLClient(subgraphUrl);
-    return getSdk(client);
-}
+import { GraphQLClient } from "graphql-request";
+import { getSdk } from "../subgraph";
+export function getSubgraphSdk(subgraphUrl) {
+    const client = new GraphQLClient(subgraphUrl);
+    return getSdk(client);
+}
 //# sourceMappingURL=graphql.js.map

package/dist/esm/utils/logs.d.ts

@@ -1,21 +1,21 @@
-import { Log } from "@bosonprotocol/common";
-import { Interface } from "@ethersproject/abi";
-export declare function getValueFromLogs<T>(args: {
-    iface: Interface;
-    logs: Log[];
-    eventArgsKey: string;
-    eventName: string;
-}): T | null;
-export declare function getValuesFromLogs<T>(args: {
-    iface: Interface;
-    logs: Log[];
-    eventArgsKey: string;
-    eventName: string;
-}): T[];
-export declare function getValuesFromLogsExt<T>(args: {
-    iface: Interface;
-    logs: Log[];
-    eventArgsKeys: string[];
-    eventNames: string[];
-}): Record<string, T[]>;
+import { Log } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+export declare function getValueFromLogs<T>(args: {
+    iface: Interface;
+    logs: Log[];
+    eventArgsKey: string;
+    eventName: string;
+}): T | null;
+export declare function getValuesFromLogs<T>(args: {
+    iface: Interface;
+    logs: Log[];
+    eventArgsKey: string;
+    eventName: string;
+}): T[];
+export declare function getValuesFromLogsExt<T>(args: {
+    iface: Interface;
+    logs: Log[];
+    eventArgsKeys: string[];
+    eventNames: string[];
+}): Record<string, T[]>;
 //# sourceMappingURL=logs.d.ts.map

package/dist/esm/utils/logs.js

@@ -1,48 +1,48 @@
-export function getValueFromLogs(args) {
-    const relevantLogs = getValuesFromLogs(args);
-    if (!relevantLogs || relevantLogs.length === 0) {
-        return null;
-    }
-    return relevantLogs[0];
-}
-export function getValuesFromLogs(args) {
-    const parsedLogs = args.logs
-        .map((log) => {
-        try {
-            return args.iface.parseLog(log);
-        }
-        catch (error) {
-            // assume that failing to parse is irrelevant log
-            return null;
-        }
-    })
-        .filter((log) => log !== null);
-    const relevantLogs = parsedLogs.filter((log) => log.name === args.eventName);
-    if (relevantLogs.length === 0) {
-        return null;
-    }
-    return relevantLogs.map((relevantLog) => relevantLog.args[args.eventArgsKey]);
-}
-export function getValuesFromLogsExt(args) {
-    const parsedLogs = args.logs
-        .map((log) => {
-        try {
-            return args.iface.parseLog(log);
-        }
-        catch (error) {
-            // assume that failing to parse is irrelevant log
-            return null;
-        }
-    })
-        .filter((log) => log !== null);
-    const relevantLogs = parsedLogs.filter((log) => args.eventNames.includes(log.name));
-    if (relevantLogs.length === 0) {
-        return null;
-    }
-    const ret = {};
-    for (const eventArgsKey of args.eventArgsKeys) {
-        ret[eventArgsKey] = relevantLogs.map((relevantLog) => relevantLog.args[eventArgsKey]);
-    }
-    return ret;
-}
+export function getValueFromLogs(args) {
+    const relevantLogs = getValuesFromLogs(args);
+    if (!relevantLogs || relevantLogs.length === 0) {
+        return null;
+    }
+    return relevantLogs[0];
+}
+export function getValuesFromLogs(args) {
+    const parsedLogs = args.logs
+        .map((log) => {
+        try {
+            return args.iface.parseLog(log);
+        }
+        catch (error) {
+            // assume that failing to parse is irrelevant log
+            return null;
+        }
+    })
+        .filter((log) => log !== null);
+    const relevantLogs = parsedLogs.filter((log) => log.name === args.eventName);
+    if (relevantLogs.length === 0) {
+        return null;
+    }
+    return relevantLogs.map((relevantLog) => relevantLog.args[args.eventArgsKey]);
+}
+export function getValuesFromLogsExt(args) {
+    const parsedLogs = args.logs
+        .map((log) => {
+        try {
+            return args.iface.parseLog(log);
+        }
+        catch (error) {
+            // assume that failing to parse is irrelevant log
+            return null;
+        }
+    })
+        .filter((log) => log !== null);
+    const relevantLogs = parsedLogs.filter((log) => args.eventNames.includes(log.name));
+    if (relevantLogs.length === 0) {
+        return null;
+    }
+    const ret = {};
+    for (const eventArgsKey of args.eventArgsKeys) {
+        ret[eventArgsKey] = relevantLogs.map((relevantLog) => relevantLog.args[eventArgsKey]);
+    }
+    return ret;
+}
 //# sourceMappingURL=logs.js.map

package/dist/esm/utils/signature.d.ts

@@ -1,24 +1,24 @@
-import { Web3LibAdapter } from "@bosonprotocol/common";
-declare type SignatureArgs = {
-    web3Lib: Web3LibAdapter;
-    verifyingContractAddress: string;
-    chainId: number;
-    customSignatureType?: Record<string, unknown>;
-    customDomainData?: Record<string, unknown>;
-    primaryType: string;
-    message: Record<string, unknown>;
-};
-export declare function prepareDataSignatureParameters(args: SignatureArgs): Promise<{
-    r: string;
-    s: string;
-    v: number;
-    signature: string;
-}>;
-export declare function getSignatureParameters(signature: string): {
-    r: string;
-    s: string;
-    v: number;
-    signature: string;
-};
-export {};
+import { Web3LibAdapter } from "@bosonprotocol/common";
+type SignatureArgs = {
+    web3Lib: Web3LibAdapter;
+    verifyingContractAddress: string;
+    chainId: number;
+    customSignatureType?: Record<string, unknown>;
+    customDomainData?: Record<string, unknown>;
+    primaryType: string;
+    message: Record<string, unknown>;
+};
+export declare function prepareDataSignatureParameters(args: SignatureArgs): Promise<{
+    r: string;
+    s: string;
+    v: number;
+    signature: string;
+}>;
+export declare function getSignatureParameters(signature: string): {
+    r: string;
+    s: string;
+    v: number;
+    signature: string;
+};
+export {};
 //# sourceMappingURL=signature.d.ts.map

package/dist/esm/utils/signature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../src/utils/signature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAIvD,aAAK,aAAa,GAAG;IACnB,OAAO,EAAE,cAAc,CAAC;IACxB,wBAAwB,EAAE,MAAM,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9C,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,wBAAsB,8BAA8B,CAAC,IAAI,EAAE,aAAa;;;;;GAwCvE;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM;;;;;EAqBvD"}
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../src/utils/signature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAIvD,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,cAAc,CAAC;IACxB,wBAAwB,EAAE,MAAM,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9C,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,wBAAsB,8BAA8B,CAAC,IAAI,EAAE,aAAa;;;;;GAwCvE;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM;;;;;EAqBvD"}

package/dist/esm/utils/signature.js

@@ -1,58 +1,58 @@
-import { isHexString, hexZeroPad } from "@ethersproject/bytes";
-import { BigNumber } from "@ethersproject/bignumber";
-export async function prepareDataSignatureParameters(args) {
-    const domainType = [
-        { name: "name", type: "string" },
-        { name: "version", type: "string" },
-        { name: "verifyingContract", type: "address" },
-        { name: "salt", type: "bytes32" }
-    ];
-    const domainData = {
-        name: "Boson Protocol",
-        version: "V2",
-        verifyingContract: args.verifyingContractAddress,
-        salt: hexZeroPad(BigNumber.from(args.chainId).toHexString(), 32),
-        ...args.customDomainData
-    };
-    Object.keys(domainData).forEach((key) => {
-        if (domainData[key] === undefined) {
-            delete domainData[key];
-        }
-    });
-    const signatureTypes = {
-        EIP712Domain: domainType,
-        ...args.customSignatureType
-    };
-    const dataToSign = JSON.stringify({
-        types: signatureTypes,
-        domain: domainData,
-        primaryType: args.primaryType,
-        message: args.message
-    });
-    const signerAddress = await args.web3Lib.getSignerAddress();
-    const signature = await args.web3Lib.send("eth_signTypedData_v4", [
-        signerAddress,
-        dataToSign
-    ]);
-    return getSignatureParameters(signature);
-}
-export function getSignatureParameters(signature) {
-    if (!isHexString(signature)) {
-        throw new Error(`Value "${signature}" is not a valid hex string`);
-    }
-    const _signature = signature.substring(2);
-    const r = "0x" + _signature.substring(0, 64);
-    const s = "0x" + _signature.substring(64, 128);
-    let v = parseInt(_signature.substring(128, 130), 16);
-    if (!isNaN(v) && v < 2) {
-        // support Ledger signature
-        v = v + 27;
-    }
-    return {
-        r,
-        s,
-        v,
-        signature
-    };
-}
+import { isHexString, hexZeroPad } from "@ethersproject/bytes";
+import { BigNumber } from "@ethersproject/bignumber";
+export async function prepareDataSignatureParameters(args) {
+    const domainType = [
+        { name: "name", type: "string" },
+        { name: "version", type: "string" },
+        { name: "verifyingContract", type: "address" },
+        { name: "salt", type: "bytes32" }
+    ];
+    const domainData = {
+        name: "Boson Protocol",
+        version: "V2",
+        verifyingContract: args.verifyingContractAddress,
+        salt: hexZeroPad(BigNumber.from(args.chainId).toHexString(), 32),
+        ...args.customDomainData
+    };
+    Object.keys(domainData).forEach((key) => {
+        if (domainData[key] === undefined) {
+            delete domainData[key];
+        }
+    });
+    const signatureTypes = {
+        EIP712Domain: domainType,
+        ...args.customSignatureType
+    };
+    const dataToSign = JSON.stringify({
+        types: signatureTypes,
+        domain: domainData,
+        primaryType: args.primaryType,
+        message: args.message
+    });
+    const signerAddress = await args.web3Lib.getSignerAddress();
+    const signature = await args.web3Lib.send("eth_signTypedData_v4", [
+        signerAddress,
+        dataToSign
+    ]);
+    return getSignatureParameters(signature);
+}
+export function getSignatureParameters(signature) {
+    if (!isHexString(signature)) {
+        throw new Error(`Value "${signature}" is not a valid hex string`);
+    }
+    const _signature = signature.substring(2);
+    const r = "0x" + _signature.substring(0, 64);
+    const s = "0x" + _signature.substring(64, 128);
+    let v = parseInt(_signature.substring(128, 130), 16);
+    if (!isNaN(v) && v < 2) {
+        // support Ledger signature
+        v = v + 27;
+    }
+    return {
+        r,
+        s,
+        v,
+        signature
+    };
+}
 //# sourceMappingURL=signature.js.map

package/dist/esm/utils/tokenInfoManager.d.ts

@@ -1,24 +1,24 @@
-import { Web3LibAdapter } from "@bosonprotocol/common";
-export interface ITokenInfo {
-    name: string;
-    decimals: number;
-    symbol: string;
-}
-export interface ITokenInfoManager {
-    getExchangeTokenInfo: (tokenAddress: string) => Promise<ITokenInfo>;
-}
-export declare const NATIVE_TOKENS: {
-    [key: number]: ITokenInfo;
-};
-export declare class TokenInfoManager implements ITokenInfoManager {
-    private static TokenInfos;
-    private static mapInitialized;
-    private _web3Lib;
-    private _subgraphUrl;
-    private _chainId;
-    private static InvalidAddresses;
-    constructor(chainId: number, web3Lib: Web3LibAdapter, subgraphUrl: string);
-    getExchangeTokenInfo(tokenAddress: string): Promise<ITokenInfo | undefined>;
-    private ensureInitialized;
-}
+import { Web3LibAdapter } from "@bosonprotocol/common";
+export interface ITokenInfo {
+    name: string;
+    decimals: number;
+    symbol: string;
+}
+export interface ITokenInfoManager {
+    getExchangeTokenInfo: (tokenAddress: string) => Promise<ITokenInfo>;
+}
+export declare const NATIVE_TOKENS: {
+    [key: number]: ITokenInfo;
+};
+export declare class TokenInfoManager implements ITokenInfoManager {
+    private static TokenInfos;
+    private static mapInitialized;
+    private _web3Lib;
+    private _subgraphUrl;
+    private _chainId;
+    private static InvalidAddresses;
+    constructor(chainId: number, web3Lib: Web3LibAdapter, subgraphUrl: string);
+    getExchangeTokenInfo(tokenAddress: string): Promise<ITokenInfo | undefined>;
+    private ensureInitialized;
+}
 //# sourceMappingURL=tokenInfoManager.d.ts.map

package/dist/esm/utils/tokenInfoManager.js

@@ -1,126 +1,126 @@
-import { AddressZero } from "@ethersproject/constants";
-import { getDecimals, getName, getSymbol } from "../erc20/handler";
-import { getExchangeTokens } from "../erc20/subgraph";
-export const NATIVE_TOKENS = {
-    1: {
-        // Ethereum Mainnet
-        name: "Ether",
-        decimals: 18,
-        symbol: "ETH"
-    },
-    3: {
-        // Ethereum Ropsten
-        name: "Ether",
-        decimals: 18,
-        symbol: "ETH"
-    },
-    4: {
-        // Ethereum Rinkeby
-        name: "Ether",
-        decimals: 18,
-        symbol: "ETH"
-    },
-    5: {
-        // Ethereum Goerli
-        name: "Ether",
-        decimals: 18,
-        symbol: "ETH"
-    },
-    137: {
-        // Polygon Mainnet
-        name: "MATIC",
-        decimals: 18,
-        symbol: "MATIC"
-    },
-    80001: {
-        // Polygon Mumbai
-        name: "MATIC",
-        decimals: 18,
-        symbol: "MATIC"
-    },
-    1234: {
-        // Private Node
-        name: "Ether",
-        decimals: 18,
-        symbol: "ETH"
-    },
-    31337: {
-        // Local Hardhat
-        name: "Ether",
-        decimals: 18,
-        symbol: "ETH"
-    }
-};
-export class TokenInfoManager {
-    static TokenInfos = new Map();
-    static mapInitialized = new Map();
-    _web3Lib;
-    _subgraphUrl;
-    _chainId;
-    static InvalidAddresses = new Map();
-    constructor(chainId, web3Lib, subgraphUrl) {
-        if (!NATIVE_TOKENS[chainId]) {
-            throw new Error(`Unexpected chainId value '${chainId}'`);
-        }
-        if (!TokenInfoManager.TokenInfos.has(chainId)) {
-            const tokenInfos = new Map();
-            tokenInfos.set(AddressZero, NATIVE_TOKENS[chainId]);
-            TokenInfoManager.TokenInfos.set(chainId, tokenInfos);
-        }
-        if (!TokenInfoManager.mapInitialized.has(chainId)) {
-            TokenInfoManager.mapInitialized.set(chainId, false);
-        }
-        if (!TokenInfoManager.InvalidAddresses.has(chainId)) {
-            TokenInfoManager.InvalidAddresses.set(chainId, new Set());
-        }
-        this._web3Lib = web3Lib;
-        this._subgraphUrl = subgraphUrl;
-        this._chainId = chainId;
-    }
-    async getExchangeTokenInfo(tokenAddress) {
-        await this.ensureInitialized();
-        const tokenInfos = TokenInfoManager.TokenInfos.get(this._chainId);
-        const invalidAddressesSet = TokenInfoManager.InvalidAddresses.get(this._chainId);
-        const key = tokenAddress.toLowerCase();
-        if (!tokenInfos.has(key) && !invalidAddressesSet.has(key)) {
-            const args = {
-                web3Lib: this._web3Lib,
-                contractAddress: tokenAddress
-            };
-            try {
-                const [decimals, name, symbol] = await Promise.all([
-                    getDecimals(args),
-                    getName(args),
-                    getSymbol(args)
-                ]);
-                tokenInfos.set(key, {
-                    decimals,
-                    name,
-                    symbol
-                });
-            }
-            catch (error) {
-                invalidAddressesSet.add(key);
-            }
-        }
-        return tokenInfos.get(key);
-    }
-    async ensureInitialized() {
-        const isInitialized = TokenInfoManager.mapInitialized.get(this._chainId);
-        if (!isInitialized) {
-            // Be sure we are initializing the map only one time per chainId
-            TokenInfoManager.mapInitialized.set(this._chainId, true);
-            const tokenInfos = TokenInfoManager.TokenInfos.get(this._chainId);
-            // Get all tokens from subgraph
-            const tokens = await getExchangeTokens(this._subgraphUrl);
-            for (const token of tokens) {
-                tokenInfos.set(token.address.toLowerCase(), {
-                    decimals: parseInt(token.decimals),
-                    name: token.name,
-                    symbol: token.symbol
-                });
-            }
-        }
-    }
-}
+import { AddressZero } from "@ethersproject/constants";
+import { getDecimals, getName, getSymbol } from "../erc20/handler";
+import { getExchangeTokens } from "../erc20/subgraph";
+export const NATIVE_TOKENS = {
+    1: {
+        // Ethereum Mainnet
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    3: {
+        // Ethereum Ropsten
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    4: {
+        // Ethereum Rinkeby
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    5: {
+        // Ethereum Goerli
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    137: {
+        // Polygon Mainnet
+        name: "MATIC",
+        decimals: 18,
+        symbol: "MATIC"
+    },
+    80001: {
+        // Polygon Mumbai
+        name: "MATIC",
+        decimals: 18,
+        symbol: "MATIC"
+    },
+    1234: {
+        // Private Node
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    31337: {
+        // Local Hardhat
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    }
+};
+export class TokenInfoManager {
+    static TokenInfos = new Map();
+    static mapInitialized = new Map();
+    _web3Lib;
+    _subgraphUrl;
+    _chainId;
+    static InvalidAddresses = new Map();
+    constructor(chainId, web3Lib, subgraphUrl) {
+        if (!NATIVE_TOKENS[chainId]) {
+            throw new Error(`Unexpected chainId value '${chainId}'`);
+        }
+        if (!TokenInfoManager.TokenInfos.has(chainId)) {
+            const tokenInfos = new Map();
+            tokenInfos.set(AddressZero, NATIVE_TOKENS[chainId]);
+            TokenInfoManager.TokenInfos.set(chainId, tokenInfos);
+        }
+        if (!TokenInfoManager.mapInitialized.has(chainId)) {
+            TokenInfoManager.mapInitialized.set(chainId, false);
+        }
+        if (!TokenInfoManager.InvalidAddresses.has(chainId)) {
+            TokenInfoManager.InvalidAddresses.set(chainId, new Set());
+        }
+        this._web3Lib = web3Lib;
+        this._subgraphUrl = subgraphUrl;
+        this._chainId = chainId;
+    }
+    async getExchangeTokenInfo(tokenAddress) {
+        await this.ensureInitialized();
+        const tokenInfos = TokenInfoManager.TokenInfos.get(this._chainId);
+        const invalidAddressesSet = TokenInfoManager.InvalidAddresses.get(this._chainId);
+        const key = tokenAddress.toLowerCase();
+        if (!tokenInfos.has(key) && !invalidAddressesSet.has(key)) {
+            const args = {
+                web3Lib: this._web3Lib,
+                contractAddress: tokenAddress
+            };
+            try {
+                const [decimals, name, symbol] = await Promise.all([
+                    getDecimals(args),
+                    getName(args),
+                    getSymbol(args)
+                ]);
+                tokenInfos.set(key, {
+                    decimals,
+                    name,
+                    symbol
+                });
+            }
+            catch (error) {
+                invalidAddressesSet.add(key);
+            }
+        }
+        return tokenInfos.get(key);
+    }
+    async ensureInitialized() {
+        const isInitialized = TokenInfoManager.mapInitialized.get(this._chainId);
+        if (!isInitialized) {
+            // Be sure we are initializing the map only one time per chainId
+            TokenInfoManager.mapInitialized.set(this._chainId, true);
+            const tokenInfos = TokenInfoManager.TokenInfos.get(this._chainId);
+            // Get all tokens from subgraph
+            const tokens = await getExchangeTokens(this._subgraphUrl);
+            for (const token of tokens) {
+                tokenInfos.set(token.address.toLowerCase(), {
+                    decimals: parseInt(token.decimals),
+                    name: token.name,
+                    symbol: token.symbol
+                });
+            }
+        }
+    }
+}
 //# sourceMappingURL=tokenInfoManager.js.map