@andrewkimjoseph/celina-sdk 0.25.6 → 0.25.7

package/build/clients/generated/citizen-sdk.bundle.js

@@ -0,0 +1,1133 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/lz-string/libs/lz-string.js
+var require_lz_string = __commonJS({
+  "node_modules/lz-string/libs/lz-string.js"(exports, module) {
+    var LZString = (function() {
+      var f = String.fromCharCode;
+      var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+      var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
+      var baseReverseDic = {};
+      function getBaseValue(alphabet, character) {
+        if (!baseReverseDic[alphabet]) {
+          baseReverseDic[alphabet] = {};
+          for (var i = 0; i < alphabet.length; i++) {
+            baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+          }
+        }
+        return baseReverseDic[alphabet][character];
+      }
+      var LZString2 = {
+        compressToBase64: function(input) {
+          if (input == null) return "";
+          var res = LZString2._compress(input, 6, function(a) {
+            return keyStrBase64.charAt(a);
+          });
+          switch (res.length % 4) {
+            // To produce valid Base64
+            default:
+            // When could this happen ?
+            case 0:
+              return res;
+            case 1:
+              return res + "===";
+            case 2:
+              return res + "==";
+            case 3:
+              return res + "=";
+          }
+        },
+        decompressFromBase64: function(input) {
+          if (input == null) return "";
+          if (input == "") return null;
+          return LZString2._decompress(input.length, 32, function(index) {
+            return getBaseValue(keyStrBase64, input.charAt(index));
+          });
+        },
+        compressToUTF16: function(input) {
+          if (input == null) return "";
+          return LZString2._compress(input, 15, function(a) {
+            return f(a + 32);
+          }) + " ";
+        },
+        decompressFromUTF16: function(compressed) {
+          if (compressed == null) return "";
+          if (compressed == "") return null;
+          return LZString2._decompress(compressed.length, 16384, function(index) {
+            return compressed.charCodeAt(index) - 32;
+          });
+        },
+        //compress into uint8array (UCS-2 big endian format)
+        compressToUint8Array: function(uncompressed) {
+          var compressed = LZString2.compress(uncompressed);
+          var buf = new Uint8Array(compressed.length * 2);
+          for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) {
+            var current_value = compressed.charCodeAt(i);
+            buf[i * 2] = current_value >>> 8;
+            buf[i * 2 + 1] = current_value % 256;
+          }
+          return buf;
+        },
+        //decompress from uint8array (UCS-2 big endian format)
+        decompressFromUint8Array: function(compressed) {
+          if (compressed === null || compressed === void 0) {
+            return LZString2.decompress(compressed);
+          } else {
+            var buf = new Array(compressed.length / 2);
+            for (var i = 0, TotalLen = buf.length; i < TotalLen; i++) {
+              buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1];
+            }
+            var result = [];
+            buf.forEach(function(c) {
+              result.push(f(c));
+            });
+            return LZString2.decompress(result.join(""));
+          }
+        },
+        //compress into a string that is already URI encoded
+        compressToEncodedURIComponent: function(input) {
+          if (input == null) return "";
+          return LZString2._compress(input, 6, function(a) {
+            return keyStrUriSafe.charAt(a);
+          });
+        },
+        //decompress from an output of compressToEncodedURIComponent
+        decompressFromEncodedURIComponent: function(input) {
+          if (input == null) return "";
+          if (input == "") return null;
+          input = input.replace(/ /g, "+");
+          return LZString2._decompress(input.length, 32, function(index) {
+            return getBaseValue(keyStrUriSafe, input.charAt(index));
+          });
+        },
+        compress: function(uncompressed) {
+          return LZString2._compress(uncompressed, 16, function(a) {
+            return f(a);
+          });
+        },
+        _compress: function(uncompressed, bitsPerChar, getCharFromInt) {
+          if (uncompressed == null) return "";
+          var i, value, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii;
+          for (ii = 0; ii < uncompressed.length; ii += 1) {
+            context_c = uncompressed.charAt(ii);
+            if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
+              context_dictionary[context_c] = context_dictSize++;
+              context_dictionaryToCreate[context_c] = true;
+            }
+            context_wc = context_w + context_c;
+            if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
+              context_w = context_wc;
+            } else {
+              if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+                if (context_w.charCodeAt(0) < 256) {
+                  for (i = 0; i < context_numBits; i++) {
+                    context_data_val = context_data_val << 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                  }
+                  value = context_w.charCodeAt(0);
+                  for (i = 0; i < 8; i++) {
+                    context_data_val = context_data_val << 1 | value & 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = value >> 1;
+                  }
+                } else {
+                  value = 1;
+                  for (i = 0; i < context_numBits; i++) {
+                    context_data_val = context_data_val << 1 | value;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = 0;
+                  }
+                  value = context_w.charCodeAt(0);
+                  for (i = 0; i < 16; i++) {
+                    context_data_val = context_data_val << 1 | value & 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = value >> 1;
+                  }
+                }
+                context_enlargeIn--;
+                if (context_enlargeIn == 0) {
+                  context_enlargeIn = Math.pow(2, context_numBits);
+                  context_numBits++;
+                }
+                delete context_dictionaryToCreate[context_w];
+              } else {
+                value = context_dictionary[context_w];
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              }
+              context_enlargeIn--;
+              if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+              }
+              context_dictionary[context_wc] = context_dictSize++;
+              context_w = String(context_c);
+            }
+          }
+          if (context_w !== "") {
+            if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+              if (context_w.charCodeAt(0) < 256) {
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                }
+                value = context_w.charCodeAt(0);
+                for (i = 0; i < 8; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              } else {
+                value = 1;
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1 | value;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = 0;
+                }
+                value = context_w.charCodeAt(0);
+                for (i = 0; i < 16; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              }
+              context_enlargeIn--;
+              if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+              }
+              delete context_dictionaryToCreate[context_w];
+            } else {
+              value = context_dictionary[context_w];
+              for (i = 0; i < context_numBits; i++) {
+                context_data_val = context_data_val << 1 | value & 1;
+                if (context_data_position == bitsPerChar - 1) {
+                  context_data_position = 0;
+                  context_data.push(getCharFromInt(context_data_val));
+                  context_data_val = 0;
+                } else {
+                  context_data_position++;
+                }
+                value = value >> 1;
+              }
+            }
+            context_enlargeIn--;
+            if (context_enlargeIn == 0) {
+              context_enlargeIn = Math.pow(2, context_numBits);
+              context_numBits++;
+            }
+          }
+          value = 2;
+          for (i = 0; i < context_numBits; i++) {
+            context_data_val = context_data_val << 1 | value & 1;
+            if (context_data_position == bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+          while (true) {
+            context_data_val = context_data_val << 1;
+            if (context_data_position == bitsPerChar - 1) {
+              context_data.push(getCharFromInt(context_data_val));
+              break;
+            } else context_data_position++;
+          }
+          return context_data.join("");
+        },
+        decompress: function(compressed) {
+          if (compressed == null) return "";
+          if (compressed == "") return null;
+          return LZString2._decompress(compressed.length, 32768, function(index) {
+            return compressed.charCodeAt(index);
+          });
+        },
+        _decompress: function(length, resetValue, getNextValue) {
+          var dictionary = [], next, enlargeIn = 4, dictSize = 4, numBits = 3, entry = "", result = [], i, w, bits, resb, maxpower, power, c, data = { val: getNextValue(0), position: resetValue, index: 1 };
+          for (i = 0; i < 3; i += 1) {
+            dictionary[i] = i;
+          }
+          bits = 0;
+          maxpower = Math.pow(2, 2);
+          power = 1;
+          while (power != maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+              data.position = resetValue;
+              data.val = getNextValue(data.index++);
+            }
+            bits |= (resb > 0 ? 1 : 0) * power;
+            power <<= 1;
+          }
+          switch (next = bits) {
+            case 0:
+              bits = 0;
+              maxpower = Math.pow(2, 8);
+              power = 1;
+              while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                  data.position = resetValue;
+                  data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+              }
+              c = f(bits);
+              break;
+            case 1:
+              bits = 0;
+              maxpower = Math.pow(2, 16);
+              power = 1;
+              while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                  data.position = resetValue;
+                  data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+              }
+              c = f(bits);
+              break;
+            case 2:
+              return "";
+          }
+          dictionary[3] = c;
+          w = c;
+          result.push(c);
+          while (true) {
+            if (data.index > length) {
+              return "";
+            }
+            bits = 0;
+            maxpower = Math.pow(2, numBits);
+            power = 1;
+            while (power != maxpower) {
+              resb = data.val & data.position;
+              data.position >>= 1;
+              if (data.position == 0) {
+                data.position = resetValue;
+                data.val = getNextValue(data.index++);
+              }
+              bits |= (resb > 0 ? 1 : 0) * power;
+              power <<= 1;
+            }
+            switch (c = bits) {
+              case 0:
+                bits = 0;
+                maxpower = Math.pow(2, 8);
+                power = 1;
+                while (power != maxpower) {
+                  resb = data.val & data.position;
+                  data.position >>= 1;
+                  if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                  }
+                  bits |= (resb > 0 ? 1 : 0) * power;
+                  power <<= 1;
+                }
+                dictionary[dictSize++] = f(bits);
+                c = dictSize - 1;
+                enlargeIn--;
+                break;
+              case 1:
+                bits = 0;
+                maxpower = Math.pow(2, 16);
+                power = 1;
+                while (power != maxpower) {
+                  resb = data.val & data.position;
+                  data.position >>= 1;
+                  if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                  }
+                  bits |= (resb > 0 ? 1 : 0) * power;
+                  power <<= 1;
+                }
+                dictionary[dictSize++] = f(bits);
+                c = dictSize - 1;
+                enlargeIn--;
+                break;
+              case 2:
+                return result.join("");
+            }
+            if (enlargeIn == 0) {
+              enlargeIn = Math.pow(2, numBits);
+              numBits++;
+            }
+            if (dictionary[c]) {
+              entry = dictionary[c];
+            } else {
+              if (c === dictSize) {
+                entry = w + w.charAt(0);
+              } else {
+                return null;
+              }
+            }
+            result.push(entry);
+            dictionary[dictSize++] = w + entry.charAt(0);
+            enlargeIn--;
+            w = entry;
+            if (enlargeIn == 0) {
+              enlargeIn = Math.pow(2, numBits);
+              numBits++;
+            }
+          }
+        }
+      };
+      return LZString2;
+    })();
+    if (typeof define === "function" && define.amd) {
+      define(function() {
+        return LZString;
+      });
+    } else if (typeof module !== "undefined" && module != null) {
+      module.exports = LZString;
+    } else if (typeof angular !== "undefined" && angular != null) {
+      angular.module("LZString", []).factory("LZString", function() {
+        return LZString;
+      });
+    }
+  }
+});
+
+// node_modules/@goodsdks/citizen-sdk/dist/index.js
+var import_lz_string = __toESM(require_lz_string(), 1);
+import { parseAbi, zeroAddress, getAddress, ContractFunctionExecutionError, createPublicClient, http } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+var FV_IDENTIFIER_MSG2 = `Sign this message to request verifying your account <account> and to create your own secret unique identifier for your anonymized record.
+You can use this identifier in the future to delete this anonymized record.
+WARNING: do not sign this message unless you trust the website/application requesting this signature.`;
+var Envs = {
+  production: {
+    dappUrl: "https://wallet.gooddollar.org",
+    identityUrl: "https://goodid.gooddollar.org",
+    backend: "https://goodserver.gooddollar.org",
+    goodCollectiveUrl: "https://goodcollective.vercel.app/"
+  },
+  staging: {
+    dappUrl: "https://qa.gooddollar.org",
+    identityUrl: "https://goodid-qa.vercel.app",
+    backend: "https://goodserver-qa.herokuapp.com",
+    goodCollectiveUrl: "https://dev-goodcollective.vercel.app/"
+  },
+  development: {
+    dappUrl: "https://dev.gooddollar.org",
+    identityUrl: "https://goodid-dev.vercel.app",
+    backend: "https://good-server.herokuapp.com",
+    goodCollectiveUrl: "https://dev-goodcollective.vercel.app/"
+  }
+};
+var SupportedChains = /* @__PURE__ */ ((SupportedChains6) => {
+  SupportedChains6[SupportedChains6["FUSE"] = 122] = "FUSE";
+  SupportedChains6[SupportedChains6["CELO"] = 42220] = "CELO";
+  SupportedChains6[SupportedChains6["XDC"] = 50] = "XDC";
+  return SupportedChains6;
+})(SupportedChains || {});
+var makeExplorer = (baseUrl) => ({
+  address: (address) => `${baseUrl}/address/${address}`,
+  tx: (hash) => `${baseUrl}/tx/${hash}`
+});
+var chainConfigs = {
+  [
+    122
+    /* FUSE */
+  ]: {
+    id: 122,
+    key: "FUSE",
+    label: "Fuse",
+    shortName: "Fuse",
+    explorer: makeExplorer("https://explorer.fuse.io"),
+    rpcUrls: ["https://rpc.fuse.io", "https://fuse-rpc.gateway.pokt.network"],
+    defaultGasPrice: BigInt(11e9),
+    claimGasBuffer: 150000n,
+    fvDefaultChain: 42220,
+    contracts: {
+      production: {
+        identityContract: "0x2F9C28de9e6d44b71B91b8BA337A5D82e308E7BE",
+        ubiContract: "0xd253A5203817225e9768C05E5996d642fb96bA86",
+        faucetContract: "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9",
+        g$Contract: "0x495d133B938596C9984d462F007B676bDc57eCEC"
+      },
+      staging: {
+        identityContract: "0xb0cD4828Cc90C5BC28f4920Adf2Fd8F025003D7E",
+        ubiContract: "0x54469071Ca82B46A2C01C09D38ca6Ca4347EB21d",
+        faucetContract: "0x70f361EDB97B245E8A68573637A31886A427fe2a",
+        g$Contract: "0xe39236a9Cf13f65DB8adD06BD4b834C65c523d2b"
+      },
+      development: {
+        identityContract: "0x1e006225cff7d37411db28f652e0Da9D20325eBb",
+        ubiContract: "0x3bdeB796950301FfC9568fAF89B7370f8B217321",
+        faucetContract: "0x09Ad3430D146aa662eA8c20cBEBceBC0bbB3FB0a",
+        g$Contract: "0x79BeecC4b165Ccf547662cB4f7C0e83b3796E5b3"
+      }
+    }
+  },
+  [
+    42220
+    /* CELO */
+  ]: {
+    id: 42220,
+    key: "CELO",
+    label: "Celo",
+    shortName: "Celo",
+    explorer: makeExplorer("https://celoscan.io"),
+    rpcUrls: ["https://forno.celo.org", "https://rpc.ankr.com/celo"],
+    defaultGasPrice: BigInt(25001e6),
+    claimGasBuffer: 250000n,
+    fvDefaultChain: 42220,
+    contracts: {
+      production: {
+        identityContract: "0xC361A6E67822a0EDc17D899227dd9FC50BD62F42",
+        ubiContract: "0x43d72Ff17701B2DA814620735C39C620Ce0ea4A1",
+        faucetContract: "0x4F93Fa058b03953C851eFaA2e4FC5C34afDFAb84",
+        g$Contract: "0x62B8B11039FcfE5aB0C56E502b1C372A3d2a9c7A"
+      },
+      staging: {
+        identityContract: "0x0108BBc09772973aC27983Fc17c7D82D8e87ef4D",
+        ubiContract: "0x2881d417dA066600372753E73A3570F0781f18cB",
+        faucetContract: "0x9A0F8AEc626A0f493941Ceb1dA6021cFB0567293",
+        g$Contract: "0x61FA0fB802fd8345C06da558240E0651886fec69"
+      },
+      development: {
+        identityContract: "0xF25fA0D4896271228193E782831F6f3CFCcF169C",
+        ubiContract: "0x6B86F82293552C3B9FE380FC038A89e0328C7C5f",
+        faucetContract: "0x635b420e95b364def3A031166dA4bC4F57bf9dEB",
+        g$Contract: "0xFa51eFDc0910CCdA91732e6806912Fa12e2FD475"
+      }
+    }
+  },
+  [
+    50
+    /* XDC */
+  ]: {
+    id: 50,
+    key: "XDC",
+    label: "XDC Network",
+    shortName: "XDC",
+    explorer: makeExplorer("https://xdcscan.com"),
+    rpcUrls: ["https://rpc.ankr.com/xdc"],
+    defaultGasPrice: BigInt(125e8),
+    claimGasBuffer: 150000n,
+    fvDefaultChain: 50,
+    contracts: {
+      production: {
+        identityContract: "0x27a4a02C9ed591E1a86e2e5D05870292c34622C9",
+        ubiContract: "0x22867567E2D80f2049200E25C6F31CB6Ec2F0faf",
+        faucetContract: "0x7344Da1Be296f03fbb8082aDaC5696058B5a9bd9",
+        g$Contract: "0xEC2136843a983885AebF2feB3931F73A8eBEe50c"
+      },
+      development: {
+        identityContract: "0xa6632e9551A340E8582cc797017fbA645695E29f",
+        ubiContract: "0xA2619D468EfE2f6D8b3D915B999327C8fE13aE2c",
+        faucetContract: "0x5CE5e22329914F3317B770184a405E91ef72e489",
+        g$Contract: "0xA13625A72Aef90645CfCe34e25c114629d7855e7"
+      }
+    }
+  }
+};
+var chainIds = Object.values(SupportedChains).filter(
+  (value) => typeof value === "number"
+);
+var chainIdSet = new Set(chainIds);
+var isSupportedChain = (chainId) => typeof chainId === "number" && chainIdSet.has(chainId);
+var createRpcUrlIterator = (chainId) => {
+  const urls = [...chainConfigs[chainId]?.rpcUrls ?? []];
+  if (!urls.length) {
+    throw new Error(`No RPC URLs configured for chain ${chainId}`);
+  }
+  let index = 0;
+  return () => {
+    const url = urls[index];
+    index = (index + 1) % urls.length;
+    return url;
+  };
+};
+var identityV2ABI = parseAbi([
+  // Whitelist management (IdentityV2)
+  "function addWhitelisted(address account)",
+  "function removeWhitelisted(address account)",
+  "function getWhitelistedRoot(address account) view returns (address)",
+  "function lastAuthenticated(address account) view returns (uint256)",
+  "function authenticationPeriod() view returns (uint256)",
+  // Wallet-link methods (IdentityV4)
+  "function connectAccount(address account) external",
+  "function disconnectAccount(address account) external",
+  "function connectedAccounts(address account) view returns (address)"
+]);
+var ubiSchemeV2ABI = parseAbi([
+  "function claim() returns (bool)",
+  "function checkEntitlement() view returns (uint256)",
+  "function checkEntitlement(address _member) view returns (uint256)",
+  "function getDailyStats() view returns (uint256 claimers, uint256 amount)",
+  "function periodStart() view returns (uint256)",
+  "function currentDay() view returns (uint256)",
+  "event UBIClaimed(address indexed account, uint256 amount)"
+]);
+var faucetABI = parseAbi([
+  "function minTopping() view returns (uint8)",
+  "function getToppingAmount() view returns (uint256)",
+  "function canTop(address _user) view returns (bool)",
+  "function topWallet(address _user) payable"
+]);
+var g$ABI = parseAbi([
+  "function balanceOf(address account) view returns (uint256)"
+]);
+var WALLET_LINK_SECURITY_MESSAGES = {
+  connect: [
+    "SECURITY NOTICE \u2014 Connect Wallet",
+    "You are about to link a secondary wallet to your GoodDollar identity.",
+    "\u2022 Only connect wallets you own and control.",
+    "\u2022 All connected wallets share a single daily UBI claim.",
+    "\u2022 The whitelisted root identity is the only account that can connect a wallet.",
+    "Do not proceed if you did not initiate this action."
+  ].join("\n"),
+  disconnect: [
+    "SECURITY NOTICE \u2014 Disconnect Wallet",
+    "You are about to remove a wallet from your GoodDollar identity.",
+    "\u2022 Once disconnected the wallet no longer shares your UBI claim.",
+    "\u2022 Either the root identity or the connected account itself can disconnect.",
+    "Do not proceed if you did not initiate this action."
+  ].join("\n")
+};
+var resolveChainAndContract = (walletClient, env) => {
+  const chainId = walletClient.chain?.id;
+  if (!isSupportedChain(chainId)) {
+    throw new Error(`Unsupported chain ID.`);
+  }
+  const contractEnvAddresses = chainConfigs[chainId]?.contracts[env] ?? null;
+  if (!contractEnvAddresses) {
+    throw new Error(
+      `Contract address for environment "${env}" on chain "${chainConfigs[chainId].label}" not found. Try a different environment or chain.`
+    );
+  }
+  return { chainId, contractEnvAddresses };
+};
+var createRpcIteratorRegistry = () => /* @__PURE__ */ new Map();
+var getIterator = (chainId, registry) => {
+  if (!registry.has(chainId)) {
+    registry.set(chainId, createRpcUrlIterator(chainId));
+  }
+  const iterator = registry.get(chainId);
+  if (!iterator) {
+    throw new Error(`RPC iterator not available for chain ${chainId}`);
+  }
+  return iterator;
+};
+var getRpcFallbackClient = (chainId, registry) => {
+  const iterator = getIterator(chainId, registry);
+  const rpcUrl = iterator();
+  return createPublicClient({
+    transport: http(rpcUrl)
+  });
+};
+var initializeIdentityContract = (publicClient, contractAddress) => ({
+  publicClient,
+  contractAddress
+});
+var IdentitySDK = class _IdentitySDK {
+  account;
+  publicClient;
+  walletClient;
+  contract;
+  env = "production";
+  chainId;
+  fvDefaultChain;
+  rpcIterators = createRpcIteratorRegistry();
+  /**
+   * Initializes the IdentitySDK.
+   * @param publicClient - The PublicClient instance.
+   * @param walletClient - The WalletClient with WalletActions.
+   * @param env - The environment to use ("production" | "staging" | "development").
+   */
+  constructor({
+    account,
+    publicClient,
+    walletClient,
+    env
+  }) {
+    if (!walletClient.account) {
+      throw new Error(
+        "IdentitySDK: WalletClient must have an account attached."
+      );
+    }
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.env = env;
+    this.account = account ?? walletClient.account.address;
+    const { chainId, contractEnvAddresses } = resolveChainAndContract(
+      walletClient,
+      env
+    );
+    this.chainId = chainId;
+    this.fvDefaultChain = chainConfigs[chainId]?.fvDefaultChain ?? chainId;
+    this.contract = initializeIdentityContract(
+      this.publicClient,
+      contractEnvAddresses.identityContract
+    );
+  }
+  static async init(props) {
+    const [account] = await props.walletClient.getAddresses();
+    return new _IdentitySDK({ account, ...props });
+  }
+  /**
+   * Evaluates security constraints and prompts the user with security messages if required.
+   * Custodial/automated flows can bypass this entirely via `skipSecurityMessage: true`.
+   * For native wallet flows, `onSecurityMessage` receives the notice and must resolve
+   * to `true` for the transaction to proceed. Without either option the message is
+   * logged to `console.info` as a headless default.
+   * @param action - The wallet link action being performed ("connect" or "disconnect").
+   * @param options - Additional wallet link options including security prompt handlers.
+   */
+  async runSecurityCheck(action, options) {
+    if (options?.skipSecurityMessage) return;
+    const message = WALLET_LINK_SECURITY_MESSAGES[action];
+    if (options?.onSecurityMessage) {
+      const confirmed = await options.onSecurityMessage(message);
+      if (!confirmed) {
+        throw new Error(
+          `Wallet ${action} cancelled: user did not confirm security notice.`
+        );
+      }
+      return;
+    }
+    console.info(`[IdentitySDK] ${message}`);
+  }
+  /**
+   * Submits a transaction and waits for its receipt.
+   * @param params - Parameters for simulating the contract call.
+   * @param onHash - Optional callback to receive the transaction hash.
+   * @returns The transaction receipt.
+   * @throws If submission fails or no active wallet address is found.
+   */
+  async submitAndWait(params, onHash) {
+    try {
+      if (!this.account) throw new Error("No active wallet address found.");
+      const { request } = await this.publicClient.simulateContract({
+        account: this.account,
+        ...params
+      });
+      const hash = await this.walletClient.writeContract(request);
+      onHash?.(hash);
+      return waitForTransactionReceipt(this.publicClient, { hash });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("submitAndWait Error:", error);
+      throw new Error(`Failed to submit transaction: ${message}`);
+    }
+  }
+  /**
+   * Returns whitelist status of main account or any connected account.
+   * @param account - The account address to check.
+   * @returns An object containing whitelist status and root address.
+   * @reference: https://docs.gooddollar.org/user-guides/connect-another-wallet-address-to-identity
+   */
+  async getWhitelistedRoot(account) {
+    try {
+      const root = await this.publicClient.readContract({
+        address: this.contract.contractAddress,
+        abi: identityV2ABI,
+        functionName: "getWhitelistedRoot",
+        args: [account]
+      });
+      return {
+        isWhitelisted: root !== zeroAddress,
+        root
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("getWhitelistedRoot Error:", error);
+      throw new Error(`Failed to get whitelisted root: ${message}`);
+    }
+  }
+  /**
+   * Checks the wallet-link connection status of the given account.
+   *
+   * When `chainId` is provided the query is scoped to that single chain only.
+   * When omitted, all supported chains are queried in parallel via Promise.allSettled
+   * and one ChainConnectedStatus entry is returned per chain.
+   *
+   * App-provided public clients always take precedence. For the SDK's current
+   * chain `this.publicClient` is reused when no override is passed. For other
+   * chains the SDK falls back to local read-only RPC clients using the same
+   * fallback flow as other multi-chain reads.
+   *
+   * @param account - The account address to check.
+   * @param chainId - Optional. Restricts the query to this chain only.
+   * @param publicClients - Optional. App-level public clients keyed by SupportedChains ID.
+   * @returns An array of ChainConnectedStatus (one entry per queried chain).
+   */
+  async checkConnectedStatus(account, chainId, publicClients) {
+    const configs = chainId ? Object.values(chainConfigs).filter((config) => config.id === chainId) : Object.values(chainConfigs);
+    const settled = await Promise.allSettled(
+      configs.map(async (config) => {
+        const contracts = config.contracts[this.env];
+        if (!contracts) {
+          return {
+            chainId: config.id,
+            chainName: config.label,
+            isConnected: false,
+            root: zeroAddress,
+            error: `No contract configured for env "${this.env}" on ${config.label}`
+          };
+        }
+        const isPrimaryChain = this.chainId === config.id;
+        const client = publicClients?.[config.id] ?? (isPrimaryChain ? this.publicClient : getRpcFallbackClient(config.id, this.rpcIterators));
+        const root = await client.readContract({
+          address: contracts.identityContract,
+          abi: identityV2ABI,
+          functionName: "connectedAccounts",
+          args: [account]
+        });
+        return {
+          chainId: config.id,
+          chainName: config.label,
+          isConnected: root !== zeroAddress,
+          root
+        };
+      })
+    );
+    return settled.map((result, i) => {
+      const config = configs[i];
+      if (result.status === "fulfilled") return result.value;
+      return {
+        chainId: config.id,
+        chainName: config.label,
+        isConnected: false,
+        root: zeroAddress,
+        error: result.reason?.message ?? "Unknown RPC error"
+      };
+    });
+  }
+  /**
+   * Retrieves identity expiry data for a given account.
+   * @param account - The account address.
+   * @returns The identity expiry data.
+   */
+  async getIdentityExpiryData(account) {
+    try {
+      const [lastAuthenticated, authPeriod] = await Promise.all([
+        this.publicClient.readContract({
+          address: this.contract.contractAddress,
+          abi: identityV2ABI,
+          functionName: "lastAuthenticated",
+          args: [account]
+        }),
+        this.publicClient.readContract({
+          address: this.contract.contractAddress,
+          abi: identityV2ABI,
+          functionName: "authenticationPeriod",
+          args: []
+        })
+      ]);
+      return { lastAuthenticated, authPeriod };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("getIdentityExpiryData Error:", error);
+      throw new Error(
+        `Failed to retrieve identity expiry data: ${message}`
+      );
+    }
+  }
+  /**
+   * Updates the wallet-link status of an account.
+   * The whitelisted root identity must be the signer for `connectAccount`,
+   * while `disconnectAccount` can be called by either the root identity or
+   * the connected account itself.
+   * Custodial flows can pass `skipSecurityMessage: true` to bypass the notice;
+   * the underlying transaction signing is handled by the app-provided walletClient
+   * (or IdentityCustodialSDK for LocalAccount signers).
+   * @param action - The wallet-link action to submit.
+   * @param account - The account address to update.
+   * @param options - Additional options, such as security prompts.
+   * @returns The transaction receipt.
+   */
+  async updateConnectionStatus(action, account, options) {
+    const securityAction = action === "connectAccount" ? "connect" : "disconnect";
+    const actionLabel = action === "connectAccount" ? "connect" : "disconnect";
+    try {
+      await this.runSecurityCheck(securityAction, options);
+      return this.submitAndWait(
+        {
+          address: this.contract.contractAddress,
+          abi: identityV2ABI,
+          functionName: action,
+          args: [account]
+        },
+        options?.onHash
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("updateConnectionStatus Error:", error);
+      throw new Error(`Failed to ${actionLabel} account: ${message}`);
+    }
+  }
+  /**
+   * Connects a new account to the identity.
+   * The whitelisted root identity must be the signer. No additional message
+   * signature is required beyond the transaction itself.
+   * @param account - The account address to connect.
+   * @param options - Additional options, such as security prompts.
+   * @returns The transaction receipt.
+   */
+  async connectAccount(account, options) {
+    return this.updateConnectionStatus("connectAccount", account, options);
+  }
+  /**
+   * Disconnects an account from the identity.
+   * Either the root identity or the connected account itself can call this.
+   * @param account - The account address to disconnect.
+   * @param options - Additional options, such as security prompts.
+   * @returns The transaction receipt.
+   */
+  async disconnectAccount(account, options) {
+    return this.updateConnectionStatus("disconnectAccount", account, options);
+  }
+  /**
+   * Generates a Face Verification Link.
+   * @param popupMode - Whether to generate a popup link.
+   * @param callbackUrl - The URL to callback after verification.
+   * @param chainId - The blockchain network ID.
+   * @returns The generated Face Verification link.
+   */
+  async generateFVLink(popupMode = false, callbackUrl, chainId) {
+    try {
+      const address = getAddress(this.account);
+      if (!address) throw new Error("No wallet address found.");
+      const nonce = Math.floor(Date.now() / 1e3).toString();
+      const fvSigMessage = FV_IDENTIFIER_MSG2.replace("<account>", address);
+      const fvSig = await this.walletClient.signMessage({
+        account: address,
+        message: fvSigMessage
+      });
+      const { identityUrl } = Envs[this.env];
+      if (!identityUrl) {
+        throw new Error("identityUrl is not defined in environment settings.");
+      }
+      if (!fvSig) {
+        throw new Error("Missing signature for Face Verification.");
+      }
+      if (!popupMode && !callbackUrl) {
+        throw new Error("Callback URL is required for redirect mode.");
+      }
+      const url = new URL(identityUrl);
+      const fallbackChain = this.fvDefaultChain ?? this.chainId;
+      const resolvedChain = typeof chainId === "number" ? chainId : fallbackChain;
+      const fvChain = isSupportedChain(resolvedChain) ? resolvedChain : fallbackChain;
+      const params = {
+        account: address,
+        nonce,
+        fvsig: fvSig,
+        chain: fvChain
+      };
+      if (callbackUrl) {
+        params[popupMode ? "cbu" : "rdu"] = callbackUrl;
+      }
+      url.searchParams.append(
+        "lz",
+        (0, import_lz_string.compressToEncodedURIComponent)(JSON.stringify(params))
+      );
+      return url.toString();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("generateFVLink Error:", error);
+      throw new Error(
+        `Failed to generate Face Verification link: ${message}`
+      );
+    }
+  }
+  /**
+   * Calculates the identity expiry timestamp.
+   * @param lastAuthenticated - The timestamp of last authentication.
+   * @param authPeriod - The authentication period.
+   * @returns The identity expiry data.
+   */
+  calculateIdentityExpiry(lastAuthenticated, authPeriod) {
+    const MS_IN_A_SECOND = 1e3;
+    const MS_IN_A_DAY = 24 * 60 * 60 * MS_IN_A_SECOND;
+    const periodInMs = authPeriod * BigInt(MS_IN_A_DAY);
+    const expiryTimestamp = lastAuthenticated * BigInt(MS_IN_A_SECOND) + periodInMs;
+    return { expiryTimestamp };
+  }
+};
+var DAY = 1e3 * 60 * 60 * 24;
+var IdentityCustodialSDK = class extends IdentitySDK {
+  /**
+   * Override submitAndWait to handle account retrieval differently for custodial wallets
+   * @param params - Parameters for simulating the contract call.
+   * @param onHash - Optional callback to receive the transaction hash.
+   * @returns The transaction receipt.
+   * @throws If submission fails or no active wallet address is found.
+   */
+  async submitAndWait(params, onHash) {
+    try {
+      const account = this.walletClient.account?.address;
+      if (!account) throw new Error("No active wallet address found.");
+      const { request } = await this.publicClient.simulateContract({
+        account,
+        ...params
+      });
+      const hash = await this.walletClient.writeContract(request);
+      onHash?.(hash);
+      return waitForTransactionReceipt(this.publicClient, { hash });
+    } catch (error) {
+      console.error("submitAndWait Error:", error);
+      throw new Error(`Failed to submit transaction: ${error.message}`);
+    }
+  }
+  /**
+   * Override generateFVLink to handle LocalAccount message signing for Celo RPC compatibility
+   * @param popupMode - Whether to generate a popup link.
+   * @param callbackUrl - The URL to callback after verification.
+   * @param chainId - The blockchain network ID.
+   * @returns The generated Face Verification link.
+   */
+  async generateFVLink(popupMode = false, callbackUrl, chainId) {
+    try {
+      const account = this.walletClient.account;
+      if (!account?.address) throw new Error("No wallet address found.");
+      const nonce = Math.floor(Date.now() / 1e3).toString();
+      const fvSigMessage = FV_IDENTIFIER_MSG2.replace("<account>", account.address);
+      let fvSig;
+      if ("signMessage" in account) {
+        fvSig = await account.signMessage({
+          message: fvSigMessage
+        });
+      } else {
+        try {
+          fvSig = await this.walletClient.signMessage({
+            account: account.address,
+            message: fvSigMessage
+          });
+        } catch (rpcError) {
+          throw new Error(`Message signing failed: Celo RPC doesn't support personal_sign. Use a local account instead. ${rpcError.message}`);
+        }
+      }
+      const { identityUrl } = Envs[this.env];
+      if (!identityUrl) {
+        throw new Error("identityUrl is not defined in environment settings.");
+      }
+      if (!fvSig) {
+        throw new Error("Missing signature for Face Verification.");
+      }
+      if (!popupMode && !callbackUrl) {
+        throw new Error("Callback URL is required for redirect mode.");
+      }
+      const url = new URL(identityUrl);
+      const params = {
+        account: account.address,
+        nonce,
+        fvsig: fvSig,
+        chain: chainId || await this.publicClient.getChainId()
+      };
+      if (callbackUrl) {
+        params[popupMode ? "cbu" : "rdu"] = callbackUrl;
+      }
+      url.searchParams.append(
+        "lz",
+        (0, import_lz_string.compressToEncodedURIComponent)(JSON.stringify(params))
+      );
+      return url.toString();
+    } catch (error) {
+      console.error("generateFVLink Error:", error);
+      throw new Error(
+        `Failed to generate Face Verification link: ${error.message}`
+      );
+    }
+  }
+};
+
+// citizen-sdk.entry.ts
+var IdentitySDK2 = IdentityCustodialSDK ?? IdentitySDK;
+export {
+  IdentitySDK2 as IdentitySDK
+};