revert to og code

Author: realdealshaman

src/adapters/peggedAssets/societe-generale-forge-eurcv/index.ts

@@ -1,57 +1,108 @@
 const sdk = require("@defillama/sdk");
-import { Balances, ChainBlocks, PeggedIssuanceAdapter } from "../peggedAsset.type";
-import { chainContracts } from "./config";
-import { sumSingleBalance } from "../helper/generalUtil";
-import { solanaMintedOrBridged } from "../helper/getSupply";
-import { getTokenBalance } from "../helper/solana";
-
-const getChainBalance =
-  (chain: string, decimals: number, type: "minted" | "unreleased", owner?: string) =>
-  async (_ts: number, _ethBlock: number, chainBlocks: ChainBlocks) => {
-    const balances: Balances = {};
-    for (const token of chainContracts[chain].issued) {
-      const value =
-        type === "minted"
-          ? (
-              await sdk.api.abi.call({
-                abi: "erc20:totalSupply",
-                target: token,
-                block: chainBlocks[chain],
-                chain,
-              })
-            ).output
-          : (
-              await sdk.api.erc20.balanceOf({
-                target: token,
-                owner: owner!,
-                block: chainBlocks[chain],
-                chain,
-              })
+import {Balances, ChainBlocks, PeggedAssetType, PeggedIssuanceAdapter} from "../peggedAsset.type";
+import {chainContracts} from "../societe-generale-forge-eurcv/config";
+import {getTokenBalance as solanaGetTokenBalance, getTokenSupply as solanaGetTokenSupply} from "../helper/solana";
+import {sumSingleBalance} from "../helper/generalUtil";
+
+
+
+async function chainMinted(chain: string, decimals: number) {
+    return async function (
+        _timestamp: number,
+        _ethBlock: number,
+        _chainBlocks: ChainBlocks
+    ) {
+        let balances = {} as Balances;
+        for (let issued of chainContracts[chain].issued) {
+            const totalSupply = (
+                await sdk.api.abi.call({
+                    abi: "erc20:totalSupply",
+                    target: issued,
+                    block: _chainBlocks?.[chain],
+                    chain: chain,
+                })
+            ).output;
+            sumSingleBalance(
+                balances,
+                "peggedEUR",
+                totalSupply / 10 ** decimals,
+                "issued",
+                false
+            );
+        }
+        return balances;
+    };
+}
+
+async function chainUnreleased(chain: string, decimals: number, owner: string) {
+    return async function (
+        _timestamp: number,
+        _ethBlock: number,
+        _chainBlocks: ChainBlocks
+    ) {
+        let balances = {} as Balances;
+        for (let issued of chainContracts[chain].issued) {
+            const reserve = (
+                await sdk.api.erc20.balanceOf({
+                    target: issued,
+                    owner: owner,
+                    block: _chainBlocks?.[chain],
+                    chain: chain,
+                })
             ).output;
-      sumSingleBalance(balances, "peggedEUR", +value / 10 ** decimals, "issued", false);
-    }
-    return balances;
-  };
+            sumSingleBalance(balances, "peggedEUR", reserve / 10 ** decimals, "issued", false);
+        }
+        return balances;
+    };
+}
 
+export function solanaMintedOrBridged(
+    targets: string[]
+) {
+    return async function (
+        _timestamp: number,
+        _ethBlock: number,
+        _chainBlocks: ChainBlocks
+    ) {
+        let balances = {} as Balances;
+        for (let target of targets) {
+            const totalSupply = await solanaGetTokenSupply(target);
+            sumSingleBalance(balances, "peggedEUR", totalSupply, target, false);
+        }
+        return balances;
+    };
+}
 
-const solanaUnreleased = async () => {
-  const balances: Balances = {};
-  for (const addr of chainContracts.solana.unreleased) {
-    const amount = await getTokenBalance(chainContracts.solana.issued[0], addr);
-    sumSingleBalance(balances, "peggedEUR", amount, addr, false);
-  }
-  return balances;
-};
+async function solanaUnreleased() {
+    return async function (
+        _timestamp: number,
+        _ethBlock: number,
+        _chainBlocks: ChainBlocks
+    ) {
+        let balances = {} as Balances;
+        for (let unreleasedAddress of chainContracts["solana"].unreleased) {
+            sumSingleBalance(balances, "peggedEUR", await solanaGetTokenBalance(
+                chainContracts["solana"].issued[0],
+                unreleasedAddress
+            ),unreleasedAddress, false);
+        }
+        return balances;
+    };
+}
 
 const adapter: PeggedIssuanceAdapter = {
-  ethereum: {
-    minted: getChainBalance("ethereum", 18, "minted"),
-    unreleased: getChainBalance("ethereum", 18, "unreleased", chainContracts.ethereum.unreleased[0]),
-  },
-  solana: {
-    minted: solanaMintedOrBridged(chainContracts.solana.issued, "peggedEUR"),
-    unreleased: () => solanaUnreleased(),
-  },
-};
+    ethereum: {
+        minted: chainMinted("ethereum", 18),
+        unreleased: chainUnreleased(
+            "ethereum",
+            18,
+            chainContracts.ethereum.unreleased[0]
+        ),
+    },
+    solana: {
+        minted: solanaMintedOrBridged(chainContracts.solana.issued),
+        unreleased: solanaUnreleased()
+    },
+}
 
 export default adapter;