Skip to content

Instantly share code, notes, and snippets.

@kriskowal

kriskowal/beta2.js

Last active June 27, 2026 15:59
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save kriskowal/dac81e95eeecb4ad024e6278f8bed212 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save kriskowal/dac81e95eeecb4ad024e6278f8bed212 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
beta2.js
This file has been truncated, but you can view the full file.
({
imports: $h͏_imports,
liveVar: $h͏_live,
onceVar: $h͏_once,
import: $h͏_import,
importMeta: $h͏____meta,
}) =>
(function () {
"use strict";
$h͏_imports([]);
$h͏_live.q5();
$h͏_live.j5();
$h͏_live.Zye();
$h͏_live.e_();
$h͏_live.t_();
$h͏_live.JI();
$h͏_live.o_();
var LI = Object.create;
var jp = Object.defineProperty;
var qI = Object.getOwnPropertyDescriptor;
var jI = Object.getOwnPropertyNames;
var GI = Object.getPrototypeOf,
QI = Object.prototype.hasOwnProperty;
var St = (e, t) => () => (e && (t = e((e = 0))), t);
var lo = (e, t) => () => (
t || e((t = { exports: {} }).exports, t),
t.exports
),
T0 = (e, t) => {
for (var r in t) jp(e, r, { get: t[r], enumerable: !0 });
},
zI = (e, t, r, o) => {
if ((t && typeof t == "object") || typeof t == "function")
for (let n of jI(t))
!QI.call(e, n) &&
n !== r &&
jp(e, n, {
get: () => t[n],
enumerable: !(o = qI(t, n)) || o.enumerable,
});
return e;
};
var Pd = (e, t, r) => (
(r = e != null ? LI(GI(e)) : {}),
zI(
t || !e || !e.__esModule
? jp(r, "default", { value: e, enumerable: !0 })
: r,
e,
)
);
var GS = lo((Nl) => {
"use strict";
Object.defineProperty(Nl, "__esModule", { value: !0 });
Nl.toAscii = mE;
Nl.fromAscii = fE;
function mE(e) {
let t = (r) =>
r.split("").map((o) => {
let n = o.charCodeAt(0);
if (n < 32 || n > 126)
throw new Error(
`Cannot encode character that is out of printable ASCII range: ${n}`,
);
return n;
});
return Uint8Array.from(t(e));
}
function fE(e) {
return ((r) =>
r.map((o) => {
if (o < 32 || o > 126)
throw new Error(
`Cannot decode character that is out of printable ASCII range: ${o}`,
);
return String.fromCharCode(o);
}))(Array.from(e)).join("");
}
});
var YS = lo((Bl) => {
"use strict";
Bl.byteLength = gE;
Bl.toByteArray = bE;
Bl.fromByteArray = xE;
var Co = [],
Ir = [],
yE = typeof Uint8Array < "u" ? Uint8Array : Array,
Mf = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
for (Ps = 0, QS = Mf.length; Ps < QS; ++Ps)
((Co[Ps] = Mf[Ps]), (Ir[Mf.charCodeAt(Ps)] = Ps));
var Ps, QS;
Ir[45] = 62;
Ir[95] = 63;
function zS(e) {
var t = e.length;
if (t % 4 > 0)
throw new Error("Invalid string. Length must be a multiple of 4");
var r = e.indexOf("=");
r === -1 && (r = t);
var o = r === t ? 0 : 4 - (r % 4);
return [r, o];
}
function gE(e) {
var t = zS(e),
r = t[0],
o = t[1];
return ((r + o) * 3) / 4 - o;
}
function hE(e, t, r) {
return ((t + r) * 3) / 4 - r;
}
function bE(e) {
var t,
r = zS(e),
o = r[0],
n = r[1],
a = new yE(hE(e, o, n)),
i = 0,
c = n > 0 ? o - 4 : o,
d;
for (d = 0; d < c; d += 4)
((t =
(Ir[e.charCodeAt(d)] << 18) |
(Ir[e.charCodeAt(d + 1)] << 12) |
(Ir[e.charCodeAt(d + 2)] << 6) |
Ir[e.charCodeAt(d + 3)]),
(a[i++] = (t >> 16) & 255),
(a[i++] = (t >> 8) & 255),
(a[i++] = t & 255));
return (
n === 2 &&
((t = (Ir[e.charCodeAt(d)] << 2) | (Ir[e.charCodeAt(d + 1)] >> 4)),
(a[i++] = t & 255)),
n === 1 &&
((t =
(Ir[e.charCodeAt(d)] << 10) |
(Ir[e.charCodeAt(d + 1)] << 4) |
(Ir[e.charCodeAt(d + 2)] >> 2)),
(a[i++] = (t >> 8) & 255),
(a[i++] = t & 255)),
a
);
}
function vE(e) {
return (
Co[(e >> 18) & 63] +
Co[(e >> 12) & 63] +
Co[(e >> 6) & 63] +
Co[e & 63]
);
}
function SE(e, t, r) {
for (var o, n = [], a = t; a < r; a += 3)
((o =
((e[a] << 16) & 16711680) +
((e[a + 1] << 8) & 65280) +
(e[a + 2] & 255)),
n.push(vE(o)));
return n.join("");
}
function xE(e) {
for (
var t, r = e.length, o = r % 3, n = [], a = 16383, i = 0, c = r - o;
i < c;
i += a
)
n.push(SE(e, i, i + a > c ? c : i + a));
return (
o === 1
? ((t = e[r - 1]), n.push(Co[t >> 2] + Co[(t << 4) & 63] + "=="))
: o === 2 &&
((t = (e[r - 2] << 8) + e[r - 1]),
n.push(
Co[t >> 10] + Co[(t >> 4) & 63] + Co[(t << 2) & 63] + "=",
)),
n.join("")
);
}
});
var XS = lo((Ro) => {
"use strict";
var AE =
(Ro && Ro.__createBinding) ||
(Object.create
? function (e, t, r, o) {
o === void 0 && (o = r);
var n = Object.getOwnPropertyDescriptor(t, r);
((!n ||
("get" in n
? !t.__esModule
: n.writable || n.configurable)) &&
(n = {
enumerable: !0,
get: function () {
return t[r];
},
}),
Object.defineProperty(e, o, n));
}
: function (e, t, r, o) {
(o === void 0 && (o = r), (e[o] = t[r]));
}),
wE =
(Ro && Ro.__setModuleDefault) ||
(Object.create
? function (e, t) {
Object.defineProperty(e, "default", {
enumerable: !0,
value: t,
});
}
: function (e, t) {
e.default = t;
}),
PE =
(Ro && Ro.__importStar) ||
(function () {
var e = function (t) {
return (
(e =
Object.getOwnPropertyNames ||
function (r) {
var o = [];
for (var n in r)
Object.prototype.hasOwnProperty.call(r, n) &&
(o[o.length] = n);
return o;
}),
e(t)
);
};
return function (t) {
if (t && t.__esModule) return t;
var r = {};
if (t != null)
for (var o = e(t), n = 0; n < o.length; n++)
o[n] !== "default" && AE(r, t, o[n]);
return (wE(r, t), r);
};
})();
Object.defineProperty(Ro, "__esModule", { value: !0 });
Ro.toBase64 = kE;
Ro.fromBase64 = IE;
var ZS = PE(YS());
function kE(e) {
return ZS.fromByteArray(e);
}
function IE(e) {
if (!e.match(/^[a-zA-Z0-9+/]*={0,2}$/))
throw new Error("Invalid base64 string format");
return ZS.toByteArray(e);
}
});
var ox = lo((tq, rx) => {
"use strict";
var $l = "qpzry9x8gf2tvdw0s3jn54khce6mua7l",
$f = {};
for (Rc = 0; Rc < $l.length; Rc++) {
if (((Ml = $l.charAt(Rc)), $f[Ml] !== void 0))
throw new TypeError(Ml + " is ambiguous");
$f[Ml] = Rc;
}
var Ml, Rc;
function Ga(e) {
var t = e >> 25;
return (
((e & 33554431) << 5) ^
(-((t >> 0) & 1) & 996825010) ^
(-((t >> 1) & 1) & 642813549) ^
(-((t >> 2) & 1) & 513874426) ^
(-((t >> 3) & 1) & 1027748829) ^
(-((t >> 4) & 1) & 705979059)
);
}
function ex(e) {
for (var t = 1, r = 0; r < e.length; ++r) {
var o = e.charCodeAt(r);
if (o < 33 || o > 126) return "Invalid prefix (" + e + ")";
t = Ga(t) ^ (o >> 5);
}
for (t = Ga(t), r = 0; r < e.length; ++r) {
var n = e.charCodeAt(r);
t = Ga(t) ^ (n & 31);
}
return t;
}
function TE(e, t, r) {
if (((r = r || 90), e.length + 7 + t.length > r))
throw new TypeError("Exceeds length limit");
e = e.toLowerCase();
var o = ex(e);
if (typeof o == "string") throw new Error(o);
for (var n = e + "1", a = 0; a < t.length; ++a) {
var i = t[a];
if (i >> 5 !== 0) throw new Error("Non 5-bit word");
((o = Ga(o) ^ i), (n += $l.charAt(i)));
}
for (a = 0; a < 6; ++a) o = Ga(o);
for (o ^= 1, a = 0; a < 6; ++a) {
var c = (o >> ((5 - a) * 5)) & 31;
n += $l.charAt(c);
}
return n;
}
function tx(e, t) {
if (((t = t || 90), e.length < 8)) return e + " too short";
if (e.length > t) return "Exceeds length limit";
var r = e.toLowerCase(),
o = e.toUpperCase();
if (e !== r && e !== o) return "Mixed-case string " + e;
e = r;
var n = e.lastIndexOf("1");
if (n === -1) return "No separator character for " + e;
if (n === 0) return "Missing prefix for " + e;
var a = e.slice(0, n),
i = e.slice(n + 1);
if (i.length < 6) return "Data too short";
var c = ex(a);
if (typeof c == "string") return c;
for (var d = [], l = 0; l < i.length; ++l) {
var u = i.charAt(l),
p = $f[u];
if (p === void 0) return "Unknown character " + u;
((c = Ga(c) ^ p), !(l + 6 >= i.length) && d.push(p));
}
return c !== 1 ? "Invalid checksum for " + e : { prefix: a, words: d };
}
function UE() {
var e = tx.apply(null, arguments);
if (typeof e == "object") return e;
}
function CE(e) {
var t = tx.apply(null, arguments);
if (typeof t == "object") return t;
throw new Error(t);
}
function _l(e, t, r, o) {
for (
var n = 0, a = 0, i = (1 << r) - 1, c = [], d = 0;
d < e.length;
++d
)
for (n = (n << t) | e[d], a += t; a >= r; )
((a -= r), c.push((n >> a) & i));
if (o) a > 0 && c.push((n << (r - a)) & i);
else {
if (a >= t) return "Excess padding";
if ((n << (r - a)) & i) return "Non-zero padding";
}
return c;
}
function RE(e) {
var t = _l(e, 8, 5, !0);
if (Array.isArray(t)) return t;
}
function OE(e) {
var t = _l(e, 8, 5, !0);
if (Array.isArray(t)) return t;
throw new Error(t);
}
function EE(e) {
var t = _l(e, 5, 8, !1);
if (Array.isArray(t)) return t;
}
function DE(e) {
var t = _l(e, 5, 8, !1);
if (Array.isArray(t)) return t;
throw new Error(t);
}
rx.exports = {
decodeUnsafe: UE,
decode: CE,
encode: TE,
toWordsUnsafe: RE,
toWords: OE,
fromWordsUnsafe: EE,
fromWords: DE,
};
});
var ax = lo((qr) => {
"use strict";
var NE =
(qr && qr.__createBinding) ||
(Object.create
? function (e, t, r, o) {
o === void 0 && (o = r);
var n = Object.getOwnPropertyDescriptor(t, r);
((!n ||
("get" in n
? !t.__esModule
: n.writable || n.configurable)) &&
(n = {
enumerable: !0,
get: function () {
return t[r];
},
}),
Object.defineProperty(e, o, n));
}
: function (e, t, r, o) {
(o === void 0 && (o = r), (e[o] = t[r]));
}),
BE =
(qr && qr.__setModuleDefault) ||
(Object.create
? function (e, t) {
Object.defineProperty(e, "default", {
enumerable: !0,
value: t,
});
}
: function (e, t) {
e.default = t;
}),
ME =
(qr && qr.__importStar) ||
(function () {
var e = function (t) {
return (
(e =
Object.getOwnPropertyNames ||
function (r) {
var o = [];
for (var n in r)
Object.prototype.hasOwnProperty.call(r, n) &&
(o[o.length] = n);
return o;
}),
e(t)
);
};
return function (t) {
if (t && t.__esModule) return t;
var r = {};
if (t != null)
for (var o = e(t), n = 0; n < o.length; n++)
o[n] !== "default" && NE(r, t, o[n]);
return (BE(r, t), r);
};
})();
Object.defineProperty(qr, "__esModule", { value: !0 });
qr.toBech32 = nx;
qr.fromBech32 = sx;
qr.normalizeBech32 = $E;
var Fl = ME(ox());
function nx(e, t, r) {
return Fl.encode(e, Fl.toWords(t), r);
}
function sx(e, t = 1 / 0) {
let r = Fl.decode(e, t);
return {
prefix: r.prefix,
data: new Uint8Array(Fl.fromWords(r.words)),
};
}
function $E(e) {
let { prefix: t, data: r } = sx(e);
return nx(t, r);
}
});
var ix = lo((Kl) => {
"use strict";
Object.defineProperty(Kl, "__esModule", { value: !0 });
Kl.toHex = _E;
Kl.fromHex = FE;
function _E(e) {
let t = "";
for (let r of e) t += ("0" + r.toString(16)).slice(-2);
return t;
}
function FE(e) {
if (e.length % 2 !== 0)
throw new Error("hex string length must be a multiple of 2");
let t = new Uint8Array(e.length / 2);
for (let r = 0; r < t.length; r++) {
let o = 2 * r,
n = e.slice(o, o + 2);
if (!n.match(/[0-9a-f]{2}/i))
throw new Error("hex string contains invalid characters");
t[r] = parseInt(n, 16);
}
return t;
}
});
var cx = lo((Jl) => {
"use strict";
Object.defineProperty(Jl, "__esModule", { value: !0 });
Jl.fromRfc3339 = JE;
Jl.toRfc3339 = VE;
var KE =
/^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(\.\d{1,9})?((?:[+-]\d{2}:\d{2})|Z)$/;
function Qa(e, t = 2) {
return e.toString().padStart(t, "0");
}
function JE(e) {
let t = KE.exec(e);
if (!t) throw new Error("Date string is not in RFC3339 format");
let r = +t[1],
o = +t[2],
n = +t[3],
a = +t[4],
i = +t[5],
c = +t[6],
d = t[7] ? Math.floor(+t[7] * 1e3) : 0,
l,
u,
p;
t[8] === "Z"
? ((l = 1), (u = 0), (p = 0))
: ((l = t[8].substring(0, 1) === "-" ? -1 : 1),
(u = +t[8].substring(1, 3)),
(p = +t[8].substring(4, 6)));
let y = l * (u * 60 + p) * 60,
b = new Date();
return (
b.setUTCFullYear(r, o - 1, n),
b.setUTCHours(a, i, c, d),
new Date(b.getTime() - y * 1e3)
);
}
function VE(e) {
let t = e.getUTCFullYear(),
r = Qa(e.getUTCMonth() + 1),
o = Qa(e.getUTCDate()),
n = Qa(e.getUTCHours()),
a = Qa(e.getUTCMinutes()),
i = Qa(e.getUTCSeconds()),
c = Qa(e.getUTCMilliseconds(), 3);
return `${t}-${r}-${o}T${n}:${a}:${i}.${c}Z`;
}
});
var dx = lo((Vl) => {
"use strict";
Object.defineProperty(Vl, "__esModule", { value: !0 });
Vl.toUtf8 = HE;
Vl.fromUtf8 = WE;
function HE(e) {
return new TextEncoder().encode(e);
}
function WE(e, t = !1) {
let r = !t;
return new TextDecoder("utf-8", { fatal: r }).decode(e);
}
});
var Hl = lo((ze) => {
"use strict";
Object.defineProperty(ze, "__esModule", { value: !0 });
ze.toUtf8 =
ze.fromUtf8 =
ze.toRfc3339 =
ze.fromRfc3339 =
ze.toHex =
ze.fromHex =
ze.toBech32 =
ze.normalizeBech32 =
ze.fromBech32 =
ze.toBase64 =
ze.fromBase64 =
ze.toAscii =
ze.fromAscii =
void 0;
var lx = GS();
Object.defineProperty(ze, "fromAscii", {
enumerable: !0,
get: function () {
return lx.fromAscii;
},
});
Object.defineProperty(ze, "toAscii", {
enumerable: !0,
get: function () {
return lx.toAscii;
},
});
var ux = XS();
Object.defineProperty(ze, "fromBase64", {
enumerable: !0,
get: function () {
return ux.fromBase64;
},
});
Object.defineProperty(ze, "toBase64", {
enumerable: !0,
get: function () {
return ux.toBase64;
},
});
var _f = ax();
Object.defineProperty(ze, "fromBech32", {
enumerable: !0,
get: function () {
return _f.fromBech32;
},
});
Object.defineProperty(ze, "normalizeBech32", {
enumerable: !0,
get: function () {
return _f.normalizeBech32;
},
});
Object.defineProperty(ze, "toBech32", {
enumerable: !0,
get: function () {
return _f.toBech32;
},
});
var px = ix();
Object.defineProperty(ze, "fromHex", {
enumerable: !0,
get: function () {
return px.fromHex;
},
});
Object.defineProperty(ze, "toHex", {
enumerable: !0,
get: function () {
return px.toHex;
},
});
var mx = cx();
Object.defineProperty(ze, "fromRfc3339", {
enumerable: !0,
get: function () {
return mx.fromRfc3339;
},
});
Object.defineProperty(ze, "toRfc3339", {
enumerable: !0,
get: function () {
return mx.toRfc3339;
},
});
var fx = dx();
Object.defineProperty(ze, "fromUtf8", {
enumerable: !0,
get: function () {
return fx.fromUtf8;
},
});
Object.defineProperty(ze, "toUtf8", {
enumerable: !0,
get: function () {
return fx.toUtf8;
},
});
});
function Sy(e) {
if (!Number.isSafeInteger(e) || e < 0)
throw new Error(`positive integer expected, not ${e}`);
}
function nD(e) {
return (
e instanceof Uint8Array ||
(e != null &&
typeof e == "object" &&
e.constructor.name === "Uint8Array")
);
}
function Xa(e, ...t) {
if (!nD(e)) throw new Error("Uint8Array expected");
if (t.length > 0 && !t.includes(e.length))
throw new Error(
`Uint8Array expected of length ${t}, not of length=${e.length}`,
);
}
function ei(e, t = !0) {
if (e.destroyed) throw new Error("Hash instance has been destroyed");
if (t && e.finished)
throw new Error("Hash#digest() has already been called");
}
function cu(e, t) {
Xa(e);
let r = t.outputLen;
if (e.length < r)
throw new Error(
`digestInto() expects output buffer of length at least ${r}`,
);
}
var du = St(() => {});
function Ay(e) {
for (let t = 0; t < e.length; t++) e[t] = sD(e[t]);
}
function uu(e) {
Xa(e);
let t = "";
for (let r = 0; r < e.length; r++) t += aD[e[r]];
return t;
}
function fA(e) {
if (e >= en._0 && e <= en._9) return e - en._0;
if (e >= en._A && e <= en._F) return e - (en._A - 10);
if (e >= en._a && e <= en._f) return e - (en._a - 10);
}
function Or(e) {
if (typeof e != "string")
throw new Error("hex string expected, got " + typeof e);
let t = e.length,
r = t / 2;
if (t % 2)
throw new Error(
"padded hex string expected, got unpadded hex of length " + t,
);
let o = new Uint8Array(r);
for (let n = 0, a = 0; n < r; n++, a += 2) {
let i = fA(e.charCodeAt(a)),
c = fA(e.charCodeAt(a + 1));
if (i === void 0 || c === void 0) {
let d = e[a] + e[a + 1];
throw new Error(
'hex string expected, got non-hex character "' +
d +
'" at index ' +
a,
);
}
o[n] = i * 16 + c;
}
return o;
}
function iD(e) {
if (typeof e != "string")
throw new Error(`utf8ToBytes expected string, got ${typeof e}`);
return new Uint8Array(new TextEncoder().encode(e));
}
function ri(e) {
return (typeof e == "string" && (e = iD(e)), Xa(e), e);
}
function pu(e) {
let t = (o) => e().update(ri(o)).digest(),
r = e();
return (
(t.outputLen = r.outputLen),
(t.blockLen = r.blockLen),
(t.create = () => e()),
t
);
}
function gA(e) {
let t = (o, n) => e(n).update(ri(o)).digest(),
r = e({});
return (
(t.outputLen = r.outputLen),
(t.blockLen = r.blockLen),
(t.create = (o) => e(o)),
t
);
}
var yA,
lu,
zr,
xy,
sD,
aD,
en,
ti,
XQ,
No = St(() => {
du();
((yA = (e) =>
new Uint32Array(
e.buffer,
e.byteOffset,
Math.floor(e.byteLength / 4),
)),
(lu = (e) => new DataView(e.buffer, e.byteOffset, e.byteLength)),
(zr = (e, t) => (e << (32 - t)) | (e >>> t)),
(xy = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68),
(sD = (e) =>
((e << 24) & 4278190080) |
((e << 8) & 16711680) |
((e >>> 8) & 65280) |
((e >>> 24) & 255)));
aD = Array.from({ length: 256 }, (e, t) =>
t.toString(16).padStart(2, "0"),
);
en = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
((ti = class {
clone() {
return this._cloneInto();
}
}),
(XQ = {}.toString));
});
var pa,
D1 = St(() => {
pa =
typeof globalThis == "object" && "crypto" in globalThis
? globalThis.crypto
: void 0;
});
function yn(e) {
return (
e instanceof Uint8Array ||
(ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array")
);
}
function qc(e) {
if (!Number.isSafeInteger(e) || e < 0)
throw new Error("positive integer expected, got " + e);
}
function Wt(e, ...t) {
if (!yn(e)) throw new Error("Uint8Array expected");
if (t.length > 0 && !t.includes(e.length))
throw new Error(
"Uint8Array expected of length " + t + ", got length=" + e.length,
);
}
function Ku(e) {
if (typeof e != "function" || typeof e.create != "function")
throw new Error("Hash should be wrapped by utils.createHasher");
(qc(e.outputLen), qc(e.blockLen));
}
function yi(e, t = !0) {
if (e.destroyed) throw new Error("Hash instance has been destroyed");
if (t && e.finished)
throw new Error("Hash#digest() has already been called");
}
function B1(e, t) {
Wt(e);
let r = t.outputLen;
if (e.length < r)
throw new Error(
"digestInto() expects output buffer of length at least " + r,
);
}
function ma(...e) {
for (let t = 0; t < e.length; t++) e[t].fill(0);
}
function Ju(e) {
return new DataView(e.buffer, e.byteOffset, e.byteLength);
}
function Xr(e, t) {
return (e << (32 - t)) | (e >>> t);
}
function gn(e) {
if ((Wt(e), M1)) return e.toHex();
let t = "";
for (let r = 0; r < e.length; r++) t += _B[e[r]];
return t;
}
function N1(e) {
if (e >= fn._0 && e <= fn._9) return e - fn._0;
if (e >= fn.A && e <= fn.F) return e - (fn.A - 10);
if (e >= fn.a && e <= fn.f) return e - (fn.a - 10);
}
function fa(e) {
if (typeof e != "string")
throw new Error("hex string expected, got " + typeof e);
if (M1) return Uint8Array.fromHex(e);
let t = e.length,
r = t / 2;
if (t % 2)
throw new Error("hex string expected, got unpadded hex of length " + t);
let o = new Uint8Array(r);
for (let n = 0, a = 0; n < r; n++, a += 2) {
let i = N1(e.charCodeAt(a)),
c = N1(e.charCodeAt(a + 1));
if (i === void 0 || c === void 0) {
let d = e[a] + e[a + 1];
throw new Error(
'hex string expected, got non-hex character "' +
d +
'" at index ' +
a,
);
}
o[n] = i * 16 + c;
}
return o;
}
function hn(e) {
if (typeof e != "string") throw new Error("string expected");
return new Uint8Array(new TextEncoder().encode(e));
}
function jc(e) {
return (typeof e == "string" && (e = hn(e)), Wt(e), e);
}
function ut(...e) {
let t = 0;
for (let o = 0; o < e.length; o++) {
let n = e[o];
(Wt(n), (t += n.length));
}
let r = new Uint8Array(t);
for (let o = 0, n = 0; o < e.length; o++) {
let a = e[o];
(r.set(a, n), (n += a.length));
}
return r;
}
function $1(e) {
let t = (o) => e().update(jc(o)).digest(),
r = e();
return (
(t.outputLen = r.outputLen),
(t.blockLen = r.blockLen),
(t.create = () => e()),
t
);
}
function ya(e = 32) {
if (pa && typeof pa.getRandomValues == "function")
return pa.getRandomValues(new Uint8Array(e));
if (pa && typeof pa.randomBytes == "function")
return Uint8Array.from(pa.randomBytes(e));
throw new Error("crypto.getRandomValues must be defined");
}
var M1,
_B,
fn,
fi,
Qn = St(() => {
D1();
((M1 =
typeof Uint8Array.from([]).toHex == "function" &&
typeof Uint8Array.fromHex == "function"),
(_B = Array.from({ length: 256 }, (e, t) =>
t.toString(16).padStart(2, "0"),
)));
fn = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
fi = class {};
});
function Gc(e, t = "") {
if (typeof e != "boolean") {
let r = t && `"${t}"`;
throw new Error(r + "expected boolean, got type=" + typeof e);
}
return e;
}
function zn(e, t, r = "") {
let o = yn(e),
n = e?.length,
a = t !== void 0;
if (!o || (a && n !== t)) {
let i = r && `"${r}" `,
c = a ? ` of length ${t}` : "",
d = o ? `length=${n}` : `type=${typeof e}`;
throw new Error(i + "expected Uint8Array" + c + ", got " + d);
}
return e;
}
function Qc(e) {
let t = e.toString(16);
return t.length & 1 ? "0" + t : t;
}
function _1(e) {
if (typeof e != "string")
throw new Error("hex string expected, got " + typeof e);
return e === "" ? Eg : BigInt("0x" + e);
}
function eo(e) {
return _1(gn(e));
}
function Dg(e) {
return (Wt(e), _1(gn(Uint8Array.from(e).reverse())));
}
function gi(e, t) {
return fa(e.toString(16).padStart(t * 2, "0"));
}
function Ng(e, t) {
return gi(e, t).reverse();
}
function it(e, t, r) {
let o;
if (typeof t == "string")
try {
o = fa(t);
} catch (a) {
throw new Error(e + " must be hex string or Uint8Array, cause: " + a);
}
else if (yn(t)) o = Uint8Array.from(t);
else throw new Error(e + " must be hex string or Uint8Array");
let n = o.length;
if (typeof r == "number" && n !== r)
throw new Error(e + " of length " + r + " expected, got " + n);
return o;
}
function zc(e, t, r) {
return Rg(e) && Rg(t) && Rg(r) && t <= e && e < r;
}
function F1(e, t, r, o) {
if (!zc(t, r, o))
throw new Error(
"expected valid " + e + ": " + r + " <= n < " + o + ", got " + t,
);
}
function Vu(e) {
let t;
for (t = 0; e > Eg; e >>= Og, t += 1);
return t;
}
function K1(e, t, r) {
if (typeof e != "number" || e < 2)
throw new Error("hashLen must be a number");
if (typeof t != "number" || t < 2)
throw new Error("qByteLen must be a number");
if (typeof r != "function") throw new Error("hmacFn must be a function");
let o = (b) => new Uint8Array(b),
n = (b) => Uint8Array.of(b),
a = o(e),
i = o(e),
c = 0,
d = () => {
(a.fill(1), i.fill(0), (c = 0));
},
l = (...b) => r(i, a, ...b),
u = (b = o(0)) => {
((i = l(n(0), b)),
(a = l()),
b.length !== 0 && ((i = l(n(1), b)), (a = l())));
},
p = () => {
if (c++ >= 1e3) throw new Error("drbg: tried 1000 values");
let b = 0,
m = [];
for (; b < t; ) {
a = l();
let v = a.slice();
(m.push(v), (b += a.length));
}
return ut(...m);
};
return (b, m) => {
(d(), u(b));
let v;
for (; !(v = m(p())); ) u();
return (d(), v);
};
}
function J1(e) {
return typeof e == "function" && Number.isSafeInteger(e.outputLen);
}
function ga(e, t, r = {}) {
if (!e || typeof e != "object")
throw new Error("expected valid options object");
function o(n, a, i) {
let c = e[n];
if (i && c === void 0) return;
let d = typeof c;
if (d !== a || c === null)
throw new Error(`param "${n}" is invalid: expected ${a}, got ${d}`);
}
(Object.entries(t).forEach(([n, a]) => o(n, a, !1)),
Object.entries(r).forEach(([n, a]) => o(n, a, !0)));
}
function Bg(e) {
let t = new WeakMap();
return (r, ...o) => {
let n = t.get(r);
if (n !== void 0) return n;
let a = e(r, ...o);
return (t.set(r, a), a);
};
}
var Eg,
Og,
Rg,
Yn,
hi = St(() => {
Qn();
Qn();
((Eg = BigInt(0)), (Og = BigInt(1)));
Rg = (e) => typeof e == "bigint" && Eg <= e;
Yn = (e) => (Og << BigInt(e)) - Og;
});
function FB(e, t = !1) {
return t
? { h: Number(e & Hu), l: Number((e >> V1) & Hu) }
: { h: Number((e >> V1) & Hu) | 0, l: Number(e & Hu) | 0 };
}
function H1(e, t = !1) {
let r = new Uint32Array(e.length),
o = new Uint32Array(e.length);
for (let n = 0; n < e.length; n++) {
let { h: a, l: i } = FB(e[n], t);
[r[n], o[n]] = [a, i];
}
return [r, o];
}
var Hu,
V1,
W1,
L1,
q1,
j1,
G1 = St(() => {
((Hu = BigInt(4294967295)), (V1 = BigInt(32)));
((W1 = (e, t, r) => (e << r) | (t >>> (32 - r))),
(L1 = (e, t, r) => (t << r) | (e >>> (32 - r))),
(q1 = (e, t, r) => (t << (r - 32)) | (e >>> (64 - r))),
(j1 = (e, t, r) => (e << (r - 32)) | (t >>> (64 - r))));
});
function jB(e, t = 24) {
let r = new Uint32Array(10);
for (let o = 24 - t; o < 24; o++) {
for (let i = 0; i < 10; i++)
r[i] = e[i] ^ e[i + 10] ^ e[i + 20] ^ e[i + 30] ^ e[i + 40];
for (let i = 0; i < 10; i += 2) {
let c = (i + 8) % 10,
d = (i + 2) % 10,
l = r[d],
u = r[d + 1],
p = Q1(l, u, 1) ^ r[c],
y = z1(l, u, 1) ^ r[c + 1];
for (let b = 0; b < 50; b += 10)
((e[i + b] ^= p), (e[i + b + 1] ^= y));
}
let n = e[2],
a = e[3];
for (let i = 0; i < 24; i++) {
let c = Z1[i],
d = Q1(n, a, c),
l = z1(n, a, c),
u = Y1[i];
((n = e[u]), (a = e[u + 1]), (e[u] = d), (e[u + 1] = l));
}
for (let i = 0; i < 50; i += 10) {
for (let c = 0; c < 10; c++) r[c] = e[i + c];
for (let c = 0; c < 10; c++)
e[i + c] ^= ~r[(c + 2) % 10] & r[(c + 4) % 10];
}
((e[0] ^= LB[o]), (e[1] ^= qB[o]));
}
r.fill(0);
}
var Y1,
Z1,
X1,
KB,
Yc,
JB,
VB,
HB,
WB,
LB,
qB,
Q1,
z1,
Wu,
Zn,
vae,
Sae,
xae,
Aae,
wae,
Br,
Pae,
kae,
eP,
Iae,
Tae,
bi = St(() => {
du();
G1();
No();
((Y1 = []),
(Z1 = []),
(X1 = []),
(KB = BigInt(0)),
(Yc = BigInt(1)),
(JB = BigInt(2)),
(VB = BigInt(7)),
(HB = BigInt(256)),
(WB = BigInt(113)));
for (let e = 0, t = Yc, r = 1, o = 0; e < 24; e++) {
(([r, o] = [o, (2 * r + 3 * o) % 5]),
Y1.push(2 * (5 * o + r)),
Z1.push((((e + 1) * (e + 2)) / 2) % 64));
let n = KB;
for (let a = 0; a < 7; a++)
((t = ((t << Yc) ^ ((t >> VB) * WB)) % HB),
t & JB && (n ^= Yc << ((Yc << BigInt(a)) - Yc)));
X1.push(n);
}
(([LB, qB] = H1(X1, !0)),
(Q1 = (e, t, r) => (r > 32 ? q1(e, t, r) : W1(e, t, r))),
(z1 = (e, t, r) => (r > 32 ? j1(e, t, r) : L1(e, t, r))));
((Wu = class e extends ti {
constructor(t, r, o, n = !1, a = 24) {
if (
(super(),
(this.blockLen = t),
(this.suffix = r),
(this.outputLen = o),
(this.enableXOF = n),
(this.rounds = a),
(this.pos = 0),
(this.posOut = 0),
(this.finished = !1),
(this.destroyed = !1),
Sy(o),
0 >= this.blockLen || this.blockLen >= 200)
)
throw new Error("Sha3 supports only keccak-f1600 function");
((this.state = new Uint8Array(200)),
(this.state32 = yA(this.state)));
}
keccak() {
(xy || Ay(this.state32),
jB(this.state32, this.rounds),
xy || Ay(this.state32),
(this.posOut = 0),
(this.pos = 0));
}
update(t) {
ei(this);
let { blockLen: r, state: o } = this;
t = ri(t);
let n = t.length;
for (let a = 0; a < n; ) {
let i = Math.min(r - this.pos, n - a);
for (let c = 0; c < i; c++) o[this.pos++] ^= t[a++];
this.pos === r && this.keccak();
}
return this;
}
finish() {
if (this.finished) return;
this.finished = !0;
let { state: t, suffix: r, pos: o, blockLen: n } = this;
((t[o] ^= r),
(r & 128) !== 0 && o === n - 1 && this.keccak(),
(t[n - 1] ^= 128),
this.keccak());
}
writeInto(t) {
(ei(this, !1), Xa(t), this.finish());
let r = this.state,
{ blockLen: o } = this;
for (let n = 0, a = t.length; n < a; ) {
this.posOut >= o && this.keccak();
let i = Math.min(o - this.posOut, a - n);
(t.set(r.subarray(this.posOut, this.posOut + i), n),
(this.posOut += i),
(n += i));
}
return t;
}
xofInto(t) {
if (!this.enableXOF)
throw new Error("XOF is not possible for this instance");
return this.writeInto(t);
}
xof(t) {
return (Sy(t), this.xofInto(new Uint8Array(t)));
}
digestInto(t) {
if ((cu(t, this), this.finished))
throw new Error("digest() was already called");
return (this.writeInto(t), this.destroy(), t);
}
digest() {
return this.digestInto(new Uint8Array(this.outputLen));
}
destroy() {
((this.destroyed = !0), this.state.fill(0));
}
_cloneInto(t) {
let {
blockLen: r,
suffix: o,
outputLen: n,
rounds: a,
enableXOF: i,
} = this;
return (
t || (t = new e(r, o, n, i, a)),
t.state32.set(this.state32),
(t.pos = this.pos),
(t.posOut = this.posOut),
(t.finished = this.finished),
(t.rounds = a),
(t.suffix = o),
(t.outputLen = n),
(t.enableXOF = i),
(t.destroyed = this.destroyed),
t
);
}
}),
(Zn = (e, t, r) => pu(() => new Wu(t, e, r))),
(vae = Zn(6, 144, 224 / 8)),
(Sae = Zn(6, 136, 256 / 8)),
(xae = Zn(6, 104, 384 / 8)),
(Aae = Zn(6, 72, 512 / 8)),
(wae = Zn(1, 144, 224 / 8)),
(Br = Zn(1, 136, 256 / 8)),
(Pae = Zn(1, 104, 384 / 8)),
(kae = Zn(1, 72, 512 / 8)),
(eP = (e, t, r) =>
gA((o = {}) => new Wu(t, e, o.dkLen === void 0 ? r : o.dkLen, !0))),
(Iae = eP(31, 168, 128 / 8)),
(Tae = eP(31, 136, 256 / 8)));
});
function GB(e, t) {
return e.exec(t)?.groups;
}
function Fg(e) {
let t = e.type;
if (tP.test(e.type) && "components" in e) {
t = "(";
let r = e.components.length;
for (let n = 0; n < r; n++) {
let a = e.components[n];
((t += Fg(a)), n < r - 1 && (t += ", "));
}
let o = GB(tP, e.type);
return ((t += `)${o?.array ?? ""}`), Fg({ ...e, type: t }));
}
return (
"indexed" in e && e.indexed && (t = `${t} indexed`),
e.name ? `${t} ${e.name}` : t
);
}
function Zc(e) {
let t = "",
r = e.length;
for (let o = 0; o < r; o++) {
let n = e[o];
((t += Fg(n)), o !== r - 1 && (t += ", "));
}
return t;
}
function QB(e) {
return e.type === "function"
? `function ${e.name}(${Zc(e.inputs)})${e.stateMutability && e.stateMutability !== "nonpayable" ? ` ${e.stateMutability}` : ""}${e.outputs?.length ? ` returns (${Zc(e.outputs)})` : ""}`
: e.type === "event"
? `event ${e.name}(${Zc(e.inputs)})`
: e.type === "error"
? `error ${e.name}(${Zc(e.inputs)})`
: e.type === "constructor"
? `constructor(${Zc(e.inputs)})${e.stateMutability === "payable" ? " payable" : ""}`
: e.type === "fallback"
? `fallback() external${e.stateMutability === "payable" ? " payable" : ""}`
: "receive() external payable";
}
function cP(e, t) {
return t?.(e)
? e
: e && typeof e == "object" && "cause" in e && e.cause !== void 0
? cP(e.cause, t)
: t
? null
: e;
}
function Jg(e, { includeName: t = !1 } = {}) {
if (e.type !== "function" && e.type !== "event" && e.type !== "error")
throw new oM(e.type);
return `${e.name}(${dP(e.inputs, { includeName: t })})`;
}
function dP(e, { includeName: t = !1 } = {}) {
return e
? e.map((r) => zB(r, { includeName: t })).join(t ? ", " : ",")
: "";
}
function zB(e, { includeName: t }) {
return e.type.startsWith("tuple")
? `(${dP(e.components, { includeName: t })})${e.type.slice(5)}`
: e.type + (t && e.name ? ` ${e.name}` : "");
}
function to(e, { strict: t = !0 } = {}) {
return !e || typeof e != "string"
? !1
: t
? /^0x[0-9a-fA-F]*$/.test(e)
: e.startsWith("0x");
}
function Nt(e) {
return to(e, { strict: !1 }) ? Math.ceil((e.length - 2) / 2) : e.length;
}
function mP(e, t, r, { strict: o } = {}) {
return to(e, { strict: !1 })
? sM(e, t, r, { strict: o })
: nM(e, t, r, { strict: o });
}
function fP(e, t) {
if (typeof t == "number" && t > 0 && t > Nt(e) - 1)
throw new uP({ offset: t, position: "start", size: Nt(e) });
}
function yP(e, t, r) {
if (typeof t == "number" && typeof r == "number" && Nt(e) !== r - t)
throw new uP({ offset: r, position: "end", size: Nt(e) });
}
function nM(e, t, r, { strict: o } = {}) {
fP(e, t);
let n = e.slice(t, r);
return (o && yP(n, t, r), n);
}
function sM(e, t, r, { strict: o } = {}) {
fP(e, t);
let n = `0x${e.replace("0x", "").slice((t ?? 0) * 2, (r ?? e.length) * 2)}`;
return (o && yP(n, t, r), n);
}
function vi(e, { dir: t, size: r = 32 } = {}) {
return typeof e == "string"
? Xn(e, { dir: t, size: r })
: aM(e, { dir: t, size: r });
}
function Xn(e, { dir: t, size: r = 32 } = {}) {
if (r === null) return e;
let o = e.replace("0x", "");
if (o.length > r * 2)
throw new pP({
size: Math.ceil(o.length / 2),
targetSize: r,
type: "hex",
});
return `0x${o[t === "right" ? "padEnd" : "padStart"](r * 2, "0")}`;
}
function aM(e, { dir: t, size: r = 32 } = {}) {
if (r === null) return e;
if (e.length > r)
throw new pP({ size: e.length, targetSize: r, type: "bytes" });
let o = new Uint8Array(r);
for (let n = 0; n < r; n++) {
let a = t === "right";
o[a ? n : r - n - 1] = e[a ? n : e.length - n - 1];
}
return o;
}
function Si(e, { size: t }) {
if (Nt(e) > t) throw new iM({ givenSize: Nt(e), maxSize: t });
}
function qu(e, t = {}) {
let { signed: r } = t;
t.size && Si(e, { size: t.size });
let o = BigInt(e);
if (!r) return o;
let n = (e.length - 2) / 2,
a = (1n << (BigInt(n) * 8n - 1n)) - 1n;
return o <= a ? o : o - BigInt(`0x${"f".padStart(n * 2, "f")}`) - 1n;
}
function hP(e, t = {}) {
return Number(qu(e, t));
}
function xi(e, t = {}) {
return typeof e == "number" || typeof e == "bigint"
? vn(e, t)
: typeof e == "string"
? SP(e, t)
: typeof e == "boolean"
? bP(e, t)
: vP(e, t);
}
function bP(e, t = {}) {
let r = `0x${Number(e)}`;
return typeof t.size == "number"
? (Si(r, { size: t.size }), vi(r, { size: t.size }))
: r;
}
function vP(e, t = {}) {
let r = "";
for (let n = 0; n < e.length; n++) r += cM[e[n]];
let o = `0x${r}`;
return typeof t.size == "number"
? (Si(o, { size: t.size }), vi(o, { dir: "right", size: t.size }))
: o;
}
function vn(e, t = {}) {
let { signed: r, size: o } = t,
n = BigInt(e),
a;
o
? r
? (a = (1n << (BigInt(o) * 8n - 1n)) - 1n)
: (a = 2n ** (BigInt(o) * 8n) - 1n)
: typeof e == "number" && (a = BigInt(Number.MAX_SAFE_INTEGER));
let i = typeof a == "bigint" && r ? -a - 1n : 0;
if ((a && n > a) || n < i) {
let d = typeof e == "bigint" ? "n" : "";
throw new gP({
max: a ? `${a}${d}` : void 0,
min: `${i}${d}`,
signed: r,
size: o,
value: `${e}${d}`,
});
}
let c = `0x${(r && n < 0 ? (1n << BigInt(o * 8)) + BigInt(n) : n).toString(16)}`;
return o ? vi(c, { size: o }) : c;
}
function SP(e, t = {}) {
let r = dM.encode(e);
return vP(r, t);
}
function xP(e, t = {}) {
return typeof e == "number" || typeof e == "bigint"
? pM(e, t)
: typeof e == "boolean"
? uM(e, t)
: to(e)
? AP(e, t)
: wP(e, t);
}
function uM(e, t = {}) {
let r = new Uint8Array(1);
return (
(r[0] = Number(e)),
typeof t.size == "number"
? (Si(r, { size: t.size }), vi(r, { size: t.size }))
: r
);
}
function oP(e) {
if (e >= bn.zero && e <= bn.nine) return e - bn.zero;
if (e >= bn.A && e <= bn.F) return e - (bn.A - 10);
if (e >= bn.a && e <= bn.f) return e - (bn.a - 10);
}
function AP(e, t = {}) {
let r = e;
t.size &&
(Si(r, { size: t.size }), (r = vi(r, { dir: "right", size: t.size })));
let o = r.slice(2);
o.length % 2 && (o = `0${o}`);
let n = o.length / 2,
a = new Uint8Array(n);
for (let i = 0, c = 0; i < n; i++) {
let d = oP(o.charCodeAt(c++)),
l = oP(o.charCodeAt(c++));
if (d === void 0 || l === void 0)
throw new De(
`Invalid byte sequence ("${o[c - 2]}${o[c - 1]}" in "${o}").`,
);
a[i] = d * 16 + l;
}
return a;
}
function pM(e, t) {
let r = vn(e, t);
return AP(r);
}
function wP(e, t = {}) {
let r = lM.encode(e);
return typeof t.size == "number"
? (Si(r, { size: t.size }), vi(r, { dir: "right", size: t.size }))
: r;
}
function ro(e, t) {
let r = t || "hex",
o = Br(to(e, { strict: !1 }) ? xP(e) : e);
return r === "bytes" ? o : xi(o);
}
function fM(e) {
return mM(e);
}
function yM(e) {
let t = !0,
r = "",
o = 0,
n = "",
a = !1;
for (let i = 0; i < e.length; i++) {
let c = e[i];
if (
(["(", ")", ","].includes(c) && (t = !0),
c === "(" && o++,
c === ")" && o--,
!!t)
) {
if (o === 0) {
if (c === " " && ["event", "function", ""].includes(n)) n = "";
else if (((n += c), c === ")")) {
a = !0;
break;
}
continue;
}
if (c === " ") {
e[i - 1] !== "," && r !== "," && r !== ",(" && ((r = ""), (t = !1));
continue;
}
((n += c), (r += c));
}
}
if (!a) throw new De("Unable to normalize signature.");
return n;
}
function PP(e) {
return fM(gM(e));
}
function es(e, t) {
let { strict: r = !0 } = t ?? {},
o = `${e}.${r}`;
if ($g.has(o)) return $g.get(o);
let n = hM.test(e)
? e.toLowerCase() === e
? !0
: r
? Gu(e) === e
: !0
: !1;
return ($g.set(o, n), n);
}
function Gu(e, t) {
if (_g.has(`${e}.${t}`)) return _g.get(`${e}.${t}`);
let r = t ? `${t}${e.toLowerCase()}` : e.substring(2).toLowerCase(),
o = ro(wP(r), "bytes"),
n = (t ? r.substring(`${t}0x`.length) : r).split("");
for (let i = 0; i < 40; i += 2)
(o[i >> 1] >> 4 >= 8 && n[i] && (n[i] = n[i].toUpperCase()),
(o[i >> 1] & 15) >= 8 &&
n[i + 1] &&
(n[i + 1] = n[i + 1].toUpperCase()));
let a = `0x${n.join("")}`;
return (_g.set(`${e}.${t}`, a), a);
}
function Qu(e, t) {
if (!es(e, { strict: !1 })) throw new ju({ address: e });
return Gu(e, t);
}
function ts(e) {
return typeof e[0] == "string" ? TP(e) : SM(e);
}
function SM(e) {
let t = 0;
for (let n of e) t += n.length;
let r = new Uint8Array(t),
o = 0;
for (let n of e) (r.set(n, o), (o += n.length));
return r;
}
function TP(e) {
return `0x${e.reduce((t, r) => t + r.replace("0x", ""), "")}`;
}
function oo(e, t) {
if (e.length !== t.length)
throw new XB({ expectedLength: e.length, givenLength: t.length });
let r = xM({ params: e, values: t }),
o = Lg(r);
return o.length === 0 ? "0x" : o;
}
function xM({ params: e, values: t }) {
let r = [];
for (let o = 0; o < e.length; o++)
r.push(Wg({ param: e[o], value: t[o] }));
return r;
}
function Wg({ param: e, value: t }) {
let r = CM(e.type);
if (r) {
let [o, n] = r;
return wM(t, { length: o, param: { ...e, type: n } });
}
if (e.type === "tuple") return UM(t, { param: e });
if (e.type === "address") return AM(t);
if (e.type === "bool") return kM(t);
if (e.type.startsWith("uint") || e.type.startsWith("int")) {
let o = e.type.startsWith("int"),
[, , n = "256"] = Hg.exec(e.type) ?? [];
return IM(t, { signed: o, size: Number(n) });
}
if (e.type.startsWith("bytes")) return PM(t, { param: e });
if (e.type === "string") return TM(t);
throw new tM(e.type, { docsPath: "/docs/contract/encodeAbiParameters" });
}
function Lg(e) {
let t = 0;
for (let a = 0; a < e.length; a++) {
let { dynamic: i, encoded: c } = e[a];
i ? (t += 32) : (t += Nt(c));
}
let r = [],
o = [],
n = 0;
for (let a = 0; a < e.length; a++) {
let { dynamic: i, encoded: c } = e[a];
i
? (r.push(vn(t + n, { size: 32 })), o.push(c), (n += Nt(c)))
: r.push(c);
}
return ts([...r, ...o]);
}
function AM(e) {
if (!es(e)) throw new ju({ address: e });
return { dynamic: !1, encoded: Xn(e.toLowerCase()) };
}
function wM(e, { length: t, param: r }) {
let o = t === null;
if (!Array.isArray(e)) throw new rM(e);
if (!o && e.length !== t)
throw new YB({
expectedLength: t,
givenLength: e.length,
type: `${r.type}[${t}]`,
});
let n = !1,
a = [];
for (let i = 0; i < e.length; i++) {
let c = Wg({ param: r, value: e[i] });
(c.dynamic && (n = !0), a.push(c));
}
if (o || n) {
let i = Lg(a);
if (o) {
let c = vn(a.length, { size: 32 });
return { dynamic: !0, encoded: a.length > 0 ? ts([c, i]) : c };
}
if (n) return { dynamic: !0, encoded: i };
}
return { dynamic: !1, encoded: ts(a.map(({ encoded: i }) => i)) };
}
function PM(e, { param: t }) {
let [, r] = t.type.split("bytes"),
o = Nt(e);
if (!r) {
let n = e;
return (
o % 32 !== 0 &&
(n = Xn(n, {
dir: "right",
size: Math.ceil((e.length - 2) / 2 / 32) * 32,
})),
{ dynamic: !0, encoded: ts([Xn(vn(o, { size: 32 })), n]) }
);
}
if (o !== Number.parseInt(r, 10))
throw new ZB({ expectedSize: Number.parseInt(r, 10), value: e });
return { dynamic: !1, encoded: Xn(e, { dir: "right" }) };
}
function kM(e) {
if (typeof e != "boolean")
throw new De(
`Invalid boolean value: "${e}" (type: ${typeof e}). Expected: \`true\` or \`false\`.`,
);
return { dynamic: !1, encoded: Xn(bP(e)) };
}
function IM(e, { signed: t, size: r = 256 }) {
if (typeof r == "number") {
let o = 2n ** (BigInt(r) - (t ? 1n : 0n)) - 1n,
n = t ? -o - 1n : 0n;
if (e > o || e < n)
throw new gP({
max: o.toString(),
min: n.toString(),
signed: t,
size: r / 8,
value: e.toString(),
});
}
return { dynamic: !1, encoded: vn(e, { size: 32, signed: t }) };
}
function TM(e) {
let t = SP(e),
r = Math.ceil(Nt(t) / 32),
o = [];
for (let n = 0; n < r; n++)
o.push(Xn(mP(t, n * 32, (n + 1) * 32), { dir: "right" }));
return { dynamic: !0, encoded: ts([Xn(vn(Nt(t), { size: 32 })), ...o]) };
}
function UM(e, { param: t }) {
let r = !1,
o = [];
for (let n = 0; n < t.components.length; n++) {
let a = t.components[n],
i = Array.isArray(e) ? n : a.name,
c = Wg({ param: a, value: e[i] });
(o.push(c), c.dynamic && (r = !0));
}
return {
dynamic: r,
encoded: r ? Lg(o) : ts(o.map(({ encoded: n }) => n)),
};
}
function CM(e) {
let t = e.match(/^(.*)\[(\d+)?\]$/);
return t ? [t[2] ? Number(t[2]) : null, t[1]] : void 0;
}
function OM(e) {
let { abi: t, args: r = [], name: o } = e,
n = to(o, { strict: !1 }),
a = t.filter((c) =>
n
? c.type === "function"
? kP(c) === o
: c.type === "event"
? RM(c) === o
: !1
: "name" in c && c.name === o,
);
if (a.length === 0) return;
if (a.length === 1) return a[0];
let i;
for (let c of a) {
if (!("inputs" in c)) continue;
if (!r || r.length === 0) {
if (!c.inputs || c.inputs.length === 0) return c;
continue;
}
if (!c.inputs || c.inputs.length === 0 || c.inputs.length !== r.length)
continue;
if (
r.every((l, u) => {
let p = "inputs" in c && c.inputs[u];
return p ? Vg(l, p) : !1;
})
) {
if (i && "inputs" in i && i.inputs) {
let l = RP(c.inputs, i.inputs, r);
if (l)
throw new eM(
{ abiItem: c, type: l[0] },
{ abiItem: i, type: l[1] },
);
}
i = c;
}
}
return i || a[0];
}
function Vg(e, t) {
let r = typeof e,
o = t.type;
switch (o) {
case "address":
return es(e, { strict: !1 });
case "bool":
return r === "boolean";
case "function":
return r === "string";
case "string":
return r === "string";
default:
return o === "tuple" && "components" in t
? Object.values(t.components).every((n, a) =>
Vg(Object.values(e)[a], n),
)
: /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
o,
)
? r === "number" || r === "bigint"
: /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(o)
? r === "string" || e instanceof Uint8Array
: /[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(o)
? Array.isArray(e) &&
e.every((n) =>
Vg(n, { ...t, type: o.replace(/(\[[0-9]{0,}\])$/, "") }),
)
: !1;
}
}
function RP(e, t, r) {
for (let o in e) {
let n = e[o],
a = t[o];
if (
n.type === "tuple" &&
a.type === "tuple" &&
"components" in n &&
"components" in a
)
return RP(n.components, a.components, r[o]);
let i = [n.type, a.type];
if (
i.includes("address") && i.includes("bytes20")
? !0
: i.includes("address") && i.includes("string")
? es(r[o], { strict: !1 })
: i.includes("address") && i.includes("bytes")
? es(r[o], { strict: !1 })
: !1
)
return i;
}
}
function DM(e, t) {
let r = e.toString(),
o = r.startsWith("-");
(o && (r = r.slice(1)), (r = r.padStart(t, "0")));
let [n, a] = [r.slice(0, r.length - t), r.slice(r.length - t)];
return (
(a = a.replace(/(0+)$/, "")),
`${o ? "-" : ""}${n || "0"}${a ? `.${a}` : ""}`
);
}
function Lu(e, t = "wei") {
return DM(e, EM[t]);
}
function NM(e) {
let { abi: t, args: r, functionName: o } = e,
n = t[0];
if (o) {
let a = OM({ abi: t, args: r, name: o });
if (!a) throw new rP(o, { docsPath: sP });
n = a;
}
if (n.type !== "function") throw new rP(void 0, { docsPath: sP });
return { abi: [n], functionName: kP(Jg(n)) };
}
function Xc(e) {
let { args: t } = e,
{ abi: r, functionName: o } =
e.abi.length === 1 && e.functionName?.startsWith("0x") ? e : NM(e),
n = r[0],
a = o,
i = "inputs" in n && n.inputs ? oo(n.inputs, t ?? []) : void 0;
return TP([a, i ?? "0x"]);
}
var tP,
aP,
Cae,
Rae,
iP,
Mg,
De,
YB,
ZB,
XB,
rP,
eM,
lP,
tM,
rM,
oM,
uP,
pP,
gP,
iM,
cM,
dM,
lM,
bn,
mM,
gM,
kP,
ju,
IP,
hM,
$g,
_g,
nP,
bM,
vM,
Eae,
UP,
Hg,
CP,
RM,
EM,
sP,
OP,
BM,
MM,
$M,
_M,
FM,
KM,
JM,
VM,
HM,
WM,
Dae,
Nae,
Bae,
Mae,
$ae,
_ae,
Fae,
Kae,
Jae,
Vae,
Hae,
Wae,
Lae,
qae,
jae,
Gae,
Qae,
zae,
Yae,
Zae,
Xae,
eie,
tie,
rie,
oie,
nie,
sie,
aie,
iie,
cie,
die,
lie,
uie,
pie,
mie,
fie,
yie,
gie,
hie,
bie,
vie,
Sie,
xie,
Aie,
wie,
Pie,
kie,
Iie,
Tie,
Uie,
Cie,
Rie,
Oie,
Eie,
Die,
Nie,
Bie,
Mie,
$ie,
_ie,
Fie,
Kie,
Jie,
Vie,
Hie,
Wie,
Lie,
qie,
jie,
Gie,
Qie,
zie,
Yie,
Zie,
Xie,
ece,
tce,
rce,
oce,
nce,
sce,
ace,
ice,
cce,
dce,
lce,
uce,
pce,
mce,
fce,
yce,
gce,
hce,
bce,
vce,
Sce,
ed = St(() => {
"use strict";
bi();
tP = /^tuple(?<array>(\[(\d*)\])*)$/;
((aP = [
{
inputs: [{ name: "dns", type: "bytes" }],
name: "DNSDecodingFailed",
type: "error",
},
{
inputs: [{ name: "ens", type: "string" }],
name: "DNSEncodingFailed",
type: "error",
},
{ inputs: [], name: "EmptyAddress", type: "error" },
{
inputs: [
{ name: "status", type: "uint16" },
{ name: "message", type: "string" },
],
name: "HttpError",
type: "error",
},
{ inputs: [], name: "InvalidBatchGatewayResponse", type: "error" },
{
inputs: [{ name: "errorData", type: "bytes" }],
name: "ResolverError",
type: "error",
},
{
inputs: [
{ name: "name", type: "bytes" },
{ name: "resolver", type: "address" },
],
name: "ResolverNotContract",
type: "error",
},
{
inputs: [{ name: "name", type: "bytes" }],
name: "ResolverNotFound",
type: "error",
},
{
inputs: [
{ name: "primary", type: "string" },
{ name: "primaryAddress", type: "bytes" },
],
name: "ReverseAddressMismatch",
type: "error",
},
{
inputs: [
{ internalType: "bytes4", name: "selector", type: "bytes4" },
],
name: "UnsupportedResolverProfile",
type: "error",
},
]),
(Cae = [
...aP,
{
name: "resolveWithGateways",
type: "function",
stateMutability: "view",
inputs: [
{ name: "name", type: "bytes" },
{ name: "data", type: "bytes" },
{ name: "gateways", type: "string[]" },
],
outputs: [
{ name: "", type: "bytes" },
{ name: "address", type: "address" },
],
},
]),
(Rae = [
...aP,
{
name: "reverseWithGateways",
type: "function",
stateMutability: "view",
inputs: [
{ type: "bytes", name: "reverseName" },
{ type: "uint256", name: "coinType" },
{ type: "string[]", name: "gateways" },
],
outputs: [
{ type: "string", name: "resolvedName" },
{ type: "address", name: "resolver" },
{ type: "address", name: "reverseResolver" },
],
},
]),
(iP = "2.41.2"),
(Mg = {
getDocsUrl: ({ docsBaseUrl: e, docsPath: t = "", docsSlug: r }) =>
t ? `${e ?? "https://viem.sh"}${t}${r ? `#${r}` : ""}` : void 0,
version: `viem@${iP}`,
}),
(De = class Kg extends Error {
constructor(t, r = {}) {
let o =
r.cause instanceof Kg
? r.cause.details
: r.cause?.message
? r.cause.message
: r.details,
n = (r.cause instanceof Kg && r.cause.docsPath) || r.docsPath,
a = Mg.getDocsUrl?.({ ...r, docsPath: n }),
i = [
t || "An error occurred.",
"",
...(r.metaMessages ? [...r.metaMessages, ""] : []),
...(a ? [`Docs: ${a}`] : []),
...(o ? [`Details: ${o}`] : []),
...(Mg.version ? [`Version: ${Mg.version}`] : []),
].join(`
`);
(super(i, r.cause ? { cause: r.cause } : void 0),
Object.defineProperty(this, "details", {
enumerable: !0,
configurable: !0,
writable: !0,
value: void 0,
}),
Object.defineProperty(this, "docsPath", {
enumerable: !0,
configurable: !0,
writable: !0,
value: void 0,
}),
Object.defineProperty(this, "metaMessages", {
enumerable: !0,
configurable: !0,
writable: !0,
value: void 0,
}),
Object.defineProperty(this, "shortMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value: void 0,
}),
Object.defineProperty(this, "version", {
enumerable: !0,
configurable: !0,
writable: !0,
value: void 0,
}),
Object.defineProperty(this, "name", {
enumerable: !0,
configurable: !0,
writable: !0,
value: "BaseError",
}),
(this.details = o),
(this.docsPath = n),
(this.metaMessages = r.metaMessages),
(this.name = r.name ?? this.name),
(this.shortMessage = t),
(this.version = iP));
}
walk(t) {
return cP(this, t);
}
}));
((YB = class extends De {
constructor({ expectedLength: e, givenLength: t, type: r }) {
super(
[
`ABI encoding array length mismatch for type ${r}.`,
`Expected length: ${e}`,
`Given length: ${t}`,
].join(`
`),
{ name: "AbiEncodingArrayLengthMismatchError" },
);
}
}),
(ZB = class extends De {
constructor({ expectedSize: e, value: t }) {
super(
`Size of bytes "${t}" (bytes${Nt(t)}) does not match expected size (bytes${e}).`,
{ name: "AbiEncodingBytesSizeMismatchError" },
);
}
}),
(XB = class extends De {
constructor({ expectedLength: e, givenLength: t }) {
super(
[
"ABI encoding params/values length mismatch.",
`Expected length (params): ${e}`,
`Given length (values): ${t}`,
].join(`
`),
{ name: "AbiEncodingLengthMismatchError" },
);
}
}),
(rP = class extends De {
constructor(e, { docsPath: t } = {}) {
super(
[
`Function ${e ? `"${e}" ` : ""}not found on ABI.`,
"Make sure you are using the correct ABI and that the function exists on it.",
].join(`
`),
{ docsPath: t, name: "AbiFunctionNotFoundError" },
);
}
}),
(eM = class extends De {
constructor(e, t) {
super("Found ambiguous types in overloaded ABI items.", {
metaMessages: [
`\`${e.type}\` in \`${Jg(e.abiItem)}\`, and`,
`\`${t.type}\` in \`${Jg(t.abiItem)}\``,
"",
"These types encode differently and cannot be distinguished at runtime.",
"Remove one of the ambiguous items in the ABI.",
],
name: "AbiItemAmbiguityError",
});
}
}),
(lP = class extends De {
constructor({ expectedSize: e, givenSize: t }) {
super(`Expected bytes${e}, got bytes${t}.`, {
name: "BytesSizeMismatchError",
});
}
}),
(tM = class extends De {
constructor(e, { docsPath: t }) {
super(
[
`Type "${e}" is not a valid encoding type.`,
"Please provide a valid ABI type.",
].join(`
`),
{ docsPath: t, name: "InvalidAbiEncodingType" },
);
}
}),
(rM = class extends De {
constructor(e) {
super(
[`Value "${e}" is not a valid array.`].join(`
`),
{ name: "InvalidArrayError" },
);
}
}),
(oM = class extends De {
constructor(e) {
super(
[
`"${e}" is not a valid definition type.`,
'Valid types: "function", "event", "error"',
].join(`
`),
{ name: "InvalidDefinitionTypeError" },
);
}
}),
(uP = class extends De {
constructor({ offset: e, position: t, size: r }) {
super(
`Slice ${t === "start" ? "starting" : "ending"} at offset "${e}" is out-of-bounds (size: ${r}).`,
{ name: "SliceOffsetOutOfBoundsError" },
);
}
}),
(pP = class extends De {
constructor({ size: e, targetSize: t, type: r }) {
super(
`${r.charAt(0).toUpperCase()}${r.slice(1).toLowerCase()} size (${e}) exceeds padding size (${t}).`,
{ name: "SizeExceedsPaddingSizeError" },
);
}
}));
((gP = class extends De {
constructor({ max: e, min: t, signed: r, size: o, value: n }) {
super(
`Number "${n}" is not in safe ${o ? `${o * 8}-bit ${r ? "signed" : "unsigned"} ` : ""}integer range ${e ? `(${t} to ${e})` : `(above ${t})`}`,
{ name: "IntegerOutOfRangeError" },
);
}
}),
(iM = class extends De {
constructor({ givenSize: e, maxSize: t }) {
super(`Size cannot exceed ${t} bytes. Given size: ${e} bytes.`, {
name: "SizeOverflowError",
});
}
}));
cM = Array.from({ length: 256 }, (e, t) =>
t.toString(16).padStart(2, "0"),
);
dM = new TextEncoder();
lM = new TextEncoder();
bn = { zero: 48, nine: 57, A: 65, F: 70, a: 97, f: 102 };
mM = (e) => ro(xP(e));
gM = (e) => {
let t = typeof e == "string" ? e : QB(e);
return yM(t);
};
((kP = (e) => mP(PP(e), 0, 4)),
(ju = class extends De {
constructor({ address: e }) {
super(`Address "${e}" is invalid.`, {
metaMessages: [
"- Address must be a hex value of 20 bytes (40 hex characters).",
"- Address must match its checksum counterpart.",
],
name: "InvalidAddressError",
});
}
}),
(IP = class extends Map {
constructor(e) {
(super(),
Object.defineProperty(this, "maxSize", {
enumerable: !0,
configurable: !0,
writable: !0,
value: void 0,
}),
(this.maxSize = e));
}
get(e) {
let t = super.get(e);
return (
super.has(e) &&
t !== void 0 &&
(this.delete(e), super.set(e, t)),
t
);
}
set(e, t) {
if ((super.set(e, t), this.maxSize && this.size > this.maxSize)) {
let r = this.keys().next().value;
r && this.delete(r);
}
return this;
}
}),
(hM = /^0x[a-fA-F0-9]{40}$/),
($g = new IP(8192)));
_g = new IP(8192);
((nP = class extends De {
constructor({ offset: e }) {
super(`Offset \`${e}\` cannot be negative.`, {
name: "NegativeOffsetError",
});
}
}),
(bM = class extends De {
constructor({ length: e, position: t }) {
super(
`Position \`${t}\` is out of bounds (\`0 < position < ${e}\`).`,
{ name: "PositionOutOfBoundsError" },
);
}
}),
(vM = class extends De {
constructor({ count: e, limit: t }) {
super(
`Recursive read limit of \`${t}\` exceeded (recursive read count: \`${e}\`).`,
{ name: "RecursiveReadLimitExceededError" },
);
}
}),
(Eae = {
bytes: new Uint8Array(),
dataView: new DataView(new ArrayBuffer(0)),
position: 0,
positionReadCount: new Map(),
recursiveReadCount: 0,
recursiveReadLimit: Number.POSITIVE_INFINITY,
assertReadLimit() {
if (this.recursiveReadCount >= this.recursiveReadLimit)
throw new vM({
count: this.recursiveReadCount + 1,
limit: this.recursiveReadLimit,
});
},
assertPosition(e) {
if (e < 0 || e > this.bytes.length - 1)
throw new bM({ length: this.bytes.length, position: e });
},
decrementPosition(e) {
if (e < 0) throw new nP({ offset: e });
let t = this.position - e;
(this.assertPosition(t), (this.position = t));
},
getReadCount(e) {
return this.positionReadCount.get(e || this.position) || 0;
},
incrementPosition(e) {
if (e < 0) throw new nP({ offset: e });
let t = this.position + e;
(this.assertPosition(t), (this.position = t));
},
inspectByte(e) {
let t = e ?? this.position;
return (this.assertPosition(t), this.bytes[t]);
},
inspectBytes(e, t) {
let r = t ?? this.position;
return (
this.assertPosition(r + e - 1),
this.bytes.subarray(r, r + e)
);
},
inspectUint8(e) {
let t = e ?? this.position;
return (this.assertPosition(t), this.bytes[t]);
},
inspectUint16(e) {
let t = e ?? this.position;
return (this.assertPosition(t + 1), this.dataView.getUint16(t));
},
inspectUint24(e) {
let t = e ?? this.position;
return (
this.assertPosition(t + 2),
(this.dataView.getUint16(t) << 8) +
this.dataView.getUint8(t + 2)
);
},
inspectUint32(e) {
let t = e ?? this.position;
return (this.assertPosition(t + 3), this.dataView.getUint32(t));
},
pushByte(e) {
(this.assertPosition(this.position),
(this.bytes[this.position] = e),
this.position++);
},
pushBytes(e) {
(this.assertPosition(this.position + e.length - 1),
this.bytes.set(e, this.position),
(this.position += e.length));
},
pushUint8(e) {
(this.assertPosition(this.position),
(this.bytes[this.position] = e),
this.position++);
},
pushUint16(e) {
(this.assertPosition(this.position + 1),
this.dataView.setUint16(this.position, e),
(this.position += 2));
},
pushUint24(e) {
(this.assertPosition(this.position + 2),
this.dataView.setUint16(this.position, e >> 8),
this.dataView.setUint8(this.position + 2, e & 255),
(this.position += 3));
},
pushUint32(e) {
(this.assertPosition(this.position + 3),
this.dataView.setUint32(this.position, e),
(this.position += 4));
},
readByte() {
(this.assertReadLimit(), this._touch());
let e = this.inspectByte();
return (this.position++, e);
},
readBytes(e, t) {
(this.assertReadLimit(), this._touch());
let r = this.inspectBytes(e);
return ((this.position += t ?? e), r);
},
readUint8() {
(this.assertReadLimit(), this._touch());
let e = this.inspectUint8();
return ((this.position += 1), e);
},
readUint16() {
(this.assertReadLimit(), this._touch());
let e = this.inspectUint16();
return ((this.position += 2), e);
},
readUint24() {
(this.assertReadLimit(), this._touch());
let e = this.inspectUint24();
return ((this.position += 3), e);
},
readUint32() {
(this.assertReadLimit(), this._touch());
let e = this.inspectUint32();
return ((this.position += 4), e);
},
get remaining() {
return this.bytes.length - this.position;
},
setPosition(e) {
let t = this.position;
return (
this.assertPosition(e),
(this.position = e),
() => (this.position = t)
);
},
_touch() {
if (this.recursiveReadLimit === Number.POSITIVE_INFINITY) return;
let e = this.getReadCount();
(this.positionReadCount.set(this.position, e + 1),
e > 0 && this.recursiveReadCount++);
},
}));
((UP = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/),
(Hg =
/^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/));
((CP = (e, t, r) =>
JSON.stringify(
e,
(o, n) => {
let a = typeof n == "bigint" ? n.toString() : n;
return typeof t == "function" ? t(o, a) : a;
},
r,
)),
(RM = PP));
EM = { ether: -9, wei: 9 };
sP = "/docs/contract/encodeFunctionData";
OP = class extends De {
constructor({ cause: e, message: t } = {}) {
let r = t
?.replace("execution reverted: ", "")
?.replace("execution reverted", "");
super(
`Execution reverted ${r ? `with reason: ${r}` : "for an unknown reason"}.`,
{ cause: e, name: "ExecutionRevertedError" },
);
}
};
Object.defineProperty(OP, "code", {
enumerable: !0,
configurable: !0,
writable: !0,
value: 3,
});
Object.defineProperty(OP, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value: /execution reverted/,
});
BM = class extends De {
constructor({ cause: e, maxFeePerGas: t } = {}) {
super(
`The fee cap (\`maxFeePerGas\`${t ? ` = ${Lu(t)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`,
{ cause: e, name: "FeeCapTooHighError" },
);
}
};
Object.defineProperty(BM, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value:
/max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/,
});
MM = class extends De {
constructor({ cause: e, maxFeePerGas: t } = {}) {
super(
`The fee cap (\`maxFeePerGas\`${t ? ` = ${Lu(t)}` : ""} gwei) cannot be lower than the block base fee.`,
{ cause: e, name: "FeeCapTooLowError" },
);
}
};
Object.defineProperty(MM, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value:
/max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/,
});
$M = class extends De {
constructor({ cause: e, nonce: t } = {}) {
super(
`Nonce provided for the transaction ${t ? `(${t}) ` : ""}is higher than the next one expected.`,
{ cause: e, name: "NonceTooHighError" },
);
}
};
Object.defineProperty($M, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value: /nonce too high/,
});
_M = class extends De {
constructor({ cause: e, nonce: t } = {}) {
super(
[
`Nonce provided for the transaction ${t ? `(${t}) ` : ""}is lower than the current nonce of the account.`,
"Try increasing the nonce or find the latest nonce with `getTransactionCount`.",
].join(`
`),
{ cause: e, name: "NonceTooLowError" },
);
}
};
Object.defineProperty(_M, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value: /nonce too low|transaction already imported|already known/,
});
FM = class extends De {
constructor({ cause: e, nonce: t } = {}) {
super(
`Nonce provided for the transaction ${t ? `(${t}) ` : ""}exceeds the maximum allowed nonce.`,
{ cause: e, name: "NonceMaxValueError" },
);
}
};
Object.defineProperty(FM, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value: /nonce has max value/,
});
KM = class extends De {
constructor({ cause: e } = {}) {
super(
[
"The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account.",
].join(`
`),
{
cause: e,
metaMessages: [
"This error could arise when the account does not have enough funds to:",
" - pay for the total gas fee,",
" - pay for the value to send.",
" ",
"The cost of the transaction is calculated as `gas * gas fee + value`, where:",
" - `gas` is the amount of gas needed for transaction to execute,",
" - `gas fee` is the gas fee,",
" - `value` is the amount of ether to send to the recipient.",
],
name: "InsufficientFundsError",
},
);
}
};
Object.defineProperty(KM, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value:
/insufficient funds|exceeds transaction sender account balance/,
});
JM = class extends De {
constructor({ cause: e, gas: t } = {}) {
super(
`The amount of gas ${t ? `(${t}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`,
{ cause: e, name: "IntrinsicGasTooHighError" },
);
}
};
Object.defineProperty(JM, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value: /intrinsic gas too high|gas limit reached/,
});
VM = class extends De {
constructor({ cause: e, gas: t } = {}) {
super(
`The amount of gas ${t ? `(${t}) ` : ""}provided for the transaction is too low.`,
{ cause: e, name: "IntrinsicGasTooLowError" },
);
}
};
Object.defineProperty(VM, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value: /intrinsic gas too low/,
});
HM = class extends De {
constructor({ cause: e }) {
super("The transaction type is not supported for this chain.", {
cause: e,
name: "TransactionTypeNotSupportedError",
});
}
};
Object.defineProperty(HM, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value: /transaction type not valid/,
});
WM = class extends De {
constructor({
cause: e,
maxPriorityFeePerGas: t,
maxFeePerGas: r,
} = {}) {
super(
[
`The provided tip (\`maxPriorityFeePerGas\`${t ? ` = ${Lu(t)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${r ? ` = ${Lu(r)} gwei` : ""}).`,
].join(`
`),
{ cause: e, name: "TipAboveFeeCapError" },
);
}
};
Object.defineProperty(WM, "nodeMessage", {
enumerable: !0,
configurable: !0,
writable: !0,
value:
/max priority fee per gas higher than max fee per gas|tip higher than fee cap/,
});
((Dae = 2n ** (8n - 1n) - 1n),
(Nae = 2n ** (16n - 1n) - 1n),
(Bae = 2n ** (24n - 1n) - 1n),
(Mae = 2n ** (32n - 1n) - 1n),
($ae = 2n ** (40n - 1n) - 1n),
(_ae = 2n ** (48n - 1n) - 1n),
(Fae = 2n ** (56n - 1n) - 1n),
(Kae = 2n ** (64n - 1n) - 1n),
(Jae = 2n ** (72n - 1n) - 1n),
(Vae = 2n ** (80n - 1n) - 1n),
(Hae = 2n ** (88n - 1n) - 1n),
(Wae = 2n ** (96n - 1n) - 1n),
(Lae = 2n ** (104n - 1n) - 1n),
(qae = 2n ** (112n - 1n) - 1n),
(jae = 2n ** (120n - 1n) - 1n),
(Gae = 2n ** (128n - 1n) - 1n),
(Qae = 2n ** (136n - 1n) - 1n),
(zae = 2n ** (144n - 1n) - 1n),
(Yae = 2n ** (152n - 1n) - 1n),
(Zae = 2n ** (160n - 1n) - 1n),
(Xae = 2n ** (168n - 1n) - 1n),
(eie = 2n ** (176n - 1n) - 1n),
(tie = 2n ** (184n - 1n) - 1n),
(rie = 2n ** (192n - 1n) - 1n),
(oie = 2n ** (200n - 1n) - 1n),
(nie = 2n ** (208n - 1n) - 1n),
(sie = 2n ** (216n - 1n) - 1n),
(aie = 2n ** (224n - 1n) - 1n),
(iie = 2n ** (232n - 1n) - 1n),
(cie = 2n ** (240n - 1n) - 1n),
(die = 2n ** (248n - 1n) - 1n),
(lie = 2n ** (256n - 1n) - 1n),
(uie = -(2n ** (8n - 1n))),
(pie = -(2n ** (16n - 1n))),
(mie = -(2n ** (24n - 1n))),
(fie = -(2n ** (32n - 1n))),
(yie = -(2n ** (40n - 1n))),
(gie = -(2n ** (48n - 1n))),
(hie = -(2n ** (56n - 1n))),
(bie = -(2n ** (64n - 1n))),
(vie = -(2n ** (72n - 1n))),
(Sie = -(2n ** (80n - 1n))),
(xie = -(2n ** (88n - 1n))),
(Aie = -(2n ** (96n - 1n))),
(wie = -(2n ** (104n - 1n))),
(Pie = -(2n ** (112n - 1n))),
(kie = -(2n ** (120n - 1n))),
(Iie = -(2n ** (128n - 1n))),
(Tie = -(2n ** (136n - 1n))),
(Uie = -(2n ** (144n - 1n))),
(Cie = -(2n ** (152n - 1n))),
(Rie = -(2n ** (160n - 1n))),
(Oie = -(2n ** (168n - 1n))),
(Eie = -(2n ** (176n - 1n))),
(Die = -(2n ** (184n - 1n))),
(Nie = -(2n ** (192n - 1n))),
(Bie = -(2n ** (200n - 1n))),
(Mie = -(2n ** (208n - 1n))),
($ie = -(2n ** (216n - 1n))),
(_ie = -(2n ** (224n - 1n))),
(Fie = -(2n ** (232n - 1n))),
(Kie = -(2n ** (240n - 1n))),
(Jie = -(2n ** (248n - 1n))),
(Vie = -(2n ** (256n - 1n))),
(Hie = 2n ** 8n - 1n),
(Wie = 2n ** 16n - 1n),
(Lie = 2n ** 24n - 1n),
(qie = 2n ** 32n - 1n),
(jie = 2n ** 40n - 1n),
(Gie = 2n ** 48n - 1n),
(Qie = 2n ** 56n - 1n),
(zie = 2n ** 64n - 1n),
(Yie = 2n ** 72n - 1n),
(Zie = 2n ** 80n - 1n),
(Xie = 2n ** 88n - 1n),
(ece = 2n ** 96n - 1n),
(tce = 2n ** 104n - 1n),
(rce = 2n ** 112n - 1n),
(oce = 2n ** 120n - 1n),
(nce = 2n ** 128n - 1n),
(sce = 2n ** 136n - 1n),
(ace = 2n ** 144n - 1n),
(ice = 2n ** 152n - 1n),
(cce = 2n ** 160n - 1n),
(dce = 2n ** 168n - 1n),
(lce = 2n ** 176n - 1n),
(uce = 2n ** 184n - 1n),
(pce = 2n ** 192n - 1n),
(mce = 2n ** 200n - 1n),
(fce = 2n ** 208n - 1n),
(yce = 2n ** 216n - 1n),
(gce = 2n ** 224n - 1n),
(hce = 2n ** 232n - 1n),
(bce = 2n ** 240n - 1n),
(vce = 2n ** 248n - 1n),
(Sce = 2n ** 256n - 1n));
});
function LM(e, t, r, o) {
if (typeof e.setBigUint64 == "function") return e.setBigUint64(t, r, o);
let n = BigInt(32),
a = BigInt(4294967295),
i = Number((r >> n) & a),
c = Number(r & a),
d = o ? 4 : 0,
l = o ? 0 : 4;
(e.setUint32(t + d, i, o), e.setUint32(t + l, c, o));
}
function EP(e, t, r) {
return (e & t) ^ (~e & r);
}
function DP(e, t, r) {
return (e & t) ^ (e & r) ^ (t & r);
}
var zu,
Sn,
NP = St(() => {
Qn();
((zu = class extends fi {
constructor(t, r, o, n) {
(super(),
(this.finished = !1),
(this.length = 0),
(this.pos = 0),
(this.destroyed = !1),
(this.blockLen = t),
(this.outputLen = r),
(this.padOffset = o),
(this.isLE = n),
(this.buffer = new Uint8Array(t)),
(this.view = Ju(this.buffer)));
}
update(t) {
(yi(this), (t = jc(t)), Wt(t));
let { view: r, buffer: o, blockLen: n } = this,
a = t.length;
for (let i = 0; i < a; ) {
let c = Math.min(n - this.pos, a - i);
if (c === n) {
let d = Ju(t);
for (; n <= a - i; i += n) this.process(d, i);
continue;
}
(o.set(t.subarray(i, i + c), this.pos),
(this.pos += c),
(i += c),
this.pos === n && (this.process(r, 0), (this.pos = 0)));
}
return ((this.length += t.length), this.roundClean(), this);
}
digestInto(t) {
(yi(this), B1(t, this), (this.finished = !0));
let { buffer: r, view: o, blockLen: n, isLE: a } = this,
{ pos: i } = this;
((r[i++] = 128),
ma(this.buffer.subarray(i)),
this.padOffset > n - i && (this.process(o, 0), (i = 0)));
for (let p = i; p < n; p++) r[p] = 0;
(LM(o, n - 8, BigInt(this.length * 8), a), this.process(o, 0));
let c = Ju(t),
d = this.outputLen;
if (d % 4)
throw new Error("_sha2: outputLen should be aligned to 32bit");
let l = d / 4,
u = this.get();
if (l > u.length)
throw new Error("_sha2: outputLen bigger than state");
for (let p = 0; p < l; p++) c.setUint32(4 * p, u[p], a);
}
digest() {
let { buffer: t, outputLen: r } = this;
this.digestInto(t);
let o = t.slice(0, r);
return (this.destroy(), o);
}
_cloneInto(t) {
(t || (t = new this.constructor()), t.set(...this.get()));
let {
blockLen: r,
buffer: o,
length: n,
finished: a,
destroyed: i,
pos: c,
} = this;
return (
(t.destroyed = i),
(t.finished = a),
(t.length = n),
(t.pos = c),
n % r && t.buffer.set(o),
t
);
}
clone() {
return this._cloneInto();
}
}),
(Sn = Uint32Array.from([
1779033703, 3144134277, 1013904242, 2773480762, 1359893119,
2600822924, 528734635, 1541459225,
])));
});
var qM,
rs,
qg,
td,
BP = St(() => {
NP();
Qn();
((qM = Uint32Array.from([
1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993,
2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987,
1925078388, 2162078206, 2614888103, 3248222580, 3835390401,
4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692,
1996064986, 2554220882, 2821834349, 2952996808, 3210313671,
3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912,
1294757372, 1396182291, 1695183700, 1986661051, 2177026350,
2456956037, 2730485921, 2820302411, 3259730800, 3345764771,
3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616,
659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779,
1955562222, 2024104815, 2227730452, 2361852424, 2428436474,
2756734187, 3204031479, 3329325298,
])),
(rs = new Uint32Array(64)),
(qg = class extends zu {
constructor(t = 32) {
(super(64, t, 8, !1),
(this.A = Sn[0] | 0),
(this.B = Sn[1] | 0),
(this.C = Sn[2] | 0),
(this.D = Sn[3] | 0),
(this.E = Sn[4] | 0),
(this.F = Sn[5] | 0),
(this.G = Sn[6] | 0),
(this.H = Sn[7] | 0));
}
get() {
let { A: t, B: r, C: o, D: n, E: a, F: i, G: c, H: d } = this;
return [t, r, o, n, a, i, c, d];
}
set(t, r, o, n, a, i, c, d) {
((this.A = t | 0),
(this.B = r | 0),
(this.C = o | 0),
(this.D = n | 0),
(this.E = a | 0),
(this.F = i | 0),
(this.G = c | 0),
(this.H = d | 0));
}
process(t, r) {
for (let p = 0; p < 16; p++, r += 4) rs[p] = t.getUint32(r, !1);
for (let p = 16; p < 64; p++) {
let y = rs[p - 15],
b = rs[p - 2],
m = Xr(y, 7) ^ Xr(y, 18) ^ (y >>> 3),
v = Xr(b, 17) ^ Xr(b, 19) ^ (b >>> 10);
rs[p] = (v + rs[p - 7] + m + rs[p - 16]) | 0;
}
let { A: o, B: n, C: a, D: i, E: c, F: d, G: l, H: u } = this;
for (let p = 0; p < 64; p++) {
let y = Xr(c, 6) ^ Xr(c, 11) ^ Xr(c, 25),
b = (u + y + EP(c, d, l) + qM[p] + rs[p]) | 0,
v = ((Xr(o, 2) ^ Xr(o, 13) ^ Xr(o, 22)) + DP(o, n, a)) | 0;
((u = l),
(l = d),
(d = c),
(c = (i + b) | 0),
(i = a),
(a = n),
(n = o),
(o = (b + v) | 0));
}
((o = (o + this.A) | 0),
(n = (n + this.B) | 0),
(a = (a + this.C) | 0),
(i = (i + this.D) | 0),
(c = (c + this.E) | 0),
(d = (d + this.F) | 0),
(l = (l + this.G) | 0),
(u = (u + this.H) | 0),
this.set(o, n, a, i, c, d, l, u));
}
roundClean() {
ma(rs);
}
destroy() {
(this.set(0, 0, 0, 0, 0, 0, 0, 0), ma(this.buffer));
}
}),
(td = $1(() => new qg())));
});
var Yu,
jg,
MP = St(() => {
Qn();
((Yu = class extends fi {
constructor(t, r) {
(super(), (this.finished = !1), (this.destroyed = !1), Ku(t));
let o = jc(r);
if (
((this.iHash = t.create()),
typeof this.iHash.update != "function")
)
throw new Error(
"Expected instance of class which extends utils.Hash",
);
((this.blockLen = this.iHash.blockLen),
(this.outputLen = this.iHash.outputLen));
let n = this.blockLen,
a = new Uint8Array(n);
a.set(o.length > n ? t.create().update(o).digest() : o);
for (let i = 0; i < a.length; i++) a[i] ^= 54;
(this.iHash.update(a), (this.oHash = t.create()));
for (let i = 0; i < a.length; i++) a[i] ^= 106;
(this.oHash.update(a), ma(a));
}
update(t) {
return (yi(this), this.iHash.update(t), this);
}
digestInto(t) {
(yi(this),
Wt(t, this.outputLen),
(this.finished = !0),
this.iHash.digestInto(t),
this.oHash.update(t),
this.oHash.digestInto(t),
this.destroy());
}
digest() {
let t = new Uint8Array(this.oHash.outputLen);
return (this.digestInto(t), t);
}
_cloneInto(t) {
t || (t = Object.create(Object.getPrototypeOf(this), {}));
let {
oHash: r,
iHash: o,
finished: n,
destroyed: a,
blockLen: i,
outputLen: c,
} = this;
return (
(t = t),
(t.finished = n),
(t.destroyed = a),
(t.blockLen = i),
(t.outputLen = c),
(t.oHash = r._cloneInto(t.oHash)),
(t.iHash = o._cloneInto(t.iHash)),
t
);
}
clone() {
return this._cloneInto();
}
destroy() {
((this.destroyed = !0), this.oHash.destroy(), this.iHash.destroy());
}
}),
(jg = (e, t, r) => new Yu(e, t).update(r).digest()));
jg.create = (e, t) => new Yu(e, t);
});
function Lt(e, t) {
let r = e % t;
return r >= qt ? r : t + r;
}
function pr(e, t, r) {
let o = e;
for (; t-- > qt; ) ((o *= o), (o %= r));
return o;
}
function $P(e, t) {
if (e === qt) throw new Error("invert: expected non-zero number");
if (t <= qt)
throw new Error("invert: expected positive modulus, got " + t);
let r = Lt(e, t),
o = t,
n = qt,
a = Bt,
i = Bt,
c = qt;
for (; r !== qt; ) {
let l = o / r,
u = o % r,
p = n - i * l,
y = a - c * l;
((o = r), (r = u), (n = i), (a = c), (i = p), (c = y));
}
if (o !== Bt) throw new Error("invert: does not exist");
return Lt(n, t);
}
function Gg(e, t, r) {
if (!e.eql(e.sqr(t), r)) throw new Error("Cannot find square root");
}
function WP(e, t) {
let r = (e.ORDER + Bt) / KP,
o = e.pow(t, r);
return (Gg(e, o, t), o);
}
function QM(e, t) {
let r = (e.ORDER - JP) / VP,
o = e.mul(t, ha),
n = e.pow(o, r),
a = e.mul(t, n),
i = e.mul(e.mul(a, ha), n),
c = e.mul(a, e.sub(i, e.ONE));
return (Gg(e, c, t), c);
}
function zM(e) {
let t = os(e),
r = LP(e),
o = r(t, t.neg(t.ONE)),
n = r(t, o),
a = r(t, t.neg(o)),
i = (e + jM) / HP;
return (c, d) => {
let l = c.pow(d, i),
u = c.mul(l, o),
p = c.mul(l, n),
y = c.mul(l, a),
b = c.eql(c.sqr(u), d),
m = c.eql(c.sqr(p), d);
((l = c.cmov(l, u, b)), (u = c.cmov(y, p, m)));
let v = c.eql(c.sqr(u), d),
h = c.cmov(l, u, v);
return (Gg(c, h, d), h);
};
}
function LP(e) {
if (e < FP) throw new Error("sqrt is not defined for small field");
let t = e - Bt,
r = 0;
for (; t % ha === qt; ) ((t /= ha), r++);
let o = ha,
n = os(e);
for (; _P(n, o) === 1; )
if (o++ > 1e3)
throw new Error("Cannot find square root: probably non-prime P");
if (r === 1) return WP;
let a = n.pow(o, t),
i = (t + Bt) / ha;
return function (d, l) {
if (d.is0(l)) return l;
if (_P(d, l) !== 1) throw new Error("Cannot find square root");
let u = r,
p = d.mul(d.ONE, a),
y = d.pow(l, t),
b = d.pow(l, i);
for (; !d.eql(y, d.ONE); ) {
if (d.is0(y)) return d.ZERO;
let m = 1,
v = d.sqr(y);
for (; !d.eql(v, d.ONE); )
if ((m++, (v = d.sqr(v)), m === u))
throw new Error("Cannot find square root");
let h = Bt << BigInt(u - m - 1),
g = d.pow(p, h);
((u = m), (p = d.sqr(g)), (y = d.mul(y, p)), (b = d.mul(b, g)));
}
return b;
};
}
function YM(e) {
return e % KP === FP
? WP
: e % VP === JP
? QM
: e % HP === GM
? zM(e)
: LP(e);
}
function Zu(e) {
let t = {
ORDER: "bigint",
MASK: "bigint",
BYTES: "number",
BITS: "number",
},
r = ZM.reduce((o, n) => ((o[n] = "function"), o), t);
return (ga(e, r), e);
}
function XM(e, t, r) {
if (r < qt) throw new Error("invalid exponent, negatives unsupported");
if (r === qt) return e.ONE;
if (r === Bt) return t;
let o = e.ONE,
n = t;
for (; r > qt; )
(r & Bt && (o = e.mul(o, n)), (n = e.sqr(n)), (r >>= Bt));
return o;
}
function ba(e, t, r = !1) {
let o = new Array(t.length).fill(r ? e.ZERO : void 0),
n = t.reduce(
(i, c, d) => (e.is0(c) ? i : ((o[d] = i), e.mul(i, c))),
e.ONE,
),
a = e.inv(n);
return (
t.reduceRight(
(i, c, d) => (e.is0(c) ? i : ((o[d] = e.mul(i, o[d])), e.mul(i, c))),
a,
),
o
);
}
function _P(e, t) {
let r = (e.ORDER - Bt) / ha,
o = e.pow(t, r),
n = e.eql(o, e.ONE),
a = e.eql(o, e.ZERO),
i = e.eql(o, e.neg(e.ONE));
if (!n && !a && !i) throw new Error("invalid Legendre symbol result");
return n ? 1 : a ? 0 : -1;
}
function Xu(e, t) {
t !== void 0 && qc(t);
let r = t !== void 0 ? t : e.toString(2).length,
o = Math.ceil(r / 8);
return { nBitLength: r, nByteLength: o };
}
function os(e, t, r = !1, o = {}) {
if (e <= qt)
throw new Error("invalid field: expected ORDER > 0, got " + e);
let n,
a,
i = !1,
c;
if (typeof t == "object" && t != null) {
if (o.sqrt || r)
throw new Error("cannot specify opts in two arguments");
let y = t;
(y.BITS && (n = y.BITS),
y.sqrt && (a = y.sqrt),
typeof y.isLE == "boolean" && (r = y.isLE),
typeof y.modFromBytes == "boolean" && (i = y.modFromBytes),
(c = y.allowedLengths));
} else (typeof t == "number" && (n = t), o.sqrt && (a = o.sqrt));
let { nBitLength: d, nByteLength: l } = Xu(e, n);
if (l > 2048)
throw new Error("invalid field: expected ORDER of <= 2048 bytes");
let u,
p = Object.freeze({
ORDER: e,
isLE: r,
BITS: d,
BYTES: l,
MASK: Yn(d),
ZERO: qt,
ONE: Bt,
allowedLengths: c,
create: (y) => Lt(y, e),
isValid: (y) => {
if (typeof y != "bigint")
throw new Error(
"invalid field element: expected bigint, got " + typeof y,
);
return qt <= y && y < e;
},
is0: (y) => y === qt,
isValidNot0: (y) => !p.is0(y) && p.isValid(y),
isOdd: (y) => (y & Bt) === Bt,
neg: (y) => Lt(-y, e),
eql: (y, b) => y === b,
sqr: (y) => Lt(y * y, e),
add: (y, b) => Lt(y + b, e),
sub: (y, b) => Lt(y - b, e),
mul: (y, b) => Lt(y * b, e),
pow: (y, b) => XM(p, y, b),
div: (y, b) => Lt(y * $P(b, e), e),
sqrN: (y) => y * y,
addN: (y, b) => y + b,
subN: (y, b) => y - b,
mulN: (y, b) => y * b,
inv: (y) => $P(y, e),
sqrt: a || ((y) => (u || (u = YM(e)), u(p, y))),
toBytes: (y) => (r ? Ng(y, l) : gi(y, l)),
fromBytes: (y, b = !0) => {
if (c) {
if (!c.includes(y.length) || y.length > l)
throw new Error(
"Field.fromBytes: expected " + c + " bytes, got " + y.length,
);
let v = new Uint8Array(l);
(v.set(y, r ? 0 : v.length - y.length), (y = v));
}
if (y.length !== l)
throw new Error(
"Field.fromBytes: expected " + l + " bytes, got " + y.length,
);
let m = r ? Dg(y) : eo(y);
if ((i && (m = Lt(m, e)), !b && !p.isValid(m)))
throw new Error(
"invalid field element: outside of range 0..ORDER",
);
return m;
},
invertBatch: (y) => ba(p, y),
cmov: (y, b, m) => (m ? b : y),
});
return Object.freeze(p);
}
function qP(e) {
if (typeof e != "bigint") throw new Error("field order must be bigint");
let t = e.toString(2).length;
return Math.ceil(t / 8);
}
function Qg(e) {
let t = qP(e);
return t + Math.ceil(t / 2);
}
function ep(e, t, r = !1) {
let o = e.length,
n = qP(t),
a = Qg(t);
if (o < 16 || o < a || o > 1024)
throw new Error("expected " + a + "-1024 bytes of input, got " + o);
let i = r ? Dg(e) : eo(e),
c = Lt(i, t - Bt) + Bt;
return r ? Ng(c, n) : gi(c, n);
}
var qt,
Bt,
ha,
FP,
KP,
JP,
jM,
VP,
GM,
HP,
ZM,
rd = St(() => {
hi();
((qt = BigInt(0)),
(Bt = BigInt(1)),
(ha = BigInt(2)),
(FP = BigInt(3)),
(KP = BigInt(4)),
(JP = BigInt(5)),
(jM = BigInt(7)),
(VP = BigInt(8)),
(GM = BigInt(9)),
(HP = BigInt(16)));
ZM = [
"create",
"isValid",
"is0",
"neg",
"inv",
"sqrt",
"sqr",
"eql",
"add",
"sub",
"mul",
"pow",
"div",
"addN",
"subN",
"mulN",
"sqrN",
];
});
function od(e, t) {
let r = t.negate();
return e ? r : t;
}
function rp(e, t) {
let r = ba(
e.Fp,
t.map((o) => o.Z),
);
return t.map((o, n) => e.fromAffine(o.toAffine(r[n])));
}
function zP(e, t) {
if (!Number.isSafeInteger(e) || e <= 0 || e > t)
throw new Error(
"invalid window size, expected [1.." + t + "], got W=" + e,
);
}
function zg(e, t) {
zP(e, t);
let r = Math.ceil(t / e) + 1,
o = 2 ** (e - 1),
n = 2 ** e,
a = Yn(e),
i = BigInt(e);
return { windows: r, windowSize: o, mask: a, maxNumber: n, shiftBy: i };
}
function jP(e, t, r) {
let { windowSize: o, mask: n, maxNumber: a, shiftBy: i } = r,
c = Number(e & n),
d = e >> i;
c > o && ((c -= a), (d += va));
let l = t * o,
u = l + Math.abs(c) - 1,
p = c === 0,
y = c < 0,
b = t % 2 !== 0;
return {
nextN: d,
offset: u,
isZero: p,
isNeg: y,
isNegF: b,
offsetF: l,
};
}
function e$(e, t) {
if (!Array.isArray(e)) throw new Error("array expected");
e.forEach((r, o) => {
if (!(r instanceof t)) throw new Error("invalid point at index " + o);
});
}
function t$(e, t) {
if (!Array.isArray(e)) throw new Error("array of scalars expected");
e.forEach((r, o) => {
if (!t.isValid(r)) throw new Error("invalid scalar at index " + o);
});
}
function Zg(e) {
return YP.get(e) || 1;
}
function GP(e) {
if (e !== Ai) throw new Error("invalid wNAF");
}
function ZP(e, t, r, o) {
let n = t,
a = e.ZERO,
i = e.ZERO;
for (; r > Ai || o > Ai; )
(r & va && (a = a.add(n)),
o & va && (i = i.add(n)),
(n = n.double()),
(r >>= va),
(o >>= va));
return { p1: a, p2: i };
}
function XP(e, t, r, o) {
(e$(r, e), t$(o, t));
let n = r.length,
a = o.length;
if (n !== a)
throw new Error("arrays of points and scalars must have equal length");
let i = e.ZERO,
c = Vu(BigInt(n)),
d = 1;
c > 12 ? (d = c - 3) : c > 4 ? (d = c - 2) : c > 0 && (d = 2);
let l = Yn(d),
u = new Array(Number(l) + 1).fill(i),
p = Math.floor((t.BITS - 1) / d) * d,
y = i;
for (let b = p; b >= 0; b -= d) {
u.fill(i);
for (let v = 0; v < a; v++) {
let h = o[v],
g = Number((h >> BigInt(b)) & l);
u[g] = u[g].add(r[v]);
}
let m = i;
for (let v = u.length - 1, h = i; v > 0; v--)
((h = h.add(u[v])), (m = m.add(h)));
if (((y = y.add(m)), b !== 0))
for (let v = 0; v < d; v++) y = y.double();
}
return y;
}
function QP(e, t, r) {
if (t) {
if (t.ORDER !== e)
throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
return (Zu(t), t);
} else return os(e, { isLE: r });
}
function ek(e, t, r = {}, o) {
if ((o === void 0 && (o = e === "edwards"), !t || typeof t != "object"))
throw new Error(`expected valid ${e} CURVE object`);
for (let d of ["p", "n", "h"]) {
let l = t[d];
if (!(typeof l == "bigint" && l > Ai))
throw new Error(`CURVE.${d} must be positive bigint`);
}
let n = QP(t.p, r.Fp, o),
a = QP(t.n, r.Fn, o),
c = ["Gx", "Gy", "a", e === "weierstrass" ? "b" : "d"];
for (let d of c)
if (!n.isValid(t[d]))
throw new Error(`CURVE.${d} must be valid field element of CURVE.Fp`);
return (
(t = Object.freeze(Object.assign({}, t))),
{ CURVE: t, Fp: n, Fn: a }
);
}
var Ai,
va,
Yg,
YP,
tp,
tk = St(() => {
hi();
rd();
((Ai = BigInt(0)), (va = BigInt(1)));
((Yg = new WeakMap()), (YP = new WeakMap()));
tp = class {
constructor(t, r) {
((this.BASE = t.BASE),
(this.ZERO = t.ZERO),
(this.Fn = t.Fn),
(this.bits = r));
}
_unsafeLadder(t, r, o = this.ZERO) {
let n = t;
for (; r > Ai; )
(r & va && (o = o.add(n)), (n = n.double()), (r >>= va));
return o;
}
precomputeWindow(t, r) {
let { windows: o, windowSize: n } = zg(r, this.bits),
a = [],
i = t,
c = i;
for (let d = 0; d < o; d++) {
((c = i), a.push(c));
for (let l = 1; l < n; l++) ((c = c.add(i)), a.push(c));
i = c.double();
}
return a;
}
wNAF(t, r, o) {
if (!this.Fn.isValid(o)) throw new Error("invalid scalar");
let n = this.ZERO,
a = this.BASE,
i = zg(t, this.bits);
for (let c = 0; c < i.windows; c++) {
let {
nextN: d,
offset: l,
isZero: u,
isNeg: p,
isNegF: y,
offsetF: b,
} = jP(o, c, i);
((o = d),
u ? (a = a.add(od(y, r[b]))) : (n = n.add(od(p, r[l]))));
}
return (GP(o), { p: n, f: a });
}
wNAFUnsafe(t, r, o, n = this.ZERO) {
let a = zg(t, this.bits);
for (let i = 0; i < a.windows && o !== Ai; i++) {
let { nextN: c, offset: d, isZero: l, isNeg: u } = jP(o, i, a);
if (((o = c), !l)) {
let p = r[d];
n = n.add(u ? p.negate() : p);
}
}
return (GP(o), n);
}
getPrecomputes(t, r, o) {
let n = Yg.get(r);
return (
n ||
((n = this.precomputeWindow(r, t)),
t !== 1 &&
(typeof o == "function" && (n = o(n)), Yg.set(r, n))),
n
);
}
cached(t, r, o) {
let n = Zg(t);
return this.wNAF(n, this.getPrecomputes(n, t, o), r);
}
unsafe(t, r, o, n) {
let a = Zg(t);
return a === 1
? this._unsafeLadder(t, r, n)
: this.wNAFUnsafe(a, this.getPrecomputes(a, t, o), r, n);
}
createCache(t, r) {
(zP(r, this.bits), YP.set(t, r), Yg.delete(t));
}
hasCache(t) {
return Zg(t) !== 1;
}
};
});
function r$(e, t, r) {
let [[o, n], [a, i]] = t,
c = rk(i * e, r),
d = rk(-n * e, r),
l = e - c * o - d * a,
u = -c * n - d * i,
p = l < no,
y = u < no;
(p && (l = -l), y && (u = -u));
let b = Yn(Math.ceil(Vu(r) / 2)) + Mt;
if (l < no || l >= b || u < no || u >= b)
throw new Error("splitScalar (endomorphism): failed, k=" + e);
return { k1neg: p, k1: l, k2neg: y, k2: u };
}
function eh(e) {
if (!["compact", "recovered", "der"].includes(e))
throw new Error(
'Signature format must be "compact", "recovered", or "der"',
);
return e;
}
function Xg(e, t) {
let r = {};
for (let o of Object.keys(t)) r[o] = e[o] === void 0 ? t[o] : e[o];
return (
Gc(r.lowS, "lowS"),
Gc(r.prehash, "prehash"),
r.format !== void 0 && eh(r.format),
r
);
}
function ns(e, t) {
let { BYTES: r } = e,
o;
if (typeof t == "bigint") o = t;
else {
let n = it("private key", t);
try {
o = e.fromBytes(n);
} catch {
throw new Error(
`invalid private key: expected ui8a of size ${r}, got ${typeof t}`,
);
}
}
if (!e.isValidNot0(o))
throw new Error("invalid private key: out of range [1..N-1]");
return o;
}
function o$(e, t = {}) {
let r = ek("weierstrass", e, t),
{ Fp: o, Fn: n } = r,
a = r.CURVE,
{ h: i, n: c } = a;
ga(
t,
{},
{
allowInfinityPoint: "boolean",
clearCofactor: "function",
isTorsionFree: "function",
fromBytes: "function",
toBytes: "function",
endo: "object",
wrapPrivateKey: "boolean",
},
);
let { endo: d } = t;
if (
d &&
(!o.is0(a.a) || typeof d.beta != "bigint" || !Array.isArray(d.basises))
)
throw new Error(
'invalid endo: expected "beta": bigint and "basises": array',
);
let l = sk(o, n);
function u() {
if (!o.isOdd)
throw new Error(
"compression is not supported: Field does not have .isOdd()",
);
}
function p(_, T, R) {
let { x: N, y: F } = T.toAffine(),
H = o.toBytes(N);
if ((Gc(R, "isCompressed"), R)) {
u();
let q = !o.isOdd(F);
return ut(ok(q), H);
} else return ut(Uint8Array.of(4), H, o.toBytes(F));
}
function y(_) {
zn(_, void 0, "Point");
let { publicKey: T, publicKeyUncompressed: R } = l,
N = _.length,
F = _[0],
H = _.subarray(1);
if (N === T && (F === 2 || F === 3)) {
let q = o.fromBytes(H);
if (!o.isValid(q))
throw new Error("bad point: is not on curve, wrong x");
let ne = v(q),
ee;
try {
ee = o.sqrt(ne);
} catch (W) {
let Y = W instanceof Error ? ": " + W.message : "";
throw new Error("bad point: is not on curve, sqrt error" + Y);
}
u();
let Q = o.isOdd(ee);
return (((F & 1) === 1) !== Q && (ee = o.neg(ee)), { x: q, y: ee });
} else if (N === R && F === 4) {
let q = o.BYTES,
ne = o.fromBytes(H.subarray(0, q)),
ee = o.fromBytes(H.subarray(q, q * 2));
if (!h(ne, ee)) throw new Error("bad point: is not on curve");
return { x: ne, y: ee };
} else
throw new Error(
`bad point: got length ${N}, expected compressed=${T} or uncompressed=${R}`,
);
}
let b = t.toBytes || p,
m = t.fromBytes || y;
function v(_) {
let T = o.sqr(_),
R = o.mul(T, _);
return o.add(o.add(R, o.mul(_, a.a)), a.b);
}
function h(_, T) {
let R = o.sqr(T),
N = v(_);
return o.eql(R, N);
}
if (!h(a.Gx, a.Gy)) throw new Error("bad curve params: generator point");
let g = o.mul(o.pow(a.a, wi), rh),
S = o.mul(o.sqr(a.b), BigInt(27));
if (o.is0(o.add(g, S))) throw new Error("bad curve params: a or b");
function w(_, T, R = !1) {
if (!o.isValid(T) || (R && o.is0(T)))
throw new Error(`bad point coordinate ${_}`);
return T;
}
function I(_) {
if (!(_ instanceof k)) throw new Error("ProjectivePoint expected");
}
function E(_) {
if (!d || !d.basises) throw new Error("no endo");
return r$(_, d.basises, n.ORDER);
}
let K = Bg((_, T) => {
let { X: R, Y: N, Z: F } = _;
if (o.eql(F, o.ONE)) return { x: R, y: N };
let H = _.is0();
T == null && (T = H ? o.ONE : o.inv(F));
let q = o.mul(R, T),
ne = o.mul(N, T),
ee = o.mul(F, T);
if (H) return { x: o.ZERO, y: o.ZERO };
if (!o.eql(ee, o.ONE)) throw new Error("invZ was invalid");
return { x: q, y: ne };
}),
J = Bg((_) => {
if (_.is0()) {
if (t.allowInfinityPoint && !o.is0(_.Y)) return;
throw new Error("bad point: ZERO");
}
let { x: T, y: R } = _.toAffine();
if (!o.isValid(T) || !o.isValid(R))
throw new Error("bad point: x or y not field elements");
if (!h(T, R)) throw new Error("bad point: equation left != right");
if (!_.isTorsionFree())
throw new Error("bad point: not in prime-order subgroup");
return !0;
});
function P(_, T, R, N, F) {
return (
(R = new k(o.mul(R.X, _), R.Y, R.Z)),
(T = od(N, T)),
(R = od(F, R)),
T.add(R)
);
}
class k {
constructor(T, R, N) {
((this.X = w("x", T)),
(this.Y = w("y", R, !0)),
(this.Z = w("z", N)),
Object.freeze(this));
}
static CURVE() {
return a;
}
static fromAffine(T) {
let { x: R, y: N } = T || {};
if (!T || !o.isValid(R) || !o.isValid(N))
throw new Error("invalid affine point");
if (T instanceof k) throw new Error("projective point not allowed");
return o.is0(R) && o.is0(N) ? k.ZERO : new k(R, N, o.ONE);
}
static fromBytes(T) {
let R = k.fromAffine(m(zn(T, void 0, "point")));
return (R.assertValidity(), R);
}
static fromHex(T) {
return k.fromBytes(it("pointHex", T));
}
get x() {
return this.toAffine().x;
}
get y() {
return this.toAffine().y;
}
precompute(T = 8, R = !0) {
return (D.createCache(this, T), R || this.multiply(wi), this);
}
assertValidity() {
J(this);
}
hasEvenY() {
let { y: T } = this.toAffine();
if (!o.isOdd) throw new Error("Field doesn't support isOdd");
return !o.isOdd(T);
}
equals(T) {
I(T);
let { X: R, Y: N, Z: F } = this,
{ X: H, Y: q, Z: ne } = T,
ee = o.eql(o.mul(R, ne), o.mul(H, F)),
Q = o.eql(o.mul(N, ne), o.mul(q, F));
return ee && Q;
}
negate() {
return new k(this.X, o.neg(this.Y), this.Z);
}
double() {
let { a: T, b: R } = a,
N = o.mul(R, wi),
{ X: F, Y: H, Z: q } = this,
ne = o.ZERO,
ee = o.ZERO,
Q = o.ZERO,
L = o.mul(F, F),
W = o.mul(H, H),
Y = o.mul(q, q),
j = o.mul(F, H);
return (
(j = o.add(j, j)),
(Q = o.mul(F, q)),
(Q = o.add(Q, Q)),
(ne = o.mul(T, Q)),
(ee = o.mul(N, Y)),
(ee = o.add(ne, ee)),
(ne = o.sub(W, ee)),
(ee = o.add(W, ee)),
(ee = o.mul(ne, ee)),
(ne = o.mul(j, ne)),
(Q = o.mul(N, Q)),
(Y = o.mul(T, Y)),
(j = o.sub(L, Y)),
(j = o.mul(T, j)),
(j = o.add(j, Q)),
(Q = o.add(L, L)),
(L = o.add(Q, L)),
(L = o.add(L, Y)),
(L = o.mul(L, j)),
(ee = o.add(ee, L)),
(Y = o.mul(H, q)),
(Y = o.add(Y, Y)),
(L = o.mul(Y, j)),
(ne = o.sub(ne, L)),
(Q = o.mul(Y, W)),
(Q = o.add(Q, Q)),
(Q = o.add(Q, Q)),
new k(ne, ee, Q)
);
}
add(T) {
I(T);
let { X: R, Y: N, Z: F } = this,
{ X: H, Y: q, Z: ne } = T,
ee = o.ZERO,
Q = o.ZERO,
L = o.ZERO,
W = a.a,
Y = o.mul(a.b, wi),
j = o.mul(R, H),
X = o.mul(N, q),
z = o.mul(F, ne),
te = o.add(R, N),
oe = o.add(H, q);
((te = o.mul(te, oe)),
(oe = o.add(j, X)),
(te = o.sub(te, oe)),
(oe = o.add(R, F)));
let ie = o.add(H, ne);
return (
(oe = o.mul(oe, ie)),
(ie = o.add(j, z)),
(oe = o.sub(oe, ie)),
(ie = o.add(N, F)),
(ee = o.add(q, ne)),
(ie = o.mul(ie, ee)),
(ee = o.add(X, z)),
(ie = o.sub(ie, ee)),
(L = o.mul(W, oe)),
(ee = o.mul(Y, z)),
(L = o.add(ee, L)),
(ee = o.sub(X, L)),
(L = o.add(X, L)),
(Q = o.mul(ee, L)),
(X = o.add(j, j)),
(X = o.add(X, j)),
(z = o.mul(W, z)),
(oe = o.mul(Y, oe)),
(X = o.add(X, z)),
(z = o.sub(j, z)),
(z = o.mul(W, z)),
(oe = o.add(oe, z)),
(j = o.mul(X, oe)),
(Q = o.add(Q, j)),
(j = o.mul(ie, oe)),
(ee = o.mul(te, ee)),
(ee = o.sub(ee, j)),
(j = o.mul(te, X)),
(L = o.mul(ie, L)),
(L = o.add(L, j)),
new k(ee, Q, L)
);
}
subtract(T) {
return this.add(T.negate());
}
is0() {
return this.equals(k.ZERO);
}
multiply(T) {
let { endo: R } = t;
if (!n.isValidNot0(T))
throw new Error("invalid scalar: out of range");
let N,
F,
H = (q) => D.cached(this, q, (ne) => rp(k, ne));
if (R) {
let { k1neg: q, k1: ne, k2neg: ee, k2: Q } = E(T),
{ p: L, f: W } = H(ne),
{ p: Y, f: j } = H(Q);
((F = W.add(j)), (N = P(R.beta, L, Y, q, ee)));
} else {
let { p: q, f: ne } = H(T);
((N = q), (F = ne));
}
return rp(k, [N, F])[0];
}
multiplyUnsafe(T) {
let { endo: R } = t,
N = this;
if (!n.isValid(T)) throw new Error("invalid scalar: out of range");
if (T === no || N.is0()) return k.ZERO;
if (T === Mt) return N;
if (D.hasCache(this)) return this.multiply(T);
if (R) {
let { k1neg: F, k1: H, k2neg: q, k2: ne } = E(T),
{ p1: ee, p2: Q } = ZP(k, N, H, ne);
return P(R.beta, ee, Q, F, q);
} else return D.unsafe(N, T);
}
multiplyAndAddUnsafe(T, R, N) {
let F = this.multiplyUnsafe(R).add(T.multiplyUnsafe(N));
return F.is0() ? void 0 : F;
}
toAffine(T) {
return K(this, T);
}
isTorsionFree() {
let { isTorsionFree: T } = t;
return i === Mt ? !0 : T ? T(k, this) : D.unsafe(this, c).is0();
}
clearCofactor() {
let { clearCofactor: T } = t;
return i === Mt ? this : T ? T(k, this) : this.multiplyUnsafe(i);
}
isSmallOrder() {
return this.multiplyUnsafe(i).is0();
}
toBytes(T = !0) {
return (Gc(T, "isCompressed"), this.assertValidity(), b(k, this, T));
}
toHex(T = !0) {
return gn(this.toBytes(T));
}
toString() {
return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
}
get px() {
return this.X;
}
get py() {
return this.X;
}
get pz() {
return this.Z;
}
toRawBytes(T = !0) {
return this.toBytes(T);
}
_setWindowSize(T) {
this.precompute(T);
}
static normalizeZ(T) {
return rp(k, T);
}
static msm(T, R) {
return XP(k, n, T, R);
}
static fromPrivateKey(T) {
return k.BASE.multiply(ns(n, T));
}
}
((k.BASE = new k(a.Gx, a.Gy, o.ONE)),
(k.ZERO = new k(o.ZERO, o.ONE, o.ZERO)),
(k.Fp = o),
(k.Fn = n));
let U = n.BITS,
D = new tp(k, t.endo ? Math.ceil(U / 2) : U);
return (k.BASE.precompute(8), k);
}
function ok(e) {
return Uint8Array.of(e ? 2 : 3);
}
function n$(e, t) {
let r = e.ORDER,
o = no;
for (let m = r - Mt; m % Ko === no; m /= Ko) o += Mt;
let n = o,
a = Ko << (n - Mt - Mt),
i = a * Ko,
c = (r - Mt) / i,
d = (c - Mt) / Ko,
l = i - Mt,
u = a,
p = e.pow(t, c),
y = e.pow(t, (c + Mt) / Ko),
b = (m, v) => {
let h = p,
g = e.pow(v, l),
S = e.sqr(g);
S = e.mul(S, v);
let w = e.mul(m, S);
((w = e.pow(w, d)),
(w = e.mul(w, g)),
(g = e.mul(w, v)),
(S = e.mul(w, m)));
let I = e.mul(S, g);
w = e.pow(I, u);
let E = e.eql(w, e.ONE);
((g = e.mul(S, y)),
(w = e.mul(I, h)),
(S = e.cmov(g, S, E)),
(I = e.cmov(w, I, E)));
for (let K = n; K > Mt; K--) {
let J = K - Ko;
J = Ko << (J - Mt);
let P = e.pow(I, J),
k = e.eql(P, e.ONE);
((g = e.mul(S, h)),
(h = e.mul(h, h)),
(P = e.mul(I, h)),
(S = e.cmov(g, S, k)),
(I = e.cmov(P, I, k)));
}
return { isValid: E, value: S };
};
if (e.ORDER % rh === wi) {
let m = (e.ORDER - wi) / rh,
v = e.sqrt(e.neg(t));
b = (h, g) => {
let S = e.sqr(g),
w = e.mul(h, g);
S = e.mul(S, w);
let I = e.pow(S, m);
I = e.mul(I, w);
let E = e.mul(I, v),
K = e.mul(e.sqr(I), g),
J = e.eql(K, h),
P = e.cmov(E, I, J);
return { isValid: J, value: P };
};
}
return b;
}
function nk(e, t) {
Zu(e);
let { A: r, B: o, Z: n } = t;
if (!e.isValid(r) || !e.isValid(o) || !e.isValid(n))
throw new Error("mapToCurveSimpleSWU: invalid opts");
let a = n$(e, n);
if (!e.isOdd) throw new Error("Field does not have .isOdd()");
return (i) => {
let c, d, l, u, p, y, b, m;
((c = e.sqr(i)),
(c = e.mul(c, n)),
(d = e.sqr(c)),
(d = e.add(d, c)),
(l = e.add(d, e.ONE)),
(l = e.mul(l, o)),
(u = e.cmov(n, e.neg(d), !e.eql(d, e.ZERO))),
(u = e.mul(u, r)),
(d = e.sqr(l)),
(y = e.sqr(u)),
(p = e.mul(y, r)),
(d = e.add(d, p)),
(d = e.mul(d, l)),
(y = e.mul(y, u)),
(p = e.mul(y, o)),
(d = e.add(d, p)),
(b = e.mul(c, l)));
let { isValid: v, value: h } = a(d, y);
((m = e.mul(c, i)),
(m = e.mul(m, h)),
(b = e.cmov(b, l, v)),
(m = e.cmov(m, h, v)));
let g = e.isOdd(i) === e.isOdd(m);
m = e.cmov(e.neg(m), m, g);
let S = ba(e, [u], !0)[0];
return ((b = e.mul(b, S)), { x: b, y: m });
};
}
function sk(e, t) {
return {
secretKey: t.BYTES,
publicKey: 1 + e.BYTES,
publicKeyUncompressed: 1 + 2 * e.BYTES,
publicKeyHasPrefix: !0,
signature: 2 * t.BYTES,
};
}
function s$(e, t = {}) {
let { Fn: r } = e,
o = t.randomBytes || ya,
n = Object.assign(sk(e.Fp, r), { seed: Qg(r.ORDER) });
function a(b) {
try {
return !!ns(r, b);
} catch {
return !1;
}
}
function i(b, m) {
let { publicKey: v, publicKeyUncompressed: h } = n;
try {
let g = b.length;
return (m === !0 && g !== v) || (m === !1 && g !== h)
? !1
: !!e.fromBytes(b);
} catch {
return !1;
}
}
function c(b = o(n.seed)) {
return ep(zn(b, n.seed, "seed"), r.ORDER);
}
function d(b, m = !0) {
return e.BASE.multiply(ns(r, b)).toBytes(m);
}
function l(b) {
let m = c(b);
return { secretKey: m, publicKey: d(m) };
}
function u(b) {
if (typeof b == "bigint") return !1;
if (b instanceof e) return !0;
let { secretKey: m, publicKey: v, publicKeyUncompressed: h } = n;
if (r.allowedLengths || m === v) return;
let g = it("key", b).length;
return g === v || g === h;
}
function p(b, m, v = !0) {
if (u(b) === !0) throw new Error("first arg must be private key");
if (u(m) === !1) throw new Error("second arg must be public key");
let h = ns(r, b);
return e.fromHex(m).multiply(h).toBytes(v);
}
return Object.freeze({
getPublicKey: d,
getSharedSecret: p,
keygen: l,
Point: e,
utils: {
isValidSecretKey: a,
isValidPublicKey: i,
randomSecretKey: c,
isValidPrivateKey: a,
randomPrivateKey: c,
normPrivateKeyToScalar: (b) => ns(r, b),
precompute(b = 8, m = e.BASE) {
return m.precompute(b, !1);
},
},
lengths: n,
});
}
function a$(e, t, r = {}) {
(Ku(t),
ga(
r,
{},
{
hmac: "function",
lowS: "boolean",
randomBytes: "function",
bits2int: "function",
bits2int_modN: "function",
},
));
let o = r.randomBytes || ya,
n = r.hmac || ((R, ...N) => jg(t, R, ut(...N))),
{ Fp: a, Fn: i } = e,
{ ORDER: c, BITS: d } = i,
{
keygen: l,
getPublicKey: u,
getSharedSecret: p,
utils: y,
lengths: b,
} = s$(e, r),
m = {
prehash: !1,
lowS: typeof r.lowS == "boolean" ? r.lowS : !1,
format: void 0,
extraEntropy: !1,
},
v = "compact";
function h(R) {
let N = c >> Mt;
return R > N;
}
function g(R, N) {
if (!i.isValidNot0(N))
throw new Error(
`invalid signature ${R}: out of range 1..Point.Fn.ORDER`,
);
return N;
}
function S(R, N) {
eh(N);
let F = b.signature,
H = N === "compact" ? F : N === "recovered" ? F + 1 : void 0;
return zn(R, H, `${N} signature`);
}
class w {
constructor(N, F, H) {
((this.r = g("r", N)),
(this.s = g("s", F)),
H != null && (this.recovery = H),
Object.freeze(this));
}
static fromBytes(N, F = v) {
S(N, F);
let H;
if (F === "der") {
let { r: Q, s: L } = xn.toSig(zn(N));
return new w(Q, L);
}
F === "recovered" &&
((H = N[0]), (F = "compact"), (N = N.subarray(1)));
let q = i.BYTES,
ne = N.subarray(0, q),
ee = N.subarray(q, q * 2);
return new w(i.fromBytes(ne), i.fromBytes(ee), H);
}
static fromHex(N, F) {
return this.fromBytes(fa(N), F);
}
addRecoveryBit(N) {
return new w(this.r, this.s, N);
}
recoverPublicKey(N) {
let F = a.ORDER,
{ r: H, s: q, recovery: ne } = this;
if (ne == null || ![0, 1, 2, 3].includes(ne))
throw new Error("recovery id invalid");
if (c * Ko < F && ne > 1)
throw new Error("recovery id is ambiguous for h>1 curve");
let Q = ne === 2 || ne === 3 ? H + c : H;
if (!a.isValid(Q)) throw new Error("recovery id 2 or 3 invalid");
let L = a.toBytes(Q),
W = e.fromBytes(ut(ok((ne & 1) === 0), L)),
Y = i.inv(Q),
j = E(it("msgHash", N)),
X = i.create(-j * Y),
z = i.create(q * Y),
te = e.BASE.multiplyUnsafe(X).add(W.multiplyUnsafe(z));
if (te.is0()) throw new Error("point at infinify");
return (te.assertValidity(), te);
}
hasHighS() {
return h(this.s);
}
toBytes(N = v) {
if ((eh(N), N === "der")) return fa(xn.hexFromSig(this));
let F = i.toBytes(this.r),
H = i.toBytes(this.s);
if (N === "recovered") {
if (this.recovery == null)
throw new Error("recovery bit must be present");
return ut(Uint8Array.of(this.recovery), F, H);
}
return ut(F, H);
}
toHex(N) {
return gn(this.toBytes(N));
}
assertValidity() {}
static fromCompact(N) {
return w.fromBytes(it("sig", N), "compact");
}
static fromDER(N) {
return w.fromBytes(it("sig", N), "der");
}
normalizeS() {
return this.hasHighS()
? new w(this.r, i.neg(this.s), this.recovery)
: this;
}
toDERRawBytes() {
return this.toBytes("der");
}
toDERHex() {
return gn(this.toBytes("der"));
}
toCompactRawBytes() {
return this.toBytes("compact");
}
toCompactHex() {
return gn(this.toBytes("compact"));
}
}
let I =
r.bits2int ||
function (N) {
if (N.length > 8192) throw new Error("input is too large");
let F = eo(N),
H = N.length * 8 - d;
return H > 0 ? F >> BigInt(H) : F;
},
E =
r.bits2int_modN ||
function (N) {
return i.create(I(N));
},
K = Yn(d);
function J(R) {
return (F1("num < 2^" + d, R, no, K), i.toBytes(R));
}
function P(R, N) {
return (
zn(R, void 0, "message"),
N ? zn(t(R), void 0, "prehashed message") : R
);
}
function k(R, N, F) {
if (["recovered", "canonical"].some((X) => X in F))
throw new Error("sign() legacy options not supported");
let { lowS: H, prehash: q, extraEntropy: ne } = Xg(F, m);
R = P(R, q);
let ee = E(R),
Q = ns(i, N),
L = [J(Q), J(ee)];
if (ne != null && ne !== !1) {
let X = ne === !0 ? o(b.secretKey) : ne;
L.push(it("extraEntropy", X));
}
let W = ut(...L),
Y = ee;
function j(X) {
let z = I(X);
if (!i.isValidNot0(z)) return;
let te = i.inv(z),
oe = e.BASE.multiply(z).toAffine(),
ie = i.create(oe.x);
if (ie === no) return;
let ue = i.create(te * i.create(Y + ie * Q));
if (ue === no) return;
let ge = (oe.x === ie ? 0 : 2) | Number(oe.y & Mt),
Fe = ue;
return (
H && h(ue) && ((Fe = i.neg(ue)), (ge ^= 1)),
new w(ie, Fe, ge)
);
}
return { seed: W, k2sig: j };
}
function U(R, N, F = {}) {
R = it("message", R);
let { seed: H, k2sig: q } = k(R, N, F);
return K1(t.outputLen, i.BYTES, n)(H, q);
}
function D(R) {
let N,
F = typeof R == "string" || yn(R),
H =
!F &&
R !== null &&
typeof R == "object" &&
typeof R.r == "bigint" &&
typeof R.s == "bigint";
if (!F && !H)
throw new Error(
"invalid signature, expected Uint8Array, hex string or Signature instance",
);
if (H) N = new w(R.r, R.s);
else if (F) {
try {
N = w.fromBytes(it("sig", R), "der");
} catch (q) {
if (!(q instanceof xn.Err)) throw q;
}
if (!N)
try {
N = w.fromBytes(it("sig", R), "compact");
} catch {
return !1;
}
}
return N || !1;
}
function _(R, N, F, H = {}) {
let { lowS: q, prehash: ne, format: ee } = Xg(H, m);
if (
((F = it("publicKey", F)),
(N = P(it("message", N), ne)),
"strict" in H)
)
throw new Error("options.strict was renamed to lowS");
let Q = ee === void 0 ? D(R) : w.fromBytes(it("sig", R), ee);
if (Q === !1) return !1;
try {
let L = e.fromBytes(F);
if (q && Q.hasHighS()) return !1;
let { r: W, s: Y } = Q,
j = E(N),
X = i.inv(Y),
z = i.create(j * X),
te = i.create(W * X),
oe = e.BASE.multiplyUnsafe(z).add(L.multiplyUnsafe(te));
return oe.is0() ? !1 : i.create(oe.x) === W;
} catch {
return !1;
}
}
function T(R, N, F = {}) {
let { prehash: H } = Xg(F, m);
return (
(N = P(N, H)),
w.fromBytes(R, "recovered").recoverPublicKey(N).toBytes()
);
}
return Object.freeze({
keygen: l,
getPublicKey: u,
getSharedSecret: p,
utils: y,
lengths: b,
Point: e,
sign: U,
verify: _,
recoverPublicKey: T,
Signature: w,
hash: t,
});
}
function i$(e) {
let t = {
a: e.a,
b: e.b,
p: e.Fp.ORDER,
n: e.n,
h: e.h,
Gx: e.Gx,
Gy: e.Gy,
},
r = e.Fp,
o = e.allowedPrivateKeyLengths
? Array.from(
new Set(e.allowedPrivateKeyLengths.map((i) => Math.ceil(i / 2))),
)
: void 0,
n = os(t.n, {
BITS: e.nBitLength,
allowedLengths: o,
modFromBytes: e.wrapPrivateKey,
}),
a = {
Fp: r,
Fn: n,
allowInfinityPoint: e.allowInfinityPoint,
endo: e.endo,
isTorsionFree: e.isTorsionFree,
clearCofactor: e.clearCofactor,
fromBytes: e.fromBytes,
toBytes: e.toBytes,
};
return { CURVE: t, curveOpts: a };
}
function c$(e) {
let { CURVE: t, curveOpts: r } = i$(e),
o = {
hmac: e.hmac,
randomBytes: e.randomBytes,
lowS: e.lowS,
bits2int: e.bits2int,
bits2int_modN: e.bits2int_modN,
};
return { CURVE: t, curveOpts: r, hash: e.hash, ecdsaOpts: o };
}
function d$(e, t) {
let r = t.Point;
return Object.assign({}, t, {
ProjectivePoint: r,
CURVE: Object.assign({}, e, Xu(r.Fn.ORDER, r.Fn.BITS)),
});
}
function ak(e) {
let { CURVE: t, curveOpts: r, hash: o, ecdsaOpts: n } = c$(e),
a = o$(t, r),
i = a$(a, o, n);
return d$(e, i);
}
var rk,
th,
xn,
no,
Mt,
Ko,
wi,
rh,
oh = St(() => {
MP();
Qn();
hi();
tk();
rd();
rk = (e, t) => (e + (e >= 0 ? t : -t) / Ko) / t;
((th = class extends Error {
constructor(t = "") {
super(t);
}
}),
(xn = {
Err: th,
_tlv: {
encode: (e, t) => {
let { Err: r } = xn;
if (e < 0 || e > 256) throw new r("tlv.encode: wrong tag");
if (t.length & 1) throw new r("tlv.encode: unpadded data");
let o = t.length / 2,
n = Qc(o);
if ((n.length / 2) & 128)
throw new r("tlv.encode: long form length too big");
let a = o > 127 ? Qc((n.length / 2) | 128) : "";
return Qc(e) + a + n + t;
},
decode(e, t) {
let { Err: r } = xn,
o = 0;
if (e < 0 || e > 256) throw new r("tlv.encode: wrong tag");
if (t.length < 2 || t[o++] !== e)
throw new r("tlv.decode: wrong tlv");
let n = t[o++],
a = !!(n & 128),
i = 0;
if (!a) i = n;
else {
let d = n & 127;
if (!d)
throw new r(
"tlv.decode(long): indefinite length not supported",
);
if (d > 4)
throw new r("tlv.decode(long): byte length is too big");
let l = t.subarray(o, o + d);
if (l.length !== d)
throw new r("tlv.decode: length bytes not complete");
if (l[0] === 0)
throw new r("tlv.decode(long): zero leftmost byte");
for (let u of l) i = (i << 8) | u;
if (((o += d), i < 128))
throw new r("tlv.decode(long): not minimal encoding");
}
let c = t.subarray(o, o + i);
if (c.length !== i)
throw new r("tlv.decode: wrong value length");
return { v: c, l: t.subarray(o + i) };
},
},
_int: {
encode(e) {
let { Err: t } = xn;
if (e < no)
throw new t("integer: negative integers are not allowed");
let r = Qc(e);
if (
(Number.parseInt(r[0], 16) & 8 && (r = "00" + r),
r.length & 1)
)
throw new t("unexpected DER parsing assertion: unpadded hex");
return r;
},
decode(e) {
let { Err: t } = xn;
if (e[0] & 128)
throw new t("invalid signature integer: negative");
if (e[0] === 0 && !(e[1] & 128))
throw new t(
"invalid signature integer: unnecessary leading zero",
);
return eo(e);
},
},
toSig(e) {
let { Err: t, _int: r, _tlv: o } = xn,
n = it("signature", e),
{ v: a, l: i } = o.decode(48, n);
if (i.length)
throw new t("invalid signature: left bytes after parsing");
let { v: c, l: d } = o.decode(2, a),
{ v: l, l: u } = o.decode(2, d);
if (u.length)
throw new t("invalid signature: left bytes after parsing");
return { r: r.decode(c), s: r.decode(l) };
},
hexFromSig(e) {
let { _tlv: t, _int: r } = xn,
o = t.encode(2, r.encode(e.r)),
n = t.encode(2, r.encode(e.s)),
a = o + n;
return t.encode(48, a);
},
}),
(no = BigInt(0)),
(Mt = BigInt(1)),
(Ko = BigInt(2)),
(wi = BigInt(3)),
(rh = BigInt(4)));
});
function ik(e, t) {
let r = (o) => ak({ ...e, hash: o });
return { ...r(t), create: r };
}
var ck = St(() => {
oh();
});
function ss(e, t) {
if ((nd(e), nd(t), e < 0 || e >= 1 << (8 * t)))
throw new Error("invalid I2OSP input: " + e);
let r = Array.from({ length: t }).fill(0);
for (let o = t - 1; o >= 0; o--) ((r[o] = e & 255), (e >>>= 8));
return new Uint8Array(r);
}
function u$(e, t) {
let r = new Uint8Array(e.length);
for (let o = 0; o < e.length; o++) r[o] = e[o] ^ t[o];
return r;
}
function nd(e) {
if (!Number.isSafeInteger(e)) throw new Error("number expected");
}
function dk(e) {
if (!yn(e) && typeof e != "string")
throw new Error("DST must be Uint8Array or string");
return typeof e == "string" ? hn(e) : e;
}
function p$(e, t, r, o) {
(Wt(e),
nd(r),
(t = dk(t)),
t.length > 255 && (t = o(ut(hn("H2C-OVERSIZE-DST-"), t))));
let { outputLen: n, blockLen: a } = o,
i = Math.ceil(r / n);
if (r > 65535 || i > 255)
throw new Error("expand_message_xmd: invalid lenInBytes");
let c = ut(t, ss(t.length, 1)),
d = ss(0, a),
l = ss(r, 2),
u = new Array(i),
p = o(ut(d, e, l, ss(0, 1), c));
u[0] = o(ut(p, ss(1, 1), c));
for (let b = 1; b <= i; b++) {
let m = [u$(p, u[b - 1]), ss(b + 1, 1), c];
u[b] = o(ut(...m));
}
return ut(...u).slice(0, r);
}
function m$(e, t, r, o, n) {
if ((Wt(e), nd(r), (t = dk(t)), t.length > 255)) {
let a = Math.ceil((2 * o) / 8);
t = n
.create({ dkLen: a })
.update(hn("H2C-OVERSIZE-DST-"))
.update(t)
.digest();
}
if (r > 65535 || t.length > 255)
throw new Error("expand_message_xof: invalid lenInBytes");
return n
.create({ dkLen: r })
.update(e)
.update(ss(r, 2))
.update(t)
.update(ss(t.length, 1))
.digest();
}
function nh(e, t, r) {
ga(r, { p: "bigint", m: "number", k: "number", hash: "function" });
let { p: o, k: n, m: a, hash: i, expand: c, DST: d } = r;
if (!J1(r.hash)) throw new Error("expected valid hash");
(Wt(e), nd(t));
let l = o.toString(2).length,
u = Math.ceil((l + n) / 8),
p = t * a * u,
y;
if (c === "xmd") y = p$(e, d, p, i);
else if (c === "xof") y = m$(e, d, p, n, i);
else if (c === "_internal_pass") y = e;
else throw new Error('expand must be "xmd" or "xof"');
let b = new Array(t);
for (let m = 0; m < t; m++) {
let v = new Array(a);
for (let h = 0; h < a; h++) {
let g = u * (h + m * a),
S = y.subarray(g, g + u);
v[h] = Lt(l$(S), o);
}
b[m] = v;
}
return b;
}
function lk(e, t) {
let r = t.map((o) => Array.from(o).reverse());
return (o, n) => {
let [a, i, c, d] = r.map((p) =>
p.reduce((y, b) => e.add(e.mul(y, o), b)),
),
[l, u] = ba(e, [i, d], !0);
return ((o = e.mul(a, l)), (n = e.mul(n, e.mul(c, u))), { x: o, y: n });
};
}
function uk(e, t, r) {
if (typeof t != "function")
throw new Error("mapToCurve() must be defined");
function o(a) {
return e.fromAffine(t(a));
}
function n(a) {
let i = a.clearCofactor();
return i.equals(e.ZERO) ? e.ZERO : (i.assertValidity(), i);
}
return {
defaults: r,
hashToCurve(a, i) {
let c = Object.assign({}, r, i),
d = nh(a, 2, c),
l = o(d[0]),
u = o(d[1]);
return n(l.add(u));
},
encodeToCurve(a, i) {
let c = r.encodeDST ? { DST: r.encodeDST } : {},
d = Object.assign({}, r, c, i),
l = nh(a, 1, d),
u = o(l[0]);
return n(u);
},
mapToCurve(a) {
if (!Array.isArray(a)) throw new Error("expected array of bigints");
for (let i of a)
if (typeof i != "bigint")
throw new Error("expected array of bigints");
return n(o(a));
},
hashToScalar(a, i) {
let c = e.Fn.ORDER,
d = Object.assign({}, r, { p: c, m: 1, DST: f$ }, i);
return nh(a, 1, d)[0][0];
},
};
}
var l$,
f$,
pk = St(() => {
hi();
rd();
l$ = eo;
f$ = hn("HashToScalar-");
});
var vk = {};
T0(vk, {
encodeToCurve: () => w$,
hashToCurve: () => A$,
schnorr: () => v$,
secp256k1: () => np,
secp256k1_hasher: () => dh,
});
function h$(e) {
let t = Pi.p,
r = BigInt(3),
o = BigInt(6),
n = BigInt(11),
a = BigInt(22),
i = BigInt(23),
c = BigInt(44),
d = BigInt(88),
l = (e * e * e) % t,
u = (l * l * e) % t,
p = (pr(u, r, t) * u) % t,
y = (pr(p, r, t) * u) % t,
b = (pr(y, sh, t) * l) % t,
m = (pr(b, n, t) * b) % t,
v = (pr(m, a, t) * m) % t,
h = (pr(v, c, t) * v) % t,
g = (pr(h, d, t) * h) % t,
S = (pr(g, c, t) * v) % t,
w = (pr(S, r, t) * u) % t,
I = (pr(w, i, t) * m) % t,
E = (pr(I, o, t) * l) % t,
K = pr(E, sh, t);
if (!An.eql(An.sqr(K), e)) throw new Error("Cannot find square root");
return K;
}
function op(e, ...t) {
let r = fk[e];
if (r === void 0) {
let o = td(hn(e));
((r = ut(o, o)), (fk[e] = r));
}
return td(ut(r, ...t));
}
function ah(e) {
let { Fn: t, BASE: r } = ki,
o = ns(t, e),
n = r.multiply(o);
return { scalar: ch(n.y) ? o : t.neg(o), bytes: ih(n) };
}
function gk(e) {
let t = An;
if (!t.isValidNot0(e)) throw new Error("invalid x: Fail if x \u2265 p");
let r = t.create(e * e),
o = t.create(r * e + BigInt(7)),
n = t.sqrt(o);
ch(n) || (n = t.neg(n));
let a = ki.fromAffine({ x: e, y: n });
return (a.assertValidity(), a);
}
function hk(...e) {
return ki.Fn.create(sd(op("BIP0340/challenge", ...e)));
}
function yk(e) {
return ah(e).bytes;
}
function b$(e, t, r = ya(32)) {
let { Fn: o } = ki,
n = it("message", e),
{ bytes: a, scalar: i } = ah(t),
c = it("auxRand", r, 32),
d = o.toBytes(i ^ sd(op("BIP0340/aux", c))),
l = op("BIP0340/nonce", d, a, n),
{ bytes: u, scalar: p } = ah(l),
y = hk(u, a, n),
b = new Uint8Array(64);
if (
(b.set(u, 0), b.set(o.toBytes(o.create(p + y * i)), 32), !bk(b, n, a))
)
throw new Error("sign: Invalid signature produced");
return b;
}
function bk(e, t, r) {
let { Fn: o, BASE: n } = ki,
a = it("signature", e, 64),
i = it("message", t),
c = it("publicKey", r, 32);
try {
let d = gk(sd(c)),
l = sd(a.subarray(0, 32));
if (!zc(l, mk, Pi.p)) return !1;
let u = sd(a.subarray(32, 64));
if (!zc(u, mk, Pi.n)) return !1;
let p = hk(o.toBytes(l), ih(d), i),
y = n.multiplyUnsafe(u).add(d.multiplyUnsafe(o.neg(p))),
{ x: b, y: m } = y.toAffine();
return !(y.is0() || !ch(m) || b !== l);
} catch {
return !1;
}
}
var Pi,
y$,
g$,
mk,
sh,
An,
np,
fk,
ih,
ki,
ch,
sd,
v$,
S$,
x$,
dh,
A$,
w$,
Sk = St(() => {
BP();
Qn();
ck();
pk();
rd();
oh();
hi();
((Pi = {
p: BigInt(
"0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f",
),
n: BigInt(
"0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
),
h: BigInt(1),
a: BigInt(0),
b: BigInt(7),
Gx: BigInt(
"0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
),
Gy: BigInt(
"0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
),
}),
(y$ = {
beta: BigInt(
"0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
),
basises: [
[
BigInt("0x3086d221a7d46bcde86c90e49284eb15"),
-BigInt("0xe4437ed6010e88286f547fa90abfe4c3"),
],
[
BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"),
BigInt("0x3086d221a7d46bcde86c90e49284eb15"),
],
],
}),
(g$ = BigInt(0)),
(mk = BigInt(1)),
(sh = BigInt(2)));
((An = os(Pi.p, { sqrt: h$ })),
(np = ik({ ...Pi, Fp: An, lowS: !0, endo: y$ }, td)),
(fk = {}));
((ih = (e) => e.toBytes(!0).slice(1)),
(ki = np.Point),
(ch = (e) => e % sh === g$));
sd = eo;
((v$ = (() => {
let r = (n = ya(48)) => ep(n, Pi.n);
np.utils.randomSecretKey;
function o(n) {
let a = r(n);
return { secretKey: a, publicKey: yk(a) };
}
return {
keygen: o,
getPublicKey: yk,
sign: b$,
verify: bk,
Point: ki,
utils: {
randomSecretKey: r,
randomPrivateKey: r,
taggedHash: op,
lift_x: gk,
pointToBytes: ih,
numberToBytesBE: gi,
bytesToNumberBE: eo,
mod: Lt,
},
lengths: {
secretKey: 32,
publicKey: 32,
publicKeyHasPrefix: !1,
signature: 64,
seed: 48,
},
};
})()),
(S$ = lk(
An,
[
[
"0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
"0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
"0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
"0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c",
],
[
"0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
"0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
"0x0000000000000000000000000000000000000000000000000000000000000001",
],
[
"0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
"0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
"0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
"0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84",
],
[
"0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
"0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
"0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
"0x0000000000000000000000000000000000000000000000000000000000000001",
],
].map((e) => e.map((t) => BigInt(t))),
)),
(x$ = nk(An, {
A: BigInt(
"0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533",
),
B: BigInt("1771"),
Z: An.create(BigInt("-11")),
})),
(dh = uk(
np.Point,
(e) => {
let { x: t, y: r } = x$(An.create(e[0]));
return S$(t, r);
},
{
DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
p: An.ORDER,
m: 1,
k: 128,
expand: "xmd",
hash: td,
},
)),
(A$ = dh.hashToCurve),
(w$ = dh.encodeToCurve));
});
var cp = St(() => {
"use strict";
});
var b2 = lo((Ri) => {
"use strict";
Object.defineProperty(Ri, "__esModule", { value: !0 });
Ri.bech32m = Ri.bech32 = void 0;
var hp = "qpzry9x8gf2tvdw0s3jn54khce6mua7l",
g2 = {};
for (let e = 0; e < hp.length; e++) {
let t = hp.charAt(e);
g2[t] = e;
}
function Ci(e) {
let t = e >> 25;
return (
((e & 33554431) << 5) ^
(-((t >> 0) & 1) & 996825010) ^
(-((t >> 1) & 1) & 642813549) ^
(-((t >> 2) & 1) & 513874426) ^
(-((t >> 3) & 1) & 1027748829) ^
(-((t >> 4) & 1) & 705979059)
);
}
function y2(e) {
let t = 1;
for (let r = 0; r < e.length; ++r) {
let o = e.charCodeAt(r);
if (o < 33 || o > 126) return "Invalid prefix (" + e + ")";
t = Ci(t) ^ (o >> 5);
}
t = Ci(t);
for (let r = 0; r < e.length; ++r) {
let o = e.charCodeAt(r);
t = Ci(t) ^ (o & 31);
}
return t;
}
function $h(e, t, r, o) {
let n = 0,
a = 0,
i = (1 << r) - 1,
c = [];
for (let d = 0; d < e.length; ++d)
for (n = (n << t) | e[d], a += t; a >= r; )
((a -= r), c.push((n >> a) & i));
if (o) a > 0 && c.push((n << (r - a)) & i);
else {
if (a >= t) return "Excess padding";
if ((n << (r - a)) & i) return "Non-zero padding";
}
return c;
}
function h8(e) {
return $h(e, 8, 5, !0);
}
function b8(e) {
let t = $h(e, 5, 8, !1);
if (Array.isArray(t)) return t;
}
function v8(e) {
let t = $h(e, 5, 8, !1);
if (Array.isArray(t)) return t;
throw new Error(t);
}
function h2(e) {
let t;
e === "bech32" ? (t = 1) : (t = 734539939);
function r(i, c, d) {
if (((d = d || 90), i.length + 7 + c.length > d))
throw new TypeError("Exceeds length limit");
i = i.toLowerCase();
let l = y2(i);
if (typeof l == "string") throw new Error(l);
let u = i + "1";
for (let p = 0; p < c.length; ++p) {
let y = c[p];
if (y >> 5 !== 0) throw new Error("Non 5-bit word");
((l = Ci(l) ^ y), (u += hp.charAt(y)));
}
for (let p = 0; p < 6; ++p) l = Ci(l);
l ^= t;
for (let p = 0; p < 6; ++p) {
let y = (l >> ((5 - p) * 5)) & 31;
u += hp.charAt(y);
}
return u;
}
function o(i, c) {
if (((c = c || 90), i.length < 8)) return i + " too short";
if (i.length > c) return "Exceeds length limit";
let d = i.toLowerCase(),
l = i.toUpperCase();
if (i !== d && i !== l) return "Mixed-case string " + i;
i = d;
let u = i.lastIndexOf("1");
if (u === -1) return "No separator character for " + i;
if (u === 0) return "Missing prefix for " + i;
let p = i.slice(0, u),
y = i.slice(u + 1);
if (y.length < 6) return "Data too short";
let b = y2(p);
if (typeof b == "string") return b;
let m = [];
for (let v = 0; v < y.length; ++v) {
let h = y.charAt(v),
g = g2[h];
if (g === void 0) return "Unknown character " + h;
((b = Ci(b) ^ g), !(v + 6 >= y.length) && m.push(g));
}
return b !== t
? "Invalid checksum for " + i
: { prefix: p, words: m };
}
function n(i, c) {
let d = o(i, c);
if (typeof d == "object") return d;
}
function a(i, c) {
let d = o(i, c);
if (typeof d == "object") return d;
throw new Error(d);
}
return {
decodeUnsafe: n,
decode: a,
encode: r,
toWords: h8,
fromWordsUnsafe: b8,
fromWords: v8,
};
}
Ri.bech32 = h2("bech32");
Ri.bech32m = h2("bech32m");
});
var kd = globalThis.assert;
if (kd === void 0)
throw Error(
"Cannot initialize @endo/errors, missing globalThis.assert, import 'ses' before '@endo/errors'",
);
var U0 = [
"typeof",
"error",
"fail",
"equal",
"string",
"note",
"details",
"Fail",
"quote",
"makeAssert",
].filter((e) => kd[e] === void 0);
if (U0.length > 0)
throw Error(
`Cannot initialize @endo/errors, missing globalThis.assert methods ${U0.join(", ")}`,
);
var {
bare: YI,
details: V,
error: Se,
Fail: f,
makeAssert: s_,
note: Ze,
quote: x,
...ZI
} = kd,
xe = (e, t, r, o) => kd(e, t, r, o);
Object.assign(xe, ZI);
var tt = YI || x;
var R0 = globalThis,
{
Object: XI,
Reflect: eT,
Array: O0,
String: tT,
JSON: rT,
Error: oT,
} = R0,
{ freeze: ls } = XI,
{ apply: nT } = eT,
Gp =
(e) =>
(t, ...r) =>
nT(e, t, r),
sT = Gp(O0.prototype.push),
C0 = Gp(O0.prototype.includes),
aT = Gp(tT.prototype.split),
ds = rT.stringify,
Id = (e, ...t) => {
let r = e[0];
for (let o = 0; o < t.length; o += 1) r = `${r}${t[o]}${e[o + 1]}`;
throw oT(r);
},
E0 = (e, t = !1) => {
let r = [],
o = (c, d, l = void 0) => {
(typeof c == "string" ||
Id`Environment option name ${ds(c)} must be a string.`,
typeof d == "string" ||
Id`Environment option default setting ${ds(d)} must be a string.`);
let u = d,
p = e.process || void 0,
y = (typeof p == "object" && p.env) || void 0;
if (typeof y == "object" && c in y) {
t || sT(r, c);
let b = y[c];
(typeof b == "string" ||
Id`Environment option named ${ds(c)}, if present, must have a corresponding string value, got ${ds(b)}`,
(u = b));
}
return (
l === void 0 ||
u === d ||
C0(l, u) ||
Id`Unrecognized ${ds(c)} value ${ds(u)}. Expected one of ${ds([d, ...l])}`,
u
);
};
ls(o);
let n = (c) => {
let d = o(c, "");
return ls(d === "" ? [] : aT(d, ","));
};
ls(n);
let a = (c, d) => C0(n(c), d),
i = () => ls([...r]);
return (
ls(i),
ls({
getEnvironmentOption: o,
getEnvironmentOptionsList: n,
environmentOptionsListHas: a,
getCapturedEnvironmentOptionNames: i,
})
);
};
ls(E0);
var {
getEnvironmentOption: hr,
getEnvironmentOptionsList: i_,
environmentOptionsListHas: Pa,
} = E0(R0, !0);
var { quote: Tn, Fail: Td } = assert,
{ hasOwn: iT, freeze: Bi, entries: D0 } = Object,
N0 = (e) => typeof e == "object" && e !== null && !Array.isArray(e),
Qp = (e) => {
for (let t of ["Alleged: ", "DebugName: "])
if (e.startsWith(t)) return e.slice(t.length);
return e;
},
ka = (e) => {
let t = JSON.parse(hr(e, "null"));
if (t === null) return;
let r,
o = () => t;
Bi(o);
let n = (c = t) => {
N0(c) || Td`Expected ${Tn(e)} option to be a JSON breakpoints record`;
let d = { __proto__: null };
for (let [l, u] of D0(c)) {
(l === Qp(l) ||
Td`Just use simple tag ${Tn(Qp(l))} rather than ${Tn(l)}`,
N0(u) ||
Td`Expected ${Tn(e)} option's ${Tn(l)} to be a JSON methods breakpoints record`);
for (let [p, y] of D0(u)) {
y === "*" ||
(typeof y == "number" && Number.isSafeInteger(y) && y >= 0) ||
Td`Expected ${Tn(e)} option's ${Tn(l)}.${Tn(p)} to be "*" or a non-negative integer`;
let b = iT(d, p) ? d[p] : (d[p] = { __proto__: null });
b[l] = y;
}
}
((t = c), (r = d));
};
Bi(n);
let a = (c, d) => {
if (d == null) return !1;
let l = r[d] || r["*"];
if (l === void 0) return !1;
let u = Qp(c[Symbol.toStringTag]),
p = l[u];
return p === void 0 && ((u = "*"), (p = l[u]), p === void 0)
? !1
: p === "*" || p === 0
? !0
: (assert(typeof p == "number" && p >= 1), (l[u] = p - 1), !1);
};
Bi(a);
let i = Bi({
getBreakpoints: o,
setBreakpoints: n,
shouldBreakpoint: a,
});
return (i.setBreakpoints(), i);
};
Bi(ka);
var { details: f_, quote: y_, Fail: g_ } = assert,
{
getOwnPropertyDescriptors: cT,
getPrototypeOf: dT,
freeze: lT,
} = Object,
{ apply: h_, ownKeys: uT } = Reflect;
var b_ = ka("ENDO_DELIVERY_BREAKPOINTS"),
pT = (e) => !e || (typeof e != "object" && typeof e != "function"),
mT = (e, t) => {
if (typeof e == typeof t) {
let r = String(e),
o = String(t);
return r < o ? -1 : r > o ? 1 : 0;
}
return typeof e == "symbol"
? (assert(typeof t == "string"), -1)
: (assert(typeof e == "string"), assert(typeof t == "symbol"), 1);
},
_r = (e) => {
let t = e,
r = new Set();
for (; t !== null && t !== Object.prototype; ) {
let o = cT(t);
for (let n of uT(o)) typeof e[n] == "function" && r.add(n);
if (pT(e)) break;
t = dT(t);
}
return harden([...r].sort(mT));
};
lT(_r);
var { isArray: fT } = Array,
{ prototype: B0 } = Function,
{
getOwnPropertyDescriptor: M0,
getPrototypeOf: zp,
hasOwn: yT,
isFrozen: gT,
prototype: hT,
} = Object,
{ apply: bT } = Reflect,
{ toStringTag: vT } = Symbol,
ST = zp(Uint8Array.prototype),
$0 = M0(ST, vT);
assert($0);
var _0 = $0.get;
assert(typeof _0 == "function");
var Je = (e) => !e || (typeof e != "object" && typeof e != "function");
harden(Je);
var F0 = (e) => !!e && (typeof e == "object" || typeof e == "function");
harden(F0);
var Yp = (e) => bT(_0, e, []) !== void 0;
harden(Yp);
var ct = Symbol.for("passStyle"),
Te = (e, t) => (assert(e, t), !0);
harden(Te);
var ve =
(e) =>
(r, ...o) =>
e(!1, V(r, ...o));
harden(ve);
var uo = (e, t, r, o) => {
let n = M0(e, t);
return (n !== void 0 || (o && ve(o)`${x(t)} property expected: ${e}`)) &&
(yT(n, "value") ||
(o && ve(o)`${x(t)} must not be an accessor property: ${e}`)) &&
(r
? n.enumerable ||
(o && ve(o)`${x(t)} must be an enumerable property: ${e}`)
: !n.enumerable ||
(o && ve(o)`${x(t)} must not be an enumerable property: ${e}`))
? n
: void 0;
};
harden(uo);
var $e = (e) => e[Symbol.toStringTag];
harden($e);
var Ud = (e, t, r, o) =>
t === r || (!!o && ve(o)`Expected ${x(r)}, not ${x(t)}: ${e}`);
harden(Ud);
var K0 = (e) => {
let t = (r, o, n) =>
(!Je(r) ||
(!!n && ve(n)`A non-object cannot be a tagRecord: ${r}`)) &&
(gT(r) || (!!n && ve(n)`A tagRecord must be frozen: ${r}`)) &&
(!fT(r) || (!!n && ve(n)`An array cannot be a tagRecord: ${r}`)) &&
Ud(r, uo(r, ct, !1, n).value, o, n) &&
(typeof uo(r, Symbol.toStringTag, !1, n).value == "string" ||
(!!n &&
ve(
n,
)`A [Symbol.toStringTag]-named property must be a string: ${r}`)) &&
e(r, zp(r), n);
return harden(t);
},
Mi = K0(
(e, t, r) =>
t === hT ||
(!!r &&
r(!1, V`A tagRecord must inherit from Object.prototype: ${e}`)),
);
harden(Mi);
var Zp = K0(
(e, t, r) =>
t === B0 ||
(t !== null && zp(t) === B0) ||
(!!r &&
r(
!1,
V`For functions, a tagRecord must inherit from Function.prototype: ${e}`,
)),
);
harden(Zp);
var Od = (e) => typeof e == "function" && !(ct in e);
harden(Od);
var xT = (e) =>
typeof e == "string" || typeof e == "symbol" || typeof e == "number";
harden(xT);
var Ed = (e) => _r(e);
harden(Ed);
var { ownKeys: Cd } = Reflect,
{ isArray: AT } = Array,
{
getPrototypeOf: J0,
isFrozen: wT,
prototype: V0,
getOwnPropertyDescriptors: W0,
hasOwn: PT,
} = Object,
Rd = (e, t) =>
(typeof e == "string" ||
(!!t &&
ve(t)`For now, interface ${e} must be a string; unimplemented`)) &&
(e === "Remotable" ||
e.startsWith("Alleged: ") ||
e.startsWith("DebugName: ") ||
(!!t &&
ve(
t,
)`For now, iface ${x(e)} must be "Remotable" or begin with "Alleged: " or "DebugName: "; unimplemented`)),
Xp = (e) => Rd(e, Te);
harden(Xp);
var kT = (e, t) => {
!Je(e) || f`Remotables must be objects or functions: ${e}`;
let r = J0(e);
if (r === V0 || r === null || r === Function.prototype)
return !!t && ve(t)`Remotables must be explicitly declared: ${x(e)}`;
if (typeof e == "object") {
let d = J0(r);
if (d !== V0 && d !== null) return em(r, t);
if (!Mi(r, "remotable", t)) return !1;
} else if (typeof e == "function" && !Zp(r, "remotable", t)) return !1;
let o = ct,
n = Symbol.toStringTag,
{
[o]: a,
[n]: { value: i },
...c
} = W0(r);
return (
(Cd(c).length === 0 ||
(!!t &&
ve(t)`Unexpected properties on Remotable Proto ${Cd(c)}`)) &&
Rd(i, t)
);
},
H0 = new WeakSet(),
em = (e, t) => {
if (H0.has(e)) return !0;
if (!wT(e))
return !!t && ve(t)`cannot serialize non-frozen objects like ${e}`;
if (!$i.canBeValid(e, t)) return !1;
let r = kT(e, t);
return (r && H0.add(e), r);
},
po = (e) => {
if (!(Je(e) || e[ct] !== "remotable" || !em(e))) return $e(e);
};
harden(po);
var $i = harden({
styleName: "remotable",
canBeValid: (e, t = void 0) => {
if (
!(
(!Je(e) ||
(!!t && ve(t)`cannot serialize non-objects as Remotable ${e}`)) &&
(!AT(e) ||
(!!t && ve(t)`cannot serialize arrays as Remotable ${e}`))
)
)
return !1;
let o = W0(e);
if (typeof e == "object")
return Cd(o).every(
(n) =>
(PT(o[n], "value") ||
(!!t &&
ve(
t,
)`cannot serialize Remotables with accessors like ${x(String(n))} in ${e}`)) &&
((n === Symbol.toStringTag && Rd(e[n], t)) ||
((Od(e[n]) ||
(!!t &&
ve(
t,
)`cannot serialize Remotables with non-methods like ${x(String(n))} in ${e}`)) &&
(n !== ct ||
(!!t && ve(t)`A pass-by-remote cannot shadow ${x(ct)}`)))),
);
if (typeof e == "function") {
let { name: n, length: a, [Symbol.toStringTag]: i, ...c } = o,
d = Cd(c);
return (
((n && typeof n.value == "string") ||
(!!t && ve(t)`Far function name must be a string, in ${e}`)) &&
((a && typeof a.value == "number") ||
(!!t && ve(t)`Far function length must be a number, in ${e}`)) &&
(i === void 0 ||
((typeof i.value == "string" ||
(!!t &&
ve(
t,
)`Far function @@toStringTag must be a string, in ${e}`)) &&
Rd(i.value, t))) &&
(d.length === 0 ||
(!!t &&
ve(
t,
)`Far functions unexpected properties besides .name and .length ${d}`))
);
}
return !!t && ve(t)`unrecognized typeof ${e}`;
},
assertRestValid: (e) => em(e, Te),
every: (e, t) => !0,
});
var { prototype: L0 } = Function,
{
getPrototypeOf: q0,
setPrototypeOf: IT,
create: TT,
isFrozen: UT,
prototype: j0,
} = Object,
CT = (e, t) => {
let r = q0(e);
return (
typeof e == "object"
? (r === null && (r = j0),
r === j0 ||
f`For now, remotables cannot inherit from anything unusual, in ${e}`)
: typeof e == "function"
? (r !== null ||
f`Original function must not inherit from null: ${e}`,
r === L0 ||
q0(r) === L0 ||
f`Far functions must originally inherit from Function.prototype, in ${e}`)
: f`unrecognized typeof ${e}`,
harden(
TT(r, {
[ct]: { value: "remotable" },
[Symbol.toStringTag]: { value: t },
}),
)
);
},
G0 = (e) => $i.canBeValid(e, Te),
Ia = (e = "Remotable", t = void 0, r = {}) => {
(Xp(e),
assert(e),
t === void 0 || f`Remotable props not yet implemented ${t}`,
G0(r),
!(ct in r) || f`Remotable ${r} is already marked as a ${x(r[ct])}`,
harden.isFake || !UT(r) || f`Remotable ${r} is already frozen`);
let o = CT(r, e),
n = (a) => {
(IT(a, o), harden(a), G0(a));
};
return (n({}), n(r), assert(e !== void 0), r);
};
harden(Ia);
var us = "__getMethodNames__",
RT = harden({
[us]() {
return _r(this);
},
})[us],
OT = harden({
value: RT,
enumerable: !1,
configurable: !1,
writable: !1,
}),
se = (e, t = void 0) => {
let r = t === void 0 ? {} : t;
return (
typeof r == "object" &&
!(us in r) &&
Object.defineProperty(r, us, OT),
Ia(`Alleged: ${e}`, void 0, r)
);
};
harden(se);
var Q0 = (e, t) => (po(t) !== void 0 ? t : se(e, (...r) => t(...r)));
harden(Q0);
var _i = (e, t) =>
se("mapped iterable", {
[Symbol.iterator]: () => {
let r = e[Symbol.iterator]();
return se("mapped iterator", {
next: () => {
let { value: o, done: n } = r.next(),
a = n ? o : t(o);
return harden({ value: a, done: n });
},
});
},
});
harden(_i);
var Ta = (e, t) =>
se("filtered iterable", {
[Symbol.iterator]: () => {
let r = e[Symbol.iterator]();
return se("filtered iterator", {
next: () => {
for (;;) {
let o = r.next(),
{ value: n, done: a } = o;
if (a || t(n)) return o;
}
},
});
},
});
harden(Ta);
var {
getPrototypeOf: ET,
getOwnPropertyDescriptors: DT,
hasOwn: NT,
entries: BT,
} = Object,
z0 = new Map([
["Error", Error],
["EvalError", EvalError],
["RangeError", RangeError],
["ReferenceError", ReferenceError],
["SyntaxError", SyntaxError],
["TypeError", TypeError],
["URIError", URIError],
]);
typeof AggregateError < "u" && z0.set("AggregateError", AggregateError);
var br = (e) => z0.get(e);
harden(br);
var Dd = (e, t = void 0) =>
e instanceof Error || (!!t && ve(t)`Error expected: ${e}`);
harden(Dd);
var mo = (e) => Dd(e);
harden(mo);
var Nd = (e, t, r, o = void 0) => {
if (t.enumerable)
return (
!!o &&
ve(
o,
)`Passable Error ${x(e)} own property must not be enumerable: ${t}`
);
if (!NT(t, "value"))
return (
!!o &&
ve(
o,
)`Passable Error ${x(e)} own property must be a data property: ${t}`
);
let { value: n } = t;
switch (e) {
case "message":
case "stack":
return (
typeof n == "string" ||
(!!o &&
ve(o)`Passable Error ${x(e)} own property must be a string: ${n}`)
);
case "cause":
return Ua(n, r, o);
case "errors":
return !Array.isArray(n) || r(n) !== "copyArray"
? !!o &&
ve(
o,
)`Passable Error ${x(e)} own property must be a copyArray: ${n}`
: n.every((a) => Ua(a, r, o));
default:
break;
}
return !!o && ve(o)`Passable Error has extra unpassed property ${x(e)}`;
};
harden(Nd);
var Ua = (e, t, r = void 0) => {
if (!Dd(e, r)) return !1;
let o = ET(e),
{ name: n } = o,
a = br(n);
if (a === void 0 || a.prototype !== o)
return (
!!r &&
ve(
r,
)`Passable Error must inherit from an error class .prototype: ${e}`
);
let i = DT(e);
return "message" in i
? BT(i).every(([c, d]) => Nd(c, d, t, r))
: !!r &&
ve(
r,
)`Passable Error must have an own "message" string property: ${e}`;
};
harden(Ua);
var Y0 = harden({
styleName: "error",
canBeValid: Dd,
assertRestValid: (e, t) => Ua(e, t, Te),
});
var { ownKeys: MT } = Reflect,
Z0 = new Map(
MT(Symbol)
.filter((e) => typeof e == "string" && typeof Symbol[e] == "symbol")
.filter(
(e) => (
!e.startsWith("@@") ||
f`Did not expect Symbol to have a symbol-valued property name starting with "@@" ${x(e)}`,
!0
),
)
.map((e) => [Symbol[e], `@@${e}`]),
),
ps = (e) =>
typeof e == "symbol" &&
(typeof Symbol.keyFor(e) == "string" || Z0.has(e));
harden(ps);
var Un = (e) =>
ps(e) ||
f`Only registered symbols or well-known symbols are passable: ${x(e)}`;
harden(Un);
var _t = (e) => {
let t = Symbol.keyFor(e);
return t === void 0 ? Z0.get(e) : t.startsWith("@@") ? `@@${t}` : t;
};
harden(_t);
var X0 = /^@@(.*)$/;
harden(X0);
var Fr = (e) => {
typeof e == "string" || f`${x(e)} must be a string, not ${x(typeof e)}`;
let t = X0.exec(e);
if (t) {
let r = t[1];
if (r.startsWith("@@")) return Symbol.for(r);
{
let o = Symbol[r];
if (typeof o == "symbol") return o;
f`Reserved for well known symbol ${x(r)}: ${x(e)}`;
}
}
return Symbol.for(e);
};
harden(Fr);
var $T = !!String.prototype.isWellFormed,
tm = $T
? (e) => typeof e == "string" && e.isWellFormed()
: (e) => {
if (typeof e != "string") return !1;
for (let t of e) {
let r = t.codePointAt(0);
if (r >= 55296 && r <= 57343) return !1;
}
return !0;
};
harden(tm);
var rm = (e) => {
tm(e) || f`Expected well-formed unicode string: ${e}`;
};
harden(rm);
var _T =
hr("ONLY_WELL_FORMED_STRINGS_PASSABLE", "disabled", ["enabled"]) ===
"enabled",
Bd = (e) => {
(typeof e == "string" || f`Expected string ${e}`, !_T || rm(e));
};
harden(Bd);
var om = () => {
let e,
t,
r = (a) => {
e ? (e(a), (e = null), (t = null)) : assert(e === null);
},
o = (a) => {
t ? (t(a), (e = null), (t = null)) : assert(t === null);
},
n = (a, i) => {
(assert(e === void 0 && t === void 0), (e = a), (t = i));
};
return harden({ resolve: r, reject: o, executor: n });
};
harden(om);
var FT = (e) => !e || (typeof e != "object" && typeof e != "function"),
eb = new WeakMap(),
tb = (e) => {
if (!e || e.settled) return new Set();
let { deferreds: t } = e;
return (
Object.assign(e, { deferreds: void 0, settled: !0 }),
Object.freeze(e),
t
);
},
rb = (e) => {
if (FT(e)) return harden({ settled: !0 });
let t = eb.get(e);
return (
t ||
((t = { deferreds: new Set(), settled: !1 }),
eb.set(e, t),
Promise.resolve(e).then(
(r) => {
for (let { resolve: o } of tb(t)) o(r);
},
(r) => {
for (let { reject: o } of tb(t)) o(r);
},
)),
t
);
},
{ race: ob } = {
race(e) {
let t,
r = [],
o = this;
return new o((a, i) => {
t = { resolve: a, reject: i };
for (let c of e) {
r.push(c);
let { settled: d, deferreds: l } = rb(c);
d ? o.resolve(c).then(a, i) : l.add(t);
}
}).finally(() => {
for (let a of r) {
let { deferreds: i } = rb(a);
i && i.delete(t);
}
});
},
};
function rr(e) {
return Promise.resolve(e) === e;
}
harden(rr);
var nb = globalThis.HandledPromise || Promise;
function xt() {
let { resolve: e, reject: t, executor: r } = om(),
o = new nb(r);
return harden({ promise: o, resolve: e, reject: t });
}
harden(xt);
function KT(e) {
return harden(ob.call(nb, e));
}
harden(KT);
var { getPrototypeOf: JT } = Object,
{ ownKeys: VT } = Reflect,
{ isArray: HT, prototype: WT } = Array,
sb = harden({
styleName: "copyArray",
canBeValid: (e, t = void 0) =>
HT(e) || (!!t && t(!1, V`Array expected: ${e}`)),
assertRestValid: (e, t) => {
JT(e) === WT || assert.fail(V`Malformed array: ${e}`, TypeError);
let r = uo(e, "length", !1, Te).value;
for (let o = 0; o < r; o += 1) t(uo(e, o, !0, Te).value);
VT(e).length === r + 1 ||
assert.fail(V`Arrays must not have non-indexes: ${e}`, TypeError);
},
});
var { getPrototypeOf: ab, getOwnPropertyDescriptor: LT } = Object,
{ ownKeys: qT, apply: jT } = Reflect,
GT = () => {
let e = new ArrayBuffer(0);
if (e.sliceToImmutable === void 0)
return {
immutableArrayBufferPrototype: null,
immutableGetter: () => !1,
};
let t = e.sliceToImmutable(),
r = ab(t),
o = LT(r, "immutable").get;
return { immutableArrayBufferPrototype: r, immutableGetter: o };
},
{ immutableArrayBufferPrototype: QT, immutableGetter: zT } = GT(),
ib = harden({
styleName: "byteArray",
canBeValid: (e, t = void 0) =>
(e instanceof ArrayBuffer && e.immutable) ||
(!!t && t(!1, V`Immutable ArrayBuffer expected: ${e}`)),
assertRestValid: (e, t) => {
(ab(e) === QT || assert.fail(V`Malformed ByteArray ${e}`, TypeError),
jT(zT, e, []) || f`Must be an immutable ArrayBuffer: ${e}`,
qT(e).length === 0 ||
assert.fail(
V`ByteArrays must not have own properties: ${e}`,
TypeError,
));
},
});
var { ownKeys: cb } = Reflect,
{ getPrototypeOf: YT, prototype: ZT } = Object,
XT = (e, t = void 0) =>
YT(e) === ZT ||
(!!t && ve(t)`Records must inherit from Object.prototype: ${e}`),
eU = (e, t, r, o = void 0) =>
(typeof t == "string" ||
(!!o &&
ve(o)`Records can only have string-named properties: ${e}`)) &&
(!Od(r) ||
(!!o &&
ve(
o,
)`Records cannot contain non-far functions because they may be methods of an implicit Remotable: ${e}`)),
db = harden({
styleName: "copyRecord",
canBeValid: (e, t = void 0) =>
XT(e, t) && cb(e).every((r) => eU(e, r, e[r], t)),
assertRestValid: (e, t) => {
for (let r of cb(e)) {
let { value: o } = uo(e, r, !0, Te);
t(o);
}
},
});
var { ownKeys: lb } = Reflect,
{ getOwnPropertyDescriptors: tU } = Object,
ub = harden({
styleName: "tagged",
canBeValid: (e, t = void 0) => Ud(e, e[ct], "tagged", t),
assertRestValid: (e, t) => {
Mi(e, "tagged", Te);
let r = ct,
o = Symbol.toStringTag,
{ [r]: n, [o]: a, payload: i, ...c } = tU(e);
(lb(c).length === 0 ||
f`Unexpected properties on tagged record ${lb(c)}`,
t(uo(e, "payload", !0, Te).value));
},
});
var {
isFrozen: yb,
getPrototypeOf: nm,
getOwnPropertyDescriptor: rU,
hasOwn: pb,
} = Object,
{ ownKeys: mb } = Reflect,
{ toStringTag: fb } = Symbol,
oU = (e, t) => {
let r = mb(e);
if (r.length === 0) return !0;
let o = r.filter(
(a) => typeof a != "symbol" || !pb(Promise.prototype, a),
);
if (o.length !== 0)
return ve(t)`${e} - Must not have any own properties: ${x(o)}`;
let n = (a) => {
if (a === fb) {
let c = rU(e, fb);
return (
assert(c !== void 0),
(pb(c, "value") ||
ve(
t,
)`Own @@toStringTag must be a data property, not an accessor: ${x(c)}`) &&
(typeof c.value == "string" ||
ve(
t,
)`Own @@toStringTag value must be a string: ${x(c.value)}`) &&
(!c.enumerable ||
ve(t)`Own @@toStringTag must not be enumerable: ${x(c)}`)
);
}
let i = e[a];
if (i === void 0 || typeof i == "number") return !0;
if (
typeof i == "object" &&
i !== null &&
yb(i) &&
nm(i) === Object.prototype
) {
let c = mb(i);
if (
c.length === 0 ||
(c.length === 1 && c[0] === "destroyed" && i.destroyed === !1)
)
return !0;
}
return ve(
t,
)`Unexpected Node async_hooks additions to promise: ${e}.${x(String(a))} is ${i}`;
};
return r.every(n);
},
sm = (e, t) =>
(yb(e) || ve(t)`${e} - Must be frozen`) &&
(rr(e) || ve(t)`${e} - Must be a promise`) &&
(nm(e) === Promise.prototype ||
ve(t)`${e} - Must inherit from Promise.prototype: ${x(nm(e))}`) &&
oU(e, t);
harden(sm);
var nU = (e) => sm(e, (t) => t);
harden(nU);
var gb = (e) => sm(e, Te);
var { ownKeys: sU } = Reflect,
{ isFrozen: hb, getOwnPropertyDescriptors: aU, values: iU } = Object,
cU = (e) => {
let t = {
__proto__: null,
copyArray: void 0,
byteArray: void 0,
copyRecord: void 0,
tagged: void 0,
error: void 0,
remotable: void 0,
};
for (let r of e) {
let { styleName: o } = r;
(o in t || f`Unrecognized helper: ${x(o)}`,
t[o] === void 0 || f`conflicting helpers for ${x(o)}`,
(t[o] = r));
}
for (let r of sU(t)) t[r] !== void 0 || f`missing helper for ${x(r)}`;
return harden(t);
},
am = (e, t, r) => {
(e.canBeValid(t, Te), e.assertRestValid(t, r));
},
dU = (e) => {
let t = cU(e),
r = t.remotable,
o = new WeakMap(),
n = (a) => {
let i = new Set(),
c = (l) => {
let u = !Je(l);
if (u) {
let y = o.get(l);
if (y) return y;
(!i.has(l) || f`Pass-by-copy data cannot be cyclic ${l}`,
i.add(l));
}
let p = d(l);
return (u && (o.set(l, p), i.delete(l)), p);
},
d = (l) => {
let u = typeof l;
switch (u) {
case "undefined":
case "boolean":
case "number":
case "bigint":
return u;
case "string":
return (Bd(l), "string");
case "symbol":
return (Un(l), "symbol");
case "object": {
if (l === null) return "null";
if (
(hb(l) ||
assert.fail(
Yp(l)
? V`Cannot pass mutable typed arrays like ${l}.`
: V`Cannot pass non-frozen objects like ${l}. Use harden()`,
),
rr(l))
)
return (gb(l), "promise");
typeof l.then != "function" ||
f`Cannot pass non-promise thenables`;
let p = l[ct];
if (p !== void 0) {
assert.typeof(p, "string");
let y = t[p];
return (
y !== void 0 || f`Unrecognized PassStyle: ${x(p)}`,
am(y, l, c),
p
);
}
for (let y of e)
if (y.canBeValid(l))
return (y.assertRestValid(l, c), y.styleName);
return (am(r, l, c), "remotable");
}
case "function":
return (
hb(l) ||
f`Cannot pass non-frozen objects like ${l}. Use harden()`,
typeof l.then != "function" ||
f`Cannot pass non-promise thenables`,
am(r, l, c),
"remotable"
);
default:
throw assert.fail(
V`Unrecognized typeof ${x(u)}`,
TypeError,
);
}
};
return c(a);
};
return harden(n);
},
lU = Symbol.for("@endo passStyleOf"),
ce = (globalThis && globalThis[lU]) || dU([sb, ib, db, ub, Y0, $i]),
fo = (e) => {
ce(e);
};
harden(fo);
var or = (e) => {
try {
return ce(e) !== void 0;
} catch {
return !1;
}
};
harden(or);
var bb = (e, t) => Nd(e, t, ce),
Fi = (e) => {
if ((harden(e), Ua(e, ce))) return e;
let { name: t, message: r } = e,
{ cause: o, errors: n } = aU(e),
a,
i;
(o && bb("cause", o) && (a = o.value),
n && bb("errors", n) && (i = n.value));
let c = br(`${t}`) || Error,
d = Se(`${r}`, c, { cause: a, errors: i });
return (
harden(d),
Ze(d, V`copied from error ${e}`),
ce(d) === "error" || f`Expected ${d} to be a passable error`,
d
);
};
harden(Fi);
var Wo = (e) => {
if ((harden(e), mo(e))) return Fi(e);
if (!Je(e)) {
let t = ce(e);
switch (t) {
case "copyArray": {
let r = e;
for (let o of r)
o === Wo(o) ||
f`nested toThrowable coercion not yet supported ${o}`;
break;
}
case "copyRecord": {
let r = e;
for (let o of iU(r))
o === Wo(o) ||
f`nested toThrowable coercion not yet supported ${o}`;
break;
}
case "tagged": {
let r = e,
{ payload: o } = r;
o === Wo(o) ||
f`nested toThrowable coercion not yet supported ${o}`;
break;
}
case "error": {
let r = e;
r === Wo(r) ||
f`nested toThrowable coercion not yet supported ${r}`;
break;
}
default:
throw f`A ${x(t)} is not throwable: ${e}`;
}
}
return e;
};
harden(Wo);
var { create: uU, prototype: pU } = Object,
Ce = (e, t) => (
typeof e == "string" ||
f`The tag of a tagged record must be a string: ${e}`,
fo(harden(t)),
harden(
uU(pU, {
[ct]: { value: "tagged" },
[Symbol.toStringTag]: { value: e },
payload: { value: t, enumerable: !0 },
}),
)
);
harden(Ce);
var Xe = (e, t) => e;
harden(Xe);
var vb = (e) => ce(e) === "copyArray";
harden(vb);
var mU = (e) => ce(e) === "byteArray";
harden(mU);
var Sb = (e) => ce(e) === "copyRecord";
harden(Sb);
var Ki = (e) => ce(e) === "remotable";
harden(Ki);
var xb = (e, t = "Alleged array") => {
let r = ce(e);
r === "copyArray" ||
f`${x(t)} ${e} must be a pass-by-copy array, not ${x(r)}`;
};
harden(xb);
var fU = (e, t = "Alleged byteArray") => {
let r = ce(e);
r === "byteArray" ||
f`${x(t)} ${e} must be a pass-by-copy binary data, not ${x(r)}`;
};
harden(fU);
var vr = (e, t = "Alleged record") => {
let r = ce(e);
r === "copyRecord" ||
f`${x(t)} ${e} must be a pass-by-copy record, not ${x(r)}`;
};
harden(vr);
var yo = (e, t = "Alleged remotable") => {
let r = ce(e);
r === "remotable" || f`${x(t)} ${e} must be a remotable, not ${x(r)}`;
};
harden(yo);
var Ab = (e, t) => {
let r;
try {
r = ce(e);
} catch (o) {
return t !== Xe && t(!1, V`Not even Passable: ${x(o)}: ${e}`);
}
switch (r) {
case "undefined":
case "null":
case "boolean":
case "number":
case "bigint":
case "string":
case "byteArray":
case "symbol":
return !0;
default:
return t !== Xe && t(!1, V`A ${x(r)} cannot be an atom: ${e}`);
}
},
ms = (e) => Ab(e, Xe);
harden(ms);
var wb = (e) => {
Ab(e, Te);
};
harden(wb);
var Ca,
Md = 0,
Ji = 0,
Pb = Pa("DEBUG", "track-turns"),
yU = hr("TRACK_TURNS", "disabled", ["enabled"]) === "enabled",
gU = (e) => (t) => {
(t instanceof Error && globalThis.assert.note(t, e),
Pb && console.log("REJECTED at top of event loop", t));
},
hU =
(e, t, r) =>
(...o) => {
((Ca = t), (Md += 1), (Ji = 0));
try {
let n;
try {
n = e(...o);
} catch (i) {
throw (
i instanceof Error &&
globalThis.assert.note(i, r`Thrown from: ${Ca}:${Md}.${Ji}`),
Pb && console.log("THROWN to top of event loop", i),
i
);
}
let a = r`Rejection from: ${Ca}:${Md}.${Ji}`;
return (Promise.resolve(n).catch(gU(a)), n);
} finally {
Ca = void 0;
}
},
kb = (e) => {
if (!yU || typeof globalThis > "u" || !globalThis.assert) return e;
let { details: t, note: r } = globalThis.assert;
Ji += 1;
let o = Error(`Event: ${Md}.${Ji}`);
return (
Ca !== void 0 && r(o, t`Caused by: ${Ca}`),
e.map((n) => n && hU(n, o, t))
);
};
var { details: bU, quote: $d, Fail: vU, error: SU } = assert,
{ assign: xU, freeze: Tb } = Object,
Cn = ka("ENDO_SEND_BREAKPOINTS"),
im = {
set(e, t, r) {
return !1;
},
isExtensible(e) {
return !1;
},
setPrototypeOf(e, t) {
return !1;
},
deleteProperty(e, t) {
return !1;
},
},
AU = (e, t) =>
harden({
...im,
get: (r, o, n) =>
harden(
{
[o](...a) {
if (this !== n)
return t.reject(
SU(
bU`Unexpected receiver for "${$d(o)}" method of E(${$d(e)})`,
),
);
if (Cn && Cn.shouldBreakpoint(e, o)) debugger;
return t.applyMethod(e, o, a);
},
}[o],
),
apply: (r, o, n = []) => {
if (Cn && Cn.shouldBreakpoint(e, void 0)) debugger;
return t.applyFunction(e, n);
},
has: (r, o) => !0,
}),
wU = (e, t) =>
harden({
...im,
get: (r, o, n) =>
harden(
{
[o](...a) {
if (
(this === n ||
vU`Unexpected receiver for "${$d(o)}" method of E.sendOnly(${$d(e)})`,
Cn && Cn.shouldBreakpoint(e, o))
)
debugger;
t.applyMethodSendOnly(e, o, a);
},
}[o],
),
apply: (r, o, n = []) => {
if (Cn && Cn.shouldBreakpoint(e, void 0)) debugger;
t.applyFunctionSendOnly(e, n);
},
has: (r, o) => !0,
}),
PU = (e, t) =>
harden({ ...im, has: (r, o) => !0, get: (r, o) => t.get(e, o) }),
Ib = Tb(() => {}),
kU = Tb({ __proto__: null }),
IU = (e) =>
harden(
xU((t) => new Proxy(Ib, AU(t, e)), {
get: (t) => new Proxy(kU, PU(t, e)),
resolve: e.resolve,
sendOnly: (t) => new Proxy(Ib, wU(t, e)),
when: (t, r, o) => e.resolve(t).then(...kb([r, o])),
}),
),
Ub = IU;
var TU = HandledPromise,
O = Ub(TU);
var { ownKeys: UU } = Reflect,
{ fromEntries: CU } = Object,
Lo = async (e) => {
if (ms(e)) return e;
if (rr(e)) return O.when(e, (r) => Lo(r));
let t = ce(e);
switch (t) {
case "copyRecord": {
let r = e,
o = UU(r),
n = o.map((a) => Lo(r[a]));
return O.when(Promise.all(n), (a) =>
harden(CU(a.map((i, c) => [o[c], i]))),
);
}
case "copyArray": {
let o = e.map((n) => Lo(n));
return O.when(Promise.all(o), (n) => harden(n));
}
case "byteArray":
return e;
case "tagged": {
let r = e,
o = $e(r);
return O.when(Lo(r.payload), (n) => Ce(o, n));
}
case "remotable":
return e;
case "error":
return e;
case "promise": {
let r = e;
return O.when(r, (o) => Lo(o));
}
default:
throw assert.fail(V`Unexpected passStyle ${x(t)}`, TypeError);
}
};
harden(Lo);
var { ownKeys: dm } = Reflect,
{ isArray: Rb } = Array,
{
getOwnPropertyDescriptors: RU,
defineProperties: OU,
is: EU,
entries: DU,
fromEntries: Ob,
freeze: NU,
hasOwn: Vi,
} = Object,
Ie = "@qclass";
var Eb = (e) => Vi(e, Ie),
cm = (e, t) => !Je(e) && !Rb(e) && Eb(e) && e[Ie] === t,
BU = (e) => f`remotable unexpected: ${e}`,
MU = (e) => f`promise unexpected: ${e}`,
$U = (e) => f`error object unexpected: ${e}`,
lm = (e = {}) => {
let {
encodeRemotableToCapData: t = BU,
encodePromiseToCapData: r = MU,
encodeErrorToCapData: o = $U,
} = e,
n = (i) => {
let c = ce(i);
switch (c) {
case "null":
case "boolean":
case "string":
return i;
case "undefined":
return { [Ie]: "undefined" };
case "number":
return Number.isNaN(i)
? { [Ie]: "NaN" }
: i === 1 / 0
? { [Ie]: "Infinity" }
: i === -1 / 0
? { [Ie]: "-Infinity" }
: EU(i, -0)
? 0
: i;
case "bigint":
return { [Ie]: "bigint", digits: String(i) };
case "symbol": {
Un(i);
let d = _t(i);
return { [Ie]: "symbol", name: d };
}
case "copyRecord": {
if (Vi(i, Ie)) {
let { [Ie]: l, ...u } = i,
p = { [Ie]: "hilbert", original: n(l) };
return (dm(u).length >= 1 && (p.rest = n(NU(u))), p);
}
let d = dm(i).sort();
return Ob(d.map((l) => [l, n(i[l])]));
}
case "copyArray":
return i.map(n);
case "byteArray":
throw f`marsal of byteArray not yet implemented: ${i}`;
case "tagged":
return { [Ie]: "tagged", tag: $e(i), payload: n(i.payload) };
case "remotable": {
let d = t(i, n);
if (cm(d, "slot")) return d;
throw f`internal: Remotable encoding must be an object with ${x(Ie)} ${x("slot")}: ${d}`;
}
case "promise": {
let d = r(i, n);
if (cm(d, "slot")) return d;
throw f`internal: Promise encoding must be an object with ${x(Ie, "slot")}: ${d}`;
}
case "error": {
let d = o(i, n);
if (cm(d, "error")) return d;
throw f`internal: Error encoding must be an object with ${x(Ie, "error")}: ${d}`;
}
default:
throw assert.fail(
V`internal: Unrecognized passStyle ${x(c)}`,
TypeError,
);
}
},
a = (i) => (mo(i) ? harden(o(i, n)) : harden(n(i)));
return harden(a);
};
harden(lm);
var Cb = (e) => f`remotable or promise unexpected: ${e}`,
_U = (e) => f`error unexpected: ${e}`,
Db = (e = {}) => {
let {
decodeRemotableFromCapData: t = Cb,
decodePromiseFromCapData: r = Cb,
decodeErrorFromCapData: o = _U,
} = e;
t === r ||
f`An implementation restriction for now: If either decodeRemotableFromCapData or decodePromiseFromCapData is provided, both must be provided and they must be the same: ${x(t)} vs ${x(r)}`;
let n = (a) => {
if (Je(a)) return a;
if (Rb(a)) return a.map((i) => n(i));
if (Eb(a)) {
let i = a[Ie];
switch (
(typeof i == "string" ||
f`invalid ${x(Ie)} typeof ${x(typeof i)}`,
i)
) {
case "undefined":
return;
case "NaN":
return NaN;
case "Infinity":
return 1 / 0;
case "-Infinity":
return -1 / 0;
case "bigint": {
let { digits: c } = a;
return (
typeof c == "string" ||
f`invalid digits typeof ${x(typeof c)}`,
BigInt(c)
);
}
case "@@asyncIterator":
return Symbol.asyncIterator;
case "symbol": {
let { name: c } = a;
return Fr(c);
}
case "tagged": {
let { tag: c, payload: d } = a;
return Ce(c, n(d));
}
case "slot":
return t(a, n);
case "error": {
let c = o(a, n);
if (ce(c) === "error") return c;
throw f`internal: decodeErrorFromCapData option must return an error: ${c}`;
}
case "hilbert": {
let { original: c, rest: d } = a;
Vi(a, "original") || f`Invalid Hilbert Hotel encoding ${a}`;
let l = { [Ie]: n(c) };
if (Vi(a, "rest")) {
if (
!(typeof d == "object" && d !== null && dm(d).length >= 1)
)
throw f`Rest encoding must be a non-empty object: ${d}`;
let p = n(d);
(!Vi(p, Ie) ||
f`Rest must not contain its own definition of ${x(Ie)}`,
OU(l, RU(p)));
}
return l;
}
case "ibid":
throw f`The capData protocol no longer supports ${x(Ie)} ${x(i)}`;
default:
throw assert.fail(V`unrecognized ${x(Ie)} ${x(i)}`, TypeError);
}
} else {
assert(typeof a == "object" && a !== null);
let i = ([d, l]) => (
typeof d == "string" ||
f`Property ${x(d)} of ${a} must be a string`,
[d, n(l)]
),
c = DU(a).map(i);
return Ob(c);
}
};
return harden(n);
};
function Ra(e) {
return typeof e == "bigint"
? e >= 0
: typeof e != "number"
? !1
: Number.isSafeInteger(e) && e >= 0;
}
function Re(e) {
if (typeof e == "bigint") {
if (e < 0n) throw RangeError(`${e} is negative`);
return e;
}
if (typeof e == "number") {
if (!Number.isSafeInteger(e))
throw RangeError(`${e} is not a safe integer`);
if (e < 0) throw RangeError(`${e} is negative`);
return BigInt(e);
}
throw TypeError(`${e} is a ${typeof e} but must be a bigint or a number`);
}
var { entries: FU, fromEntries: KU } = Object,
Ne = (e, t) => {
let o = FU(e).map(([n, a]) => [n, t(a, n)]);
return harden(KU(o));
};
harden(Ne);
var { ownKeys: um } = Reflect,
{ isArray: JU } = Array,
{ is: VU, entries: HU, fromEntries: Nb, hasOwn: pm } = Object,
WU = 33,
LU = 45,
mm = (e) => {
if (e === "") return !1;
let t = e.charCodeAt(0);
return WU <= t && t <= LU;
},
qU = (e) => f`remotable unexpected: ${e}`,
jU = (e) => f`promise unexpected: ${e}`,
GU = (e) => f`error object unexpected: ${x(e)}`,
fm = (e = {}) => {
let {
encodeRemotableToSmallcaps: t = qU,
encodePromiseToSmallcaps: r = jU,
encodeErrorToSmallcaps: o = GU,
} = e,
n = (c) => {
(typeof c == "object" && pm(c, "#error")) ||
f`internal: Error encoding must have "#error" property: ${x(c)}`;
let d = c["#error"];
(typeof d == "string" && (!mm(d) || d.charAt(0) === "!")) ||
f`internal: Error encoding must have string message: ${x(d)}`;
},
a = (c) => {
let d = ce(c);
switch (d) {
case "null":
case "boolean":
return c;
case "string":
return mm(c) ? `!${c}` : c;
case "undefined":
return "#undefined";
case "number":
return Number.isNaN(c)
? "#NaN"
: c === 1 / 0
? "#Infinity"
: c === -1 / 0
? "#-Infinity"
: VU(c, -0)
? 0
: c;
case "bigint": {
let l = String(c);
return c < 0n ? l : `+${l}`;
}
case "symbol":
return (Un(c), `%${_t(c)}`);
case "copyRecord": {
let l = um(c).sort();
return Nb(l.map((u) => [a(u), a(c[u])]));
}
case "copyArray":
return c.map(a);
case "byteArray":
throw f`marsal of byteArray not yet implemented: ${c}`;
case "tagged":
return { "#tag": a($e(c)), payload: a(c.payload) };
case "remotable": {
let l = t(c, a);
if (typeof l == "string" && l.charAt(0) === "$") return l;
throw f`internal: Remotable encoding must start with "$": ${l}`;
}
case "promise": {
let l = r(c, a);
if (typeof l == "string" && l.charAt(0) === "&") return l;
throw f`internal: Promise encoding must start with "&": ${l}`;
}
case "error": {
let l = o(c, a);
return (n(l), l);
}
default:
throw assert.fail(
V`internal: Unrecognized passStyle ${x(d)}`,
TypeError,
);
}
},
i = (c) => {
if (mo(c)) {
let d = harden(o(c, a));
return (n(d), d);
}
return harden(a(c));
};
return harden(i);
};
harden(fm);
var QU = (e) => f`remotable unexpected: ${e}`,
zU = (e) => f`promise unexpected: ${e}`,
YU = (e) => f`error unexpected: ${x(e)}`,
Bb = (e = {}) => {
let {
decodeRemotableFromSmallcaps: t = QU,
decodePromiseFromSmallcaps: r = zU,
decodeErrorFromSmallcaps: o = YU,
} = e,
n = (a) => {
switch (typeof a) {
case "boolean":
case "number":
return a;
case "string": {
if (!mm(a)) return a;
let i = a.charAt(0);
switch (i) {
case "!":
return a.slice(1);
case "%":
return Fr(a.slice(1));
case "#":
switch (a) {
case "#undefined":
return;
case "#NaN":
return NaN;
case "#Infinity":
return 1 / 0;
case "#-Infinity":
return -1 / 0;
default:
throw assert.fail(
V`unknown constant "${x(a)}"`,
TypeError,
);
}
case "+":
case "-":
return BigInt(a);
case "$": {
let c = t(a, n);
return (
ce(c) !== "remotable" &&
f`internal: decodeRemotableFromSmallcaps option must return a remotable: ${c}`,
c
);
}
case "&": {
let c = r(a, n);
return (
ce(c) !== "promise" &&
f`internal: decodePromiseFromSmallcaps option must return a promise: ${c}`,
c
);
}
default:
throw f`Special char ${x(i)} reserved for future use: ${a}`;
}
}
case "object": {
if (a === null) return a;
if (JU(a)) return a.map((d) => n(d));
if (pm(a, "#tag")) {
let { "#tag": d, payload: l, ...u } = a;
return (
typeof d == "string" ||
f`Value of "#tag", the tag, must be a string: ${a}`,
um(u).length === 0 ||
f`#tag record unexpected properties: ${x(um(u))}`,
Ce(n(d), n(l))
);
}
if (pm(a, "#error")) {
let d = o(a, n);
return (
ce(d) === "error" ||
f`internal: decodeErrorFromSmallcaps option must return an error: ${d}`,
d
);
}
let i = ([d, l]) => {
(typeof d == "string" ||
f`Property name ${x(d)} of ${a} must be a string`,
d.charAt(0) !== "#" ||
f`Unrecognized record type ${x(d)}: ${a}`);
let u = n(d);
return (
typeof u == "string" ||
f`Decoded property name ${u} from ${a} must be a string`,
[u, n(l)]
);
},
c = HU(a).map(i);
return Nb(c);
}
default:
throw assert.fail(
V`internal: unrecognized JSON typeof ${x(typeof a)}: ${a}`,
TypeError,
);
}
};
return harden(n);
};
var { defineProperties: ZU, hasOwn: XU } = Object,
{ isArray: eC } = Array,
{ ownKeys: Mb } = Reflect,
tC = (e) => e,
rC = (e, t) => e,
At = (
e = tC,
t = rC,
{
errorTagging: r = "on",
marshalName: o = "anon-marshal",
errorIdNum: n = 1e4,
marshalSaveError: a = (c) =>
console.log("Temporary logging of sent error", c),
serializeBodyFormat: i = "capdata",
} = {},
) => {
(assert.typeof(o, "string"),
r === "on" ||
r === "off" ||
f`The errorTagging option can only be "on" or "off" ${r}`);
let c = () => ((n += 1), `error:${o}#${n}`),
d = (p) => {
let y = [],
b = new Map(),
m = (h) => {
let g = b.get(h);
if (g !== void 0)
return (
assert.typeof(g, "number"),
harden({ index: g, repeat: !0 })
);
g = y.length;
let S = e(h);
return (
y.push(S),
b.set(h, g),
harden({ index: g, repeat: !1 })
);
},
v = (h, g) => {
let S = g(`${h.message}`);
assert.typeof(S, "string");
let w = g(`${h.name}`);
if ((assert.typeof(w, "string"), r === "on")) {
let I = g(c());
return (
assert.typeof(I, "string"),
Ze(h, V`Sent as ${I}`),
a(h),
harden({ errorId: I, message: S, name: w })
);
} else return harden({ message: S, name: w });
};
if (i === "capdata") {
let h = (J, P = void 0) => {
let { index: k, repeat: U } = m(J);
return U === !0 || P === void 0
? harden({ [Ie]: "slot", index: k })
: harden({ [Ie]: "slot", iface: P, index: k });
},
E = lm({
encodeRemotableToCapData: (J, P) => h(J, po(J)),
encodePromiseToCapData: (J, P) => h(J),
encodeErrorToCapData: (J, P) => {
let k = v(J, P);
return harden({ [Ie]: "error", ...k });
},
})(p),
K = JSON.stringify(E);
return harden({ body: K, slots: y });
} else if (i === "smallcaps") {
let h = (J, P, k = void 0) => {
let { index: U, repeat: D } = m(P);
return D === !0 || k === void 0
? `${J}${U}`
: `${J}${U}.${k}`;
},
E = fm({
encodeRemotableToSmallcaps: (J, P) => h("$", J, po(J)),
encodePromiseToSmallcaps: (J, P) => h("&", J),
encodeErrorToSmallcaps: (J, P) => {
let k = v(J, P),
{ message: U, ...D } = k;
return harden({ "#error": U, ...D });
},
})(p),
K = JSON.stringify(E);
return harden({ body: `#${K}`, slots: y });
} else throw f`Unrecognized serializeBodyFormat: ${x(i)}`;
},
l = (p) => {
let y = new Map(),
b = (J) => {
let { iface: P = void 0, index: k, ...U } = J;
Mb(U).length === 0 ||
f`unexpected encoded slot properties ${x(Mb(U))}`;
let D = y.get(k);
if (D) return D;
let _ = p[Number(Re(k))],
T = t(_, P);
return (y.set(k, T), T);
},
m = (J, P) => {
let {
errorId: k = void 0,
message: U,
name: D,
cause: _ = void 0,
errors: T = void 0,
...R
} = J,
N = P(D),
F = P(U),
H = k && P(k);
if (typeof N != "string")
throw f`invalid error name typeof ${x(typeof N)}`;
if (typeof F != "string")
throw f`invalid error message typeof ${x(typeof F)}`;
let q = br(N) || Error,
ee = {
errorName:
H === void 0
? `Remote${q.name}`
: `Remote${q.name}(${H})`,
sanitize: !1,
};
(_ && (ee.cause = P(_)), T && (ee.errors = P(T)));
let Q = Se(F, q, ee),
L = Ne(R, (W) => ({
value: P(W),
writable: !1,
enumerable: !1,
configurable: !1,
}));
return (ZU(Q, L), harden(Q), Fi(Q));
},
v = (J, P) => {
let { [Ie]: k, ...U } = J;
return b(U);
},
g = Db({
decodeRemotableFromCapData: v,
decodePromiseFromCapData: v,
decodeErrorFromCapData: (J, P) => {
let { [Ie]: k, ...U } = J;
return m(U, P);
},
}),
S = (J) => (P, k) => {
assert(P.charAt(0) === J);
let U = P.indexOf("."),
D = Number(P.slice(1, U < 0 ? void 0 : U)),
_ = U < 0 ? void 0 : P.slice(U + 1);
return b({ iface: _, index: D });
},
w = S("$"),
I = S("&"),
K = Bb({
decodeRemotableFromSmallcaps: w,
decodePromiseFromSmallcaps: I,
decodeErrorFromSmallcaps: (J, P) => {
let { "#error": k, ...U } = J;
return (
!XU(U, "message") ||
f`unexpected encoded error property ${x("message")}`,
m({ message: k, ...U }, P)
);
},
});
return harden({ reviveFromCapData: g, reviveFromSmallcaps: K });
},
u = (p) => {
let { body: y, slots: b } = p;
(typeof y == "string" ||
f`unserialize() given non-capdata (.body is ${y}, not string)`,
eC(p.slots) ||
f`unserialize() given non-capdata (.slots are not Array)`);
let { reviveFromCapData: m, reviveFromSmallcaps: v } = l(b),
h;
if (y.charAt(0) === "#") {
let g = y.slice(1),
S = harden(JSON.parse(g));
h = harden(v(S));
} else {
let g = harden(JSON.parse(y));
h = harden(m(g));
}
return (fo(h), h);
};
return harden({
toCapData: d,
fromCapData: u,
serialize: d,
unserialize: u,
});
};
var { freeze: $b } = Object,
oC = (e) => f`Marshal's stringify rejects presences and promises ${e}`,
nC = (e, t) => f`Marshal's parse must not encode any slots ${e}`,
sC = harden({
get: (e, t, r) => {
if (t === "length") return 0;
throw f`Marshal's parse must not encode any slot positions ${t}`;
},
}),
aC = $b([]),
iC = new Proxy(aC, sC),
{ serialize: cC, unserialize: dC } = At(oC, nC, {
errorTagging: "off",
serializeBodyFormat: "capdata",
}),
_b = (e) => cC(e).body;
harden(_b);
var Fb = (e) => dC($b({ body: e, slots: iC }));
harden(Fb);
var { ownKeys: _d } = Reflect,
{ isArray: Hi } = Array,
{ stringify: Wi } = JSON,
lC = () => {
let e = [],
t = 0,
r = !1,
o = () => (
(r = !1),
e.push(
`
`,
" ".repeat(t),
)
);
return harden({
open: (n) => ((t += 1), r && e.push(" "), (r = !1), e.push(n)),
line: o,
next: (n) => (
r && n !== "," && n !== ")" && e.push(" "),
(r = !0),
e.push(n)
),
close: (n) => (assert(t >= 1), (t -= 1), o(), e.push(n)),
done: () => (assert.equal(t, 0), e.join("")),
});
},
uC = /^(?:\w\w|<<|>>|\+\+|--|<!|->)$/,
Kb = () => {
let e = [];
return harden({
open: (t) => e.push(t),
line: () => e.length,
next: (t) => {
if (e.length >= 1) {
let r = e[e.length - 1];
if (r.length >= 1 && t.length >= 1) {
let o = `${r[r.length - 1]}${t[0]}`;
uC.test(o) && e.push(" ");
}
}
return e.push(t);
},
close: (t) => (
e.length >= 1 && e[e.length - 1] === "," && e.pop(),
e.push(t)
),
done: () => e.join(""),
});
},
ym = /^[a-zA-Z]\w*$/;
harden(ym);
var Jb = /^@@(.*)$/;
harden(Jb);
var Li = (e, t = !1, r = []) => {
let o = (l) => {
if (!Je(l))
if ((assert.typeof(l, "object"), assert(l !== null), Ie in l)) {
let u = l[Ie];
switch (
(typeof u == "string" ||
f`invalid qclass typeof ${x(typeof u)}`,
assert(!Hi(l)),
l["@qclass"])
) {
case "undefined":
case "NaN":
case "Infinity":
case "-Infinity":
return;
case "bigint": {
let { digits: p } = l;
typeof p == "string" ||
f`invalid digits typeof ${x(typeof p)}`;
return;
}
case "@@asyncIterator":
return;
case "symbol": {
let { name: p } = l;
assert.typeof(p, "string");
let y = Fr(p);
assert.typeof(y, "symbol");
return;
}
case "tagged": {
let { tag: p, payload: y } = l;
(assert.typeof(p, "string"), o(y));
return;
}
case "slot": {
let { index: p, iface: y } = l;
(assert.typeof(p, "number"),
Re(p),
y !== void 0 && assert.typeof(y, "string"));
return;
}
case "hilbert": {
let { original: p, rest: y } = l;
if (
("original" in l || f`Invalid Hilbert Hotel encoding ${l}`,
o(p),
"rest" in l)
) {
if (typeof y != "object")
throw f`Rest ${y} encoding must be an object`;
if (y === null)
throw f`Rest ${y} encoding must not be null`;
if (Hi(y)) throw f`Rest ${y} encoding must not be an array`;
if (Ie in y)
throw f`Rest encoding ${y} must not contain ${x(Ie)}`;
let b = _d(y);
for (let m of b)
(typeof m == "string" ||
f`Property name ${m} of ${l} must be a string`,
o(y[m]));
}
return;
}
case "error": {
let { name: p, message: y } = l;
if (typeof p != "string")
throw f`invalid error name typeof ${x(typeof p)}`;
(br(p) !== void 0 ||
f`Must be the name of an Error constructor ${p}`,
typeof y == "string" ||
f`invalid error message typeof ${x(typeof y)}`);
return;
}
default:
assert.fail(V`unrecognized ${x(Ie)} ${x(u)}`, TypeError);
}
} else if (Hi(l)) {
let { length: u } = l;
for (let p = 0; p < u; p += 1) o(l[p]);
} else {
let u = _d(l);
for (let p of u) {
if (typeof p != "string")
throw f`Property name ${p} of ${l} must be a string`;
o(l[p]);
}
}
},
a = (t ? lC : Kb)(),
i = (l) => d(l),
c = (l, u) => {
(a.line(),
l === "__proto__"
? a.next('["__proto__"]:')
: ym.test(l)
? a.next(`${l}:`)
: a.next(`${Wi(l)}:`),
i(u),
a.next(","));
},
d = (l) => {
if (Je(l)) return a.next(Wi(l));
if ((assert.typeof(l, "object"), assert(l !== null), Ie in l)) {
let u = l[Ie];
switch (
(assert.typeof(u, "string"), assert(!Hi(l)), l["@qclass"])
) {
case "undefined":
case "NaN":
case "Infinity":
case "-Infinity":
return a.next(u);
case "bigint": {
let { digits: p } = l;
return (assert.typeof(p, "string"), a.next(`${BigInt(p)}n`));
}
case "@@asyncIterator":
return a.next("Symbol.asyncIterator");
case "symbol": {
let { name: p } = l;
assert.typeof(p, "string");
let y = Fr(p);
assert.typeof(y, "symbol");
let b = _t(y);
if (b === void 0) {
let m = Jb.exec(p);
assert(m !== null);
let v = m[1];
return (
assert(Symbol[v] === y),
assert(ym.test(v)),
a.next(`Symbol.${v}`)
);
}
return a.next(`passableSymbolForName(${Wi(b)})`);
}
case "tagged": {
let { tag: p, payload: y } = l;
return (
a.next(`makeTagged(${Wi(p)}`),
a.next(","),
i(y),
a.next(")")
);
}
case "slot": {
let { iface: p } = l,
y = Number(Re(l.index)),
b = (m) => {
let v = a;
try {
return ((a = Kb()), i(m), a.done());
} finally {
a = v;
}
};
if (y < r.length) {
let m = b(r[y]);
return p === void 0
? a.next(`slotToVal(${m})`)
: a.next(`slotToVal(${m},${b(p)})`);
}
return p === void 0
? a.next(`slot(${y})`)
: a.next(`slot(${y},${b(p)})`);
}
case "hilbert": {
let { original: p, rest: y } = l;
if ((a.open("{"), c(Ie, p), "rest" in l)) {
(assert.typeof(y, "object"), assert(y !== null));
let b = _d(y);
for (let m of b) {
if (typeof m != "string")
throw f`Property name ${x(m)} of ${y} must be a string`;
c(m, y[m]);
}
}
return a.close("}");
}
case "error": {
let {
name: p,
message: y,
cause: b = void 0,
errors: m = void 0,
} = l;
return (
b === void 0 ||
f`error cause not yet implemented in marshal-justin`,
p !== "AggregateError" ||
f`AggregateError not yet implemented in marshal-justin`,
m === void 0 ||
f`error errors not yet implemented in marshal-justin`,
a.next(`${p}(${Wi(y)})`)
);
}
default:
throw assert.fail(V`unrecognized ${x(Ie)} ${x(u)}`, TypeError);
}
} else if (Hi(l)) {
let { length: u } = l;
if (u === 0) return a.next("[]");
a.open("[");
for (let p = 0; p < u; p += 1) (a.line(), i(l[p]), a.next(","));
return a.close("]");
} else {
let u = _d(l);
if (u.length === 0) return a.next("{}");
a.open("{");
for (let p of u) c(p, l[p]);
return a.close("}");
}
};
return (o(e), i(e), a.done());
};
harden(Li);
var gm = (e, t = !0) => {
let r = 0,
o = (d) => `s${r++}`,
{ toCapData: n } = At(o),
{ body: a, slots: i } = n(e),
c = JSON.parse(a);
return Li(c, t, i);
};
harden(gm);
var Sr = (e) => `\`${gm(harden(e), !0)}\``;
harden(Sr);
var { isArray: pC } = Array,
{ fromEntries: mC, is: vm } = Object,
{ ownKeys: fC } = Reflect,
yC = /[\x00-\x1F]/,
ft = (e, t) => (t === 0 ? e : e.substring(t)),
Ft = (e) => harden(fC(e).sort().reverse());
harden(Ft);
var xr = (e, t) => harden(t.map((r) => e[r]));
harden(xr);
var Vb = Array(16)
.fill(void 0)
.map((e, t) => "0".repeat(t)),
Sm = (e, t) => {
let r = `${e}`,
o = t - r.length;
return o === 0 ? r : (assert(o > 0 && o < Vb.length), `${Vb[o]}${r}`);
};
harden(Sm);
var xm = new Float64Array(1),
Lb = new BigUint64Array(xm.buffer),
gC = "fff8000000000000",
hC = (e) => {
if (vm(e, -0)) e = 0;
else if (vm(e, NaN)) return `f${gC}`;
xm[0] = e;
let t = Lb[0];
return (
e < 0 ? (t ^= 0xffffffffffffffffn) : (t ^= 0x8000000000000000n),
`f${Sm(t.toString(16), 16)}`
);
},
bC = (e, t = 0) => {
e.charAt(t) === "f" || f`Encoded number expected: ${e}`;
let r = BigInt(`0x${ft(e, t + 1)}`);
(e.charAt(t + 1) < "8"
? (r ^= 0xffffffffffffffffn)
: (r ^= 0x8000000000000000n),
(Lb[0] = r));
let o = xm[0];
return (!vm(o, -0) || f`Unexpected negative zero: ${ft(e, t)}`, o);
},
vC = (e) => {
let r = (e < 0n ? -e : e).toString().length,
o = r.toString().length;
return e < 0n
? `n${"#".repeat(o - 1)}${(10 ** o - r).toString().padStart(o, "0")}:${(10n ** BigInt(r) + e).toString().padStart(r, "0")}`
: `p${"~".repeat(o - 1)}${r}:${e}`;
},
SC = /([0-9]+)(:([0-9]+$|)|)/s,
xC = (e) => {
let t = e.charAt(0);
t === "p" || t === "n" || f`Encoded bigint expected: ${e}`;
let {
index: r,
1: o,
2: n,
3: a,
} = e.match(SC) || f`Digit count expected: ${e}`;
o.length === r || f`Unary-prefixed decimal digit count expected: ${e}`;
let i = parseInt(o, 10);
(t === "n" && (i = 10 ** r - i),
n.charAt(0) === ":" || f`Separator expected: ${e}`,
a.length === i || f`Fixed-length digit sequence expected: ${e}`);
let c = BigInt(a);
return (t === "n" && (c = -(10n ** BigInt(i) - c)), c);
},
Am = Array(34)
.fill(void 0)
.map((e, t) => {
switch (String.fromCharCode(t)) {
case " ":
return "!_";
case "!":
return "!|";
default:
return `!${String.fromCharCode(t + 33)}`;
}
});
Am[94] = "_@";
Am[95] = "__";
var AC = (e) => e.replace(/[\0-!^_]/g, (t) => Am[t.charCodeAt(0)]),
Hb = (e) =>
e.replace(/([\0-!_])(.|\n)?/g, (t, r, o) => {
switch (t) {
case "!_":
return " ";
case "!|":
return "!";
case "_@":
return "^";
case "__":
return "_";
default: {
let n = o;
return (
(r === "!" && o !== void 0 && n >= "!" && n <= "@") ||
f`invalid string escape: ${x(t)}`,
String.fromCharCode(n.charCodeAt(0) - 33)
);
}
}
}),
wC = (e) => e,
PC = (e) => e,
kC = (e, t) => {
let r = ["^"];
for (let o of e) {
let n = t(o);
r.push(n, " ");
}
return r.join("");
},
hm = (e, t, r = 0) => {
let o = [],
n = 0,
a = r + 1,
i = r + 1;
for (let { 0: c, index: d } of e.matchAll(/[\^ ]/g)) {
let l = d;
(l <= r
? l === r && (c === "^" || f`Encoded array expected: ${ft(e, r)}`)
: c === "^"
? (n += 1)
: (l === a &&
((n -= 1),
n >= 0 ||
f`unexpected array element terminator: ${e.slice(r, l + 2)}`),
n === 0 && (o.push(t(e.slice(i, l))), (i = l + 1))),
(a = l + 1));
}
return (
n === 0 || f`unterminated array: ${ft(e, r)}`,
a === e.length || f`unterminated array element: ${ft(e, i)}`,
harden(o)
);
},
IC = (e, t) => {
let r = ["["];
for (let o of e) {
let n = t(o);
for (let a of n) ((a === "\0" || a === "") && r.push(""), r.push(a));
r.push("\0");
}
return r.join("");
},
TC = (e, t, r = 0) => {
let o = [],
n = [],
a = r + 1,
i = !1;
for (let c of e) {
if (a > 0)
((a -= 1),
a === 0 && (c === "[" || f`Encoded array expected: ${ft(e, r)}`));
else if (i)
(c === "\0" ||
c === "" ||
f`Unexpected character after u0001 escape: ${c}`,
n.push(c));
else if (c === "\0") {
let d = n.join("");
n.length = 0;
let l = t(d);
o.push(l);
} else if (c === "") {
i = !0;
continue;
} else n.push(c);
i = !1;
}
return (
!i || f`unexpected end of encoding ${ft(e, r)}`,
n.length === 0 || f`encoding terminated early: ${ft(e, r)}`,
harden(o)
);
},
UC = (e, t) => (
f`encodePassable(byteArray) not yet implemented: ${e}`,
""
),
CC = (e, t, r) => {
let o = Ft(e),
n = xr(e, o);
return `(${t(harden([o, n]), r)}`;
},
RC = (e, t, r, o = 0) => {
assert(e.charAt(o) === "(");
let n = t(e, r, o + 1);
n.length === 2 || f`expected keys,values pair: ${ft(e, o)}`;
let [a, i] = n;
(ce(a) === "copyArray" &&
ce(i) === "copyArray" &&
a.length === i.length &&
a.every((l) => typeof l == "string")) ||
f`not a valid record encoding: ${ft(e, o)}`;
let c = a.map((l, u) => [l, i[u]]),
d = harden(mC(c));
return (vr(d, "decoded record"), d);
},
OC = (e, t, r) => `:${t(harden([$e(e), e.payload]), r)}`,
EC = (e, t, r, o = 0) => {
assert(e.charAt(o) === ":");
let n = t(e, r, o + 1);
n.length === 2 || f`expected tag,payload pair: ${ft(e, o)}`;
let [a, i] = n;
return (
ce(a) === "string" || f`not a valid tagged encoding: ${ft(e, o)}`,
Ce(a, i)
);
},
DC = (e, t) => (o, n) => {
let a = e(o, n);
return (
(typeof a == "string" && a.charAt(0) === "r") ||
f`Remotable encoding must start with "r": ${a}`,
t(a, "Remotable"),
a
);
},
NC = (e, t) => (o, n) => {
let a = e(o, n);
return (
(typeof a == "string" && a.charAt(0) === "?") ||
f`Promise encoding must start with "?": ${a}`,
t(a, "Promise"),
a
);
},
BC = (e, t) => (o, n) => {
let a = e(o, n);
return (
(typeof a == "string" && a.charAt(0) === "!") ||
f`Error encoding must start with "!": ${a}`,
t(a, "Error"),
a
);
},
Wb = (e, t, r) => {
let {
encodeRemotable: o,
encodePromise: n,
encodeError: a,
verifyEncoding: i = () => {},
} = r,
c = DC(o, i),
d = NC(n, i),
l = BC(a, i),
u = (p) => {
if (mo(p)) return l(p, u);
let y = ce(p);
switch (y) {
case "null":
return "v";
case "undefined":
return "z";
case "number":
return hC(p);
case "string":
return `s${e(p)}`;
case "boolean":
return `b${p}`;
case "bigint":
return vC(p);
case "remotable":
return c(p, u);
case "error":
return l(p, u);
case "promise":
return d(p, u);
case "symbol": {
let b = _t(p);
return (assert.typeof(b, "string"), `y${e(b)}`);
}
case "copyArray":
return t(p, u);
case "byteArray":
return UC(p, u);
case "copyRecord":
return CC(p, t, u);
case "tagged":
return OC(p, t, u);
default:
throw f`a ${x(y)} cannot be used as a collection passable`;
}
};
return u;
},
MC = {
decodeRemotable: (e, t) => {},
decodePromise: (e, t) => {},
decodeError: (e, t) => {},
},
bm = (e, t, r) => {
let { decodeRemotable: o, decodePromise: n, decodeError: a } = r,
i = (c, d = 0) => {
switch (c.charAt(d)) {
case "v":
return null;
case "z":
return;
case "f":
return bC(c, d);
case "s":
return e(ft(c, d + 1));
case "b": {
let l = ft(c, d + 1);
if (l === "true") return !0;
if (l === "false") return !1;
throw f`expected encoded boolean to be "btrue" or "bfalse": ${l}`;
}
case "n":
case "p":
return xC(ft(c, d));
case "r":
return o(ft(c, d), i);
case "?":
return n(ft(c, d), i);
case "!":
return a(ft(c, d), i);
case "y": {
let l = e(ft(c, d + 1));
return Fr(l);
}
case "[":
case "^":
return t(c, i, d);
case "(":
return RC(c, t, i, d);
case ":":
return EC(c, t, i, d);
default:
throw f`invalid database key: ${ft(c, d)}`;
}
};
return i;
},
Oa = (e = {}) => {
let {
encodeRemotable: t = (m, v) => f`remotable unexpected: ${m}`,
encodePromise: r = (m, v) => f`promise unexpected: ${m}`,
encodeError: o = (m, v) => f`error unexpected: ${m}`,
format: n = "legacyOrdered",
decodeRemotable: a = (m, v) => f`remotable unexpected: ${m}`,
decodePromise: i = (m, v) => f`promise unexpected: ${m}`,
decodeError: c = (m, v) => f`error unexpected: ${m}`,
} = e,
d,
l = {
encodeRemotable: t,
encodePromise: r,
encodeError: o,
format: n,
};
if (n === "compactOrdered") {
let m = bm(Hb, hm, MC),
h = Wb(AC, kC, {
...l,
verifyEncoding: (g, S) => {
!g.match(yC) ||
f`${tt(S)} encoding must not contain a C0 control character: ${g}`;
let w = hm(`^v ${g} v `, m);
(pC(w) && w.length === 3 && w[0] === null && w[2] === null) ||
f`${tt(S)} encoding must be embeddable: ${g}`;
},
});
d = (g) => `~${h(g)}`;
} else if (n === "legacyOrdered") d = Wb(wC, IC, l);
else throw f`Unrecognized format: ${x(n)}`;
let u = { decodeRemotable: a, decodePromise: i, decodeError: c },
p = bm(Hb, hm, u),
y = bm(PC, TC, u),
b = (m) => (m.charAt(0) === "~" ? p(m, 1) : y(m));
return harden({ encodePassable: d, decodePassable: b });
};
harden(Oa);
var qb = (e) => {
let { encodePassable: t } = Oa(e);
return t;
};
harden(qb);
var jb = (e) => {
let { decodePassable: t } = Oa(e);
return t;
};
harden(jb);
var Gb = (e) => e.charAt(0) === "r";
harden(Gb);
var Fd = {
error: "!",
copyRecord: "(",
tagged: ":",
promise: "?",
copyArray: "[^",
byteArray: "a",
boolean: "b",
number: "f",
bigint: "np",
remotable: "r",
string: "s",
null: "v",
symbol: "y",
undefined: "z",
};
Object.setPrototypeOf(Fd, null);
harden(Fd);
var { isNaN: Kd } = Number,
{ entries: $C, fromEntries: _C, setPrototypeOf: FC, is: KC } = Object,
Qb = hr("ENDO_RANK_STRINGS", "utf16-code-unit-order", [
"unicode-code-point-order",
"error-if-order-choice-matters",
]),
JC = (e, t) => e === t || KC(e, t),
qi = (e, t) => (e < t ? -1 : e === t ? 0 : 1);
harden(qi);
var Jd = (e, t) => {
let r = e[Symbol.iterator](),
o = t[Symbol.iterator]();
for (;;) {
let { value: n } = r.next(),
{ value: a } = o.next();
if (n === void 0 && a === void 0) return 0;
if (n === void 0) return -1;
if (a === void 0) return 1;
let i = n.codePointAt(0),
c = a.codePointAt(0);
if (i < c) return -1;
if (i > c) return 1;
}
};
harden(Jd);
var Ea = (e, t) =>
e < t
? -1
: e > t
? 1
: Kd(e) === Kd(t)
? 0
: Kd(t)
? -1
: (assert(Kd(e)), 1),
ji = _C(
$C(Fd)
.sort(([e, t], [r, o]) => qi(t, o))
.map(([e, t], r) => {
t === t.split("").sort().join("") ||
f`unsorted prefixes for passStyle ${x(e)}: ${x(t)}`;
let o = [
t.charAt(0),
String.fromCharCode(t.charCodeAt(t.length - 1) + 1),
];
return [e, { index: r, cover: o }];
}),
);
FC(ji, null);
harden(ji);
var st = (e) => ji[e].cover;
harden(st);
var Vd = new WeakMap(),
zb = new WeakMap(),
Zb = (e = (t, r) => NaN) => {
let t = (n, a) => {
if (JC(n, a)) return 0;
let i = ce(n),
c = ce(a);
if (i !== c) return Ea(ji[i].index, ji[c].index);
switch (i) {
case "remotable":
return e(n, a);
case "undefined":
case "null":
case "error":
case "promise":
return 0;
case "boolean":
case "bigint":
return qi(n, a);
case "string":
switch (Qb) {
case "utf16-code-unit-order":
return qi(n, a);
case "unicode-code-point-order":
return Jd(n, a);
case "error-if-order-choice-matters": {
let d = qi(n, a),
l = Jd(n, a);
return (
d === l ||
f`Comparisons differed: ${n} vs ${a}, ${x(d)} vs ${x(l)}`,
d
);
}
default:
throw f`Unexpected ENDO_RANK_STRINGS ${x(Qb)}`;
}
case "symbol":
return t(_t(n), _t(a));
case "number":
return Ea(n, a);
case "copyRecord": {
let d = Ft(n),
l = Ft(a),
u = t(d, l);
if (u !== 0) return u;
let p = xr(n, d),
y = xr(a, l);
return t(p, y);
}
case "copyArray": {
let d = Math.min(n.length, a.length);
for (let l = 0; l < d; l += 1) {
let u = t(n[l], a[l]);
if (u !== 0) return u;
}
return t(n.length, a.length);
}
case "byteArray": {
let { byteLength: d } = n,
{ byteLength: l } = a;
if (d < l) return -1;
if (d > l) return 1;
let u =
Object.getPrototypeOf(n) === ArrayBuffer.prototype
? new Uint8Array(n)
: new Uint8Array(n.slice(0)),
p =
Object.getPrototypeOf(a) === ArrayBuffer.prototype
? new Uint8Array(a)
: new Uint8Array(a.slice(0));
for (let y = 0; y < d; y += 1) {
let b = u[y],
m = p[y];
if (b < m) return -1;
if (b > m) return 1;
}
return 0;
}
case "tagged": {
let d = t($e(n), $e(a));
return d !== 0 ? d : t(n.payload, a.payload);
}
default:
throw f`Unrecognized passStyle: ${x(i)}`;
}
},
r = (n, a) => t(n, a) || 0,
o = (n, a) => r(a, n);
return (
Vd.set(r, new WeakSet()),
Vd.set(o, new WeakSet()),
zb.set(r, o),
zb.set(o, r),
harden({ comparator: r, antiComparator: o })
);
};
var Rn = (e, t) => {
let r = Vd.get(t);
if ((assert(r !== void 0), r.has(e))) return !0;
assert(ce(e) === "copyArray");
for (let o = 1; o < e.length; o += 1)
if (t(e[o - 1], e[o]) >= 1) return !1;
return (r.add(e), !0);
};
harden(Rn);
var go = (e, t) => Rn(e, t) || f`Must be rank sorted: ${e} vs ${wt(e, t)}`;
harden(go);
var wt = (e, t) => {
let r;
if (Array.isArray(e)) {
if ((harden(e), Rn(e, t))) return e;
r = [...e];
} else r = Array.from(e, harden);
let o = r.sort(t);
if (t(!0, void 0) > 0) {
let a = o.length - 1;
for (; a >= 0 && o[a] === void 0; ) a -= 1;
let i = o.length - a - 1;
i > 0 && i < o.length && (o.copyWithin(i, 0), o.fill(void 0, 0, i));
}
harden(o);
let n = Vd.get(t);
return (assert(n !== void 0), n.add(o), o);
};
harden(wt);
var Yb = (e, t, r, o = "leftMost") => {
go(e, t);
let n = 0,
a = e.length;
for (; n < a; ) {
let i = Math.floor((n + a) / 2),
c = t(e[i], r);
c <= -1 || (c === 0 && o === "rightMost")
? (n = i + 1)
: (assert(c >= 1 || (c === 0 && o === "leftMost")), (a = i));
}
return o === "leftMost" ? n : a - 1;
},
VC = (e, t, [r, o]) => {
go(e, t);
let n = Yb(e, t, r, "leftMost"),
a = Yb(e, t, o, "rightMost");
return [n, a];
};
harden(VC);
var W4 = harden(["", "{"]),
HC = (e, [t, r]) =>
harden({
[Symbol.iterator]: () => {
let n = t;
return harden({
next: () => {
if (n <= r) {
let a = e[n];
return ((n += 1), harden({ value: [n, a], done: !1 }));
} else return harden({ value: void 0, done: !0 });
},
});
},
});
harden(HC);
var Xb = (e, t, r) => (e(t, r) >= 0 ? t : r),
ev = (e, t, r) => (e(t, r) <= 0 ? t : r),
Hd = (e, t) => {
let r = ([o, n], [a, i]) => [ev(e, o, a), Xb(e, n, i)];
return t.reduce(r, ["{", ""]);
};
harden(Hd);
var wm = (e, t) => {
let r = ([o, n], [a, i]) => [Xb(e, o, a), ev(e, n, i)];
return t.reduce(r, ["", "{"]);
},
{ comparator: nr, antiComparator: Pt } = Zb(),
Qt = (e = !1) => {
let t = 0,
r = e ? WeakMap : Map,
o = new r(),
n = (i) => (o.has(i) ? o.get(i) : ((t += 1), o.set(i, t), t));
return Zb((i, c) => nr(n(i), n(c)));
};
harden(Qt);
var tv = (e, t, r) => {
((t = t || Qt().antiComparator), (e = wt(e, t)));
let { length: o } = e;
for (let n = 1; n < o; n += 1) {
let a = e[n - 1],
i = e[n];
if (t(a, i) === 0) return r(!1, V`value has duplicate keys: ${a}`);
}
return !0;
},
rv = (e, t = void 0) => {
tv(e, t, Te);
},
Gi = (e, t) =>
ce(e) !== "copyArray"
? t(!1, V`The keys of a copySet or copyMap must be a copyArray: ${e}`)
: Rn(e, Pt)
? tv(e, void 0, t)
: t(
!1,
V`The keys of a copySet or copyMap must be sorted in reverse rank order: ${e}`,
);
harden(Gi);
var ov = (e) => {
Gi(e, Te);
};
harden(ov);
var Da = (e) => {
let t = wt(e, Pt);
return (ov(t), t);
};
harden(Da);
var Qi = (e) => Ce("copySet", Da(e));
harden(Qi);
var nv = (e, t, r) => {
((t = t || Qt().antiComparator), (e = wt(e, t)));
let { length: o } = e;
for (let n = 1; n < o; n += 1) {
let a = e[n - 1][0],
i = e[n][0];
if (t(a, i) === 0) return r(!1, V`value has duplicate keys: ${a}`);
}
return !0;
},
sv = (e, t = void 0) => {
nv(e, t, Te);
},
Wd = (e, t) => {
if (ce(e) !== "copyArray")
return t(!1, V`The entries of a copyBag must be a copyArray: ${e}`);
if (!Rn(e, Pt))
return t(
!1,
V`The entries of a copyBag must be sorted in reverse rank order: ${e}`,
);
for (let r of e) {
if (
ce(r) !== "copyArray" ||
r.length !== 2 ||
typeof r[1] != "bigint"
)
return t(
!1,
V`Each entry of a copyBag must be pair of a key and a bigint representing a count: ${r}`,
);
if (r[1] < 1)
return t(
!1,
V`Each entry of a copyBag must have a positive count: ${r}`,
);
}
return nv(e, void 0, t);
};
harden(Wd);
var av = (e) => {
Wd(e, Te);
};
harden(av);
var Ld = (e) => {
let t = wt(e, Pt);
return (av(t), t);
};
harden(Ld);
var zi = (e) => Ce("copyBag", Ld(e));
harden(zi);
var { ownKeys: WC } = Reflect,
qd = (e, t) => {
if (ms(e)) return !0;
let r = ce(e);
return r === "remotable"
? !0
: t(!1, V`A ${x(r)} cannot be a scalar key: ${e}`);
},
LC = (e) => qd(e, Xe);
harden(LC);
var fs = (e) => {
qd(e, Te);
};
harden(fs);
var iv = new WeakSet(),
sr = (e, t) => {
if (ms(e) || iv.has(e)) return !0;
let r = QC(e, t);
return (r && iv.add(e), r);
};
harden(sr);
var ho = (e) => sr(e, Xe);
harden(ho);
var bo = (e) => {
sr(e, Te);
};
harden(bo);
var cv = new WeakSet(),
Na = (e, t) => {
if (cv.has(e)) return !0;
let r =
((ce(e) === "tagged" && $e(e) === "copySet") ||
t(!1, V`Not a copySet: ${e}`)) &&
Gi(e.payload, t) &&
sr(e.payload, t);
return (r && cv.add(e), r);
};
harden(Na);
var Ba = (e) => Na(e, Xe);
harden(Ba);
var jd = (e) => {
Na(e, Te);
};
harden(jd);
var vo = (e) => (jd(e), e.payload);
harden(vo);
var qC = (e, t) => vo(e).every((r, o) => t(r, o));
harden(qC);
var Ar = (e) => {
let t = Qi(e);
return (jd(t), t);
};
harden(Ar);
var dv = new WeakSet(),
Ma = (e, t) => {
if (dv.has(e)) return !0;
let r =
((ce(e) === "tagged" && $e(e) === "copyBag") ||
t(!1, V`Not a copyBag: ${e}`)) &&
Wd(e.payload, t) &&
sr(e.payload, t);
return (r && dv.add(e), r);
};
harden(Ma);
var uv = (e) => Ma(e, Xe);
harden(uv);
var Gd = (e) => {
Ma(e, Te);
};
harden(Gd);
var On = (e) => (Gd(e), e.payload);
harden(On);
var jC = (e, t) => On(e).every((r, o) => t(r, o));
harden(jC);
var qo = (e) => {
let t = zi(e);
return (Gd(t), t);
};
harden(qo);
var Pm = (e) => {
let t = Qt().antiComparator,
r = wt(e, t),
o = [];
for (let n = 0; n < r.length; ) {
let a = r[n],
i = n + 1;
for (; i < r.length && t(a, r[i]) === 0; ) i += 1;
(o.push([a, BigInt(i - n)]), (n = i));
}
return qo(o);
};
harden(Pm);
var lv = new WeakSet(),
$a = (e, t) => {
if (lv.has(e)) return !0;
if (!(ce(e) === "tagged" && $e(e) === "copyMap"))
return t(!1, V`Not a copyMap: ${e}`);
let { payload: r } = e;
if (ce(r) !== "copyRecord")
return t(!1, V`A copyMap's payload must be a record: ${e}`);
let { keys: o, values: n, ...a } = r,
i =
(WC(a).length === 0 ||
t(
!1,
V`A copyMap's payload must only have .keys and .values: ${e}`,
)) &&
Gi(o, t) &&
sr(o, t) &&
(ce(n) === "copyArray" ||
t(!1, V`A copyMap's .values must be a copyArray: ${e}`)) &&
(o.length === n.length ||
t(
!1,
V`A copyMap must have the same number of keys and values: ${e}`,
));
return (i && lv.add(e), i);
};
harden($a);
var _a = (e) => $a(e, Xe);
harden(_a);
var ys = (e) => {
$a(e, Te);
};
harden(ys);
var Qd = (e) => (ys(e), e.payload.keys);
harden(Qd);
var pv = (e) => (ys(e), e.payload.values);
harden(pv);
var Yi = (e) => {
ys(e);
let {
payload: { keys: t, values: r },
} = e;
return harden(t.map((o, n) => [o, r[n]]));
};
harden(Yi);
var gs = (e) => {
ys(e);
let {
payload: { keys: t, values: r },
} = e,
{ length: o } = t;
return se("CopyMap entries iterable", {
[Symbol.iterator]: () => {
let n = 0;
return se("CopyMap entries iterator", {
next: () => {
let a;
return n < o
? ((a = harden({ done: !1, value: [t[n], r[n]] })), (n += 1), a)
: ((a = harden({ done: !0, value: void 0 })), a);
},
});
},
});
};
harden(gs);
var GC = (e, t) => Qd(e).every((r, o) => t(r, o));
harden(GC);
var mv = (e, t) => pv(e).every((r, o) => t(r, o));
harden(mv);
var zd = (e) => Ce("copySet", e.payload.keys);
harden(zd);
var jo = (e) => {
let t = wt(e, Pt),
r = t.map(([a, i]) => a),
o = t.map(([a, i]) => i),
n = Ce("copyMap", { keys: r, values: o });
return (ys(n), n);
};
harden(jo);
var QC = (e, t) => {
let r = (n) => sr(n, t),
o = ce(e);
switch (o) {
case "remotable":
return !0;
case "copyRecord":
return Object.values(e).every(r);
case "copyArray":
return e.every(r);
case "tagged": {
let n = $e(e);
switch (n) {
case "copySet":
return Na(e, t);
case "copyBag":
return Ma(e, t);
case "copyMap":
return $a(e, t) && mv(e, r);
default:
return (
t !== Xe &&
t(!1, V`A passable tagged ${x(n)} is not a key: ${e}`)
);
}
}
case "error":
case "promise":
return t(!1, V`A ${x(o)} cannot be a key`);
default:
throw f`unexpected passStyle ${x(o)}: ${e}`;
}
};
var Fa = (e) => {
let t = harden({ [Symbol.iterator]: () => t, next: e });
return t;
};
harden(Fa);
var km = (e) => {
let { length: t } = e,
r = 0;
return Fa(() => {
let o;
return r < t
? ((o = e[r]), (r += 1), harden({ done: !1, value: o }))
: harden({ done: !0, value: o });
});
};
harden(km);
var Im = (e, t, r) => {
go(e, t);
let { length: o } = e,
n = 0,
a;
return Fa(() => {
if (a) {
let i = a.next();
if (!i.done) return i;
a = void 0;
}
if (n < o) {
let i = e[n],
c = n + 1;
for (; c < o && t(i[0], e[c][0]) === 0; ) c += 1;
if (c === n + 1) return ((n = c), harden({ done: !1, value: i }));
let d = e.slice(n, c);
n = c;
let l = wt(d, r);
for (let u = 1; u < l.length; u += 1) {
let [p] = l[u - 1],
[y] = l[u];
Math.sign(r(p, y)) || f`Duplicate entry key: ${p}`;
}
return ((a = km(l)), a.next());
}
return harden({ done: !0, value: void 0 });
});
};
harden(Im);
var Yd = (e, t, r, o) => {
let n = r(e),
a = r(t),
i = Qt().antiComparator,
c = Im(n, Pt, i),
d = Im(a, Pt, i),
l,
u,
p,
y,
b,
m,
v = [void 0, void 0],
h = () => {
!l || f`Internal: nextX must not be called once done`;
let S = p;
return (({ done: l, value: [u, p] = v } = c.next()), S);
};
h();
let g = () => {
!y || f`Internal: nextY must not be called once done`;
let S = m;
return (({ done: y, value: [b, m] = v } = d.next()), S);
};
return (
g(),
Fa(() => {
let S = !1,
w;
if (l && y) ((S = !0), (w = [void 0, o, o]));
else if (l) w = [b, o, g()];
else if (y) w = [u, h(), o];
else {
let I = i(u, b);
if (I === 0) w = [u, h(), g()];
else if (I < 0) w = [u, h(), o];
else if (I > 0) w = [b, o, g()];
else throw f`Unexpected key comparison ${x(I)} for ${u} vs ${b}`;
}
return harden({ done: S, value: w });
})
);
};
harden(Yd);
var Zi = (e, t, r) =>
harden((o, n) => {
let a = Yd(o, n, e, t),
i = !1,
c = !1;
for (let [d, l, u] of a) {
let p = r(l, u);
if (p !== 0) {
if (p < 0) c = !0;
else if (p > 0) i = !0;
else
return (
Number.isNaN(p) ||
f`Unexpected value comparison ${x(p)} for ${l} vs ${u}`,
NaN
);
if (i && c) return NaN;
}
}
return i ? 1 : c ? -1 : 0;
});
harden(Zi);
var Zd = Zi((e) => harden(vo(e).map((t) => [t, 1])), 0, Ea);
harden(Zd);
var Xd = Zi(On, 0n, Ea);
harden(Xd);
var Xi = Symbol("absent"),
zC = Zi(Yi, Xi, (e, t) => {
if (e === Xi && t === Xi)
throw f`Internal: Unexpected absent entry pair`;
return e === Xi ? -1 : t === Xi ? 1 : Kr(e, t);
});
harden(zC);
var Kr = (e, t) => {
(bo(e), bo(t));
let r = ce(e),
o = ce(t);
if (r !== o) return NaN;
switch (r) {
case "undefined":
case "null":
case "boolean":
case "bigint":
case "string":
case "byteArray":
case "symbol":
return nr(e, t);
case "number": {
let n = nr(e, t);
return n === 0
? 0
: Number.isNaN(e) || Number.isNaN(t)
? (assert(!Number.isNaN(e) || !Number.isNaN(t)), NaN)
: n;
}
case "remotable":
return e === t ? 0 : NaN;
case "copyArray": {
let n = Math.min(e.length, t.length);
for (let a = 0; a < n; a += 1) {
let i = Kr(e[a], t[a]);
if (i !== 0) return i;
}
return nr(e.length, t.length);
}
case "copyRecord": {
let n = Ft(e),
a = Ft(t);
if (!ar(n, a)) return NaN;
let i = xr(e, n),
c = xr(t, a),
d = 0;
for (let l = 0; l < i.length; l += 1) {
let u = Kr(i[l], c[l]);
if (Number.isNaN(u)) return NaN;
if (d !== u && u !== 0)
if (d === 0) d = u;
else
return (
assert((d === -1 && u === 1) || (d === 1 && u === -1)),
NaN
);
}
return d;
}
case "tagged": {
let n = $e(e),
a = $e(t);
if (n !== a) return NaN;
switch (n) {
case "copySet":
return Zd(e, t);
case "copyBag":
return Xd(e, t);
case "copyMap":
throw f`Map comparison not yet implemented: ${e} vs ${t}`;
default:
throw f`unexpected tag ${x(n)}: ${e}`;
}
}
default:
throw f`unexpected passStyle ${x(r)}: ${e}`;
}
};
harden(Kr);
var ec = (e, t) => Kr(e, t) < 0;
harden(ec);
var tc = (e, t) => Kr(e, t) <= 0;
harden(tc);
var ar = (e, t) => Kr(e, t) === 0;
harden(ar);
var rc = (e, t) => Kr(e, t) >= 0;
harden(rc);
var oc = (e, t) => Kr(e, t) > 0;
harden(oc);
var fv = (e, t, r) => {
go(e, t);
let { length: o } = e,
n = 0,
a;
return harden({
[Symbol.iterator]: () =>
harden({
next: () => {
if (a) {
let i = a.next();
if (i.done) a = void 0;
else return i;
}
if (n < o) {
let i = e[n],
c = n + 1;
for (; c < o && t(i, e[c]) === 0; ) c += 1;
if (c === n + 1)
return ((n = c), harden({ done: !1, value: i }));
let d = e.slice(n, c);
n = c;
let l = wt(d, r);
return (rv(l, r), (a = l[Symbol.iterator]()), a.next());
} else return harden({ done: !0, value: null });
},
}),
});
},
yv = (e, t) => {
let r = Qt().antiComparator,
o = fv(e, Pt, r),
n = fv(t, Pt, r);
return harden({
[Symbol.iterator]: () => {
let a,
i,
c,
d,
l = o[Symbol.iterator](),
u = () => {
(!i || f`Internal: nextX should not be called once done`,
({ done: i, value: a } = l.next()));
};
u();
let p = n[Symbol.iterator](),
y = () => {
(!d || f`Internal: nextY should not be called once done`,
({ done: d, value: c } = p.next()));
};
return (
y(),
harden({
next: () => {
let b = !1,
m;
if (i && d) ((b = !0), (m = [null, 0n, 0n]));
else if (i) ((m = [c, 0n, 1n]), y());
else if (d) ((m = [a, 1n, 0n]), u());
else {
let v = r(a, c);
v === 0
? ((m = [a, 1n, 1n]), u(), y())
: v < 0
? ((m = [a, 1n, 0n]), u())
: (v > 0 || f`Internal: Unexpected comp ${x(v)}`,
(m = [c, 0n, 1n]),
y());
}
return harden({ done: b, value: m });
},
})
);
},
});
};
harden(yv);
var YC = (e) => {
for (let [t, r, o] of e) if (r === 0n) return !1;
return !0;
},
ZC = (e) => {
for (let [t, r, o] of e) if (r >= 1n && o >= 1n) return !1;
return !0;
},
XC = (e) => {
let t = !1,
r = !1;
for (let [o, n, a] of e)
if ((n === 0n && (t = !0), a === 0n && (r = !0), r && t)) return NaN;
return r
? 1
: t
? -1
: ((!r && !t) || f`Internal: Unexpected lone pair ${x([r, t])}`, 0);
},
e3 = (e) => {
let t = [];
for (let [r, o, n] of e)
(o >= 0n || n >= 0n || f`Internal: Unexpected count ${x(n)}`,
t.push(r));
return t;
},
t3 = (e) => {
let t = [];
for (let [r, o, n] of e)
(o === 0n || n === 0n || f`Sets must not have common elements: ${r}`,
o >= 1n || n >= 1n || f`Internal: Unexpected count ${x(n)}`,
t.push(r));
return t;
},
r3 = (e) => {
let t = [];
for (let [r, o, n] of e) o >= 1n && n >= 1n && t.push(r);
return t;
},
o3 = (e) => {
let t = [];
for (let [r, o, n] of e)
(o >= 1n || f`right element ${r} was not in left`,
n === 0n && t.push(r));
return t;
},
hs = (e) => (t, r) => e(yv(t, r)),
nc = hs(YC),
Tm = hs(ZC),
el = hs(XC),
Um = hs(e3),
sc = hs(t3),
Cm = hs(r3),
ac = hs(o3),
gv = (e) => (t, r) => e(t.payload, r.payload),
tl = (e) => (t, r) => Qi(e(t.payload, r.payload)),
rl = gv(nc),
hv = gv(Tm),
bv = tl(Um),
ol = tl(sc),
vv = tl(Cm),
nl = tl(ac);
var Sv = (e, t, r) => {
go(e, t);
let { length: o } = e,
n = 0,
a;
return harden({
[Symbol.iterator]: () =>
harden({
next: () => {
if (a) {
let i = a.next();
if (i.done) a = void 0;
else return i;
}
if (n < o) {
let i = e[n],
c = n + 1;
for (; c < o && t(i[0], e[c][0]) === 0; ) c += 1;
if (c === n + 1)
return ((n = c), harden({ done: !1, value: i }));
let d = e.slice(n, c);
n = c;
let l = wt(d, r);
return (sv(l, r), (a = l[Symbol.iterator]()), a.next());
} else return harden({ done: !0, value: [null, 0n] });
},
}),
});
},
xv = (e, t) => {
let r = Qt().antiComparator,
o = Sv(e, Pt, r),
n = Sv(t, Pt, r);
return harden({
[Symbol.iterator]: () => {
let a,
i,
c,
d,
l,
u,
p = o[Symbol.iterator](),
y = () => {
(!c || f`Internal: nextX should not be called once done`,
({
done: c,
value: [a, i],
} = p.next()));
};
y();
let b = n[Symbol.iterator](),
m = () => {
(!u || f`Internal: nextY should not be called once done`,
({
done: u,
value: [d, l],
} = b.next()));
};
return (
m(),
harden({
next: () => {
let v = !1,
h;
if (c && u) ((v = !0), (h = [null, 0n, 0n]));
else if (c) ((h = [d, 0n, l]), m());
else if (u) ((h = [a, i, 0n]), y());
else {
let g = r(a, d);
g === 0
? ((h = [a, i, l]), y(), m())
: g < 0
? ((h = [a, i, 0n]), y())
: (g > 0 || f`Internal: Unexpected comp ${x(g)}`,
(h = [d, 0n, l]),
m());
}
return harden({ done: v, value: h });
},
})
);
},
});
};
harden(xv);
var n3 = (e) => {
for (let [t, r, o] of e) if (r < o) return !1;
return !0;
},
s3 = (e) => {
for (let [t, r, o] of e) if (r >= 1n && o >= 1n) return !1;
return !0;
},
a3 = (e) => {
let t = [];
for (let [r, o, n] of e) t.push([r, o + n]);
return t;
},
i3 = (e) => {
let t = [];
for (let [r, o, n] of e) {
let a = o <= n ? o : n;
t.push([r, a]);
}
return t;
},
c3 = (e) => {
let t = [];
for (let [r, o, n] of e) {
let a = o - n;
(a >= 0n || f`right element ${r} was not in left`,
a >= 1n && t.push([r, a]));
}
return t;
},
ic = (e) => (t, r) => e(xv(t, r)),
d3 = ic(n3),
l3 = ic(s3),
u3 = ic(a3),
p3 = ic(i3),
m3 = ic(c3),
Av = (e) => (t, r) => e(t.payload, r.payload),
Rm = (e) => (t, r) => zi(e(t.payload, r.payload)),
sl = Av(d3),
BK = Av(l3),
al = Rm(u3),
wv = Rm(p3),
il = Rm(m3);
var Jr = (e, t, r = void 0, o = void 0) => {
typeof t == "number" && (t = `[${t}]`);
let n = Se(`${t}: ${e.message}`, r, o);
throw (Ze(n, V`Caused by ${e}`), n);
};
harden(Jr);
var Ka = (e, t, r = void 0) => {
if (r === void 0) return e(...t);
let o;
try {
o = e(...t);
} catch (n) {
Jr(n, r);
}
return rr(o) ? O.when(o, void 0, (n) => Jr(n, r)) : o;
};
harden(Ka);
var { fromEntries: f3 } = Object,
{ ownKeys: y3 } = Reflect,
So = (e) => {
let t = [...e],
r = harden(f3(t));
if (y3(r).length === t.length) return r;
let o = new Set();
for (let [n, a] of t)
(o.has(n) && f`collision on property name ${x(n)}: ${t}`, o.add(n));
throw f`internal: failed to create object from unique entries`;
};
harden(So);
var wr = (e, t) => {
let r = new Set(t);
return e.filter((o) => !r.has(o));
};
harden(wr);
var { entries: Om, values: g3, hasOwn: Pv } = Object,
{ ownKeys: Em } = Reflect,
kv = new WeakSet(),
kt,
h3 = harden({
decimalDigitsLimit: 100,
stringLengthLimit: 1e5,
symbolNameLengthLimit: 100,
numPropertiesLimit: 80,
propertyNameLengthLimit: 100,
arrayLengthLimit: 1e4,
byteLengthLimit: 1e5,
numSetElementsLimit: 1e4,
numUniqueBagElementsLimit: 1e4,
numMapEntriesLimit: 5e3,
}),
Vr = (e = {}) => harden({ __proto__: h3, ...e }),
Hr = (e, t, r, o) => {
if ((assert(Array.isArray(t)), !Array.isArray(e)))
return r(!1, V`${x(o)} payload must be an array: ${e}`);
let n = t.length;
if (!(e.length === n || e.length === n + 1))
return r(!1, V`${x(o)} payload unexpected size: ${e}`);
let a = e[n];
return (
(e = harden(e.slice(0, n))),
v3(e, t, r, o)
? a === void 0
? !0
: (ce(a) === "copyRecord" ||
r(!1, V`Limits must be a record: ${x(a)}`)) &&
Om(a).every(
([i, c]) =>
ce(c) === "number" ||
r(!1, V`Value of limit ${x(i)} but be a number: ${x(c)}`),
)
: !1
);
},
cl = (e, t, r) =>
Math.floor(Math.log10(Math.abs(Number(e)))) + 1 <= t
? !0
: r(!1, V`bigint ${e} must not have more than ${t} digits`),
b3 = () => {
let e = (A) => Ni[A],
t = (A) => R3[A],
r = new Map([
["null", null],
["undefined", void 0],
]),
o = new WeakMap(),
n = (A, C, M) => {
let Z = e(C);
if (Z) return Z.checkIsWellFormed(A.payload, M);
{
let ae = t(C);
if (ae !== void 0) return m(A.payload, ae, M, C);
}
switch (C) {
case "copySet":
return Na(A, M);
case "copyBag":
return Ma(A, M);
case "copyMap":
return $a(A, M);
default:
return M(!1, V`cannot check unrecognized tag ${x(C)}: ${A}`);
}
},
a = (A, C = Xe) => {
let M = ce(A);
if (M !== "tagged") return M;
if (o.has(A)) return o.get(A);
let Z = $e(A);
if (n(A, Z, C)) return (o.set(A, Z), Z);
C !== Xe && C(!1, V`cannot check unrecognized tag ${x(Z)}`);
};
harden(a);
let i = (A, C, M) => {
if (r.has(C)) return l(A, r.get(C), M);
let Z = a(A, M);
return C === Z
? !0
: (M !== Xe && M(!1, V`${tt(Z)} ${A} - Must be a ${tt(C)}`), !1);
},
c = (A, C) => i(A, C, Xe),
d = (A) =>
A === void 0 || (c(A, "match:kind") && A.payload === "undefined"),
l = (A, C, M) =>
ho(A) && ar(A, C) ? !0 : M !== Xe && M(!1, V`${A} - Must be: ${C}`),
u = (A, C) => {
if (ho(A) || kv.has(A)) return !0;
let M = p(A, C);
return (M && kv.add(A), M);
},
p = (A, C) => {
let M = (ae) => u(ae, C),
Z = a(A, C);
switch (Z) {
case void 0:
return !1;
case "copyRecord":
return g3(A).every(M);
case "copyArray":
return A.every(M);
case "copyMap":
return u(A.values, C);
case "error":
case "promise":
return C(!1, V`A ${x(Z)} cannot be a pattern`);
default:
return e(Z) !== void 0
? !0
: C(!1, V`A passable of kind ${x(Z)} is not a pattern: ${A}`);
}
},
y = (A) => u(A, Xe),
b = (A) => {
u(A, Te);
},
m = (A, C, M, Z = void 0) => Ka(v, [A, C, M], Z),
v = (A, C, M) => {
let Z = a(C, M),
ae = a(A);
switch (Z) {
case void 0:
return f`pattern expected: ${C}`;
case "promise":
return f`promises cannot be patterns: ${C}`;
case "error":
return f`errors cannot be patterns: ${C}`;
case "undefined":
case "null":
case "boolean":
case "number":
case "bigint":
case "string":
case "symbol":
case "byteArray":
case "copySet":
case "copyBag":
case "remotable":
return l(A, C, M);
case "copyArray": {
if (ho(C)) return l(A, C, M);
if (ae !== "copyArray")
return M(
!1,
V`${A} - Must be a copyArray to match a copyArray pattern: ${Sr(C)}`,
);
let { length: me } = C;
return A.length !== me
? M(
!1,
V`Array ${A} - Must be as long as copyArray pattern: ${Sr(C)}`,
)
: C.every((be, Pe) => m(A[Pe], be, M, Pe));
}
case "copyRecord": {
if (ho(C)) return l(A, C, M);
if (ae !== "copyRecord")
return M(
!1,
V`${A} - Must be a copyRecord to match a copyRecord pattern: ${Sr(C)}`,
);
let me = Ft(A),
be = Ft(C),
Pe = wr(be, me);
if (Pe.length >= 1)
return M(!1, V`${A} - Must have missing properties ${x(Pe)}`);
let We = wr(me, be);
if (We.length >= 1)
return M(
!1,
V`${A} - Must not have unexpected properties: ${x(We)}`,
);
let gt = xr(A, me),
Et = xr(C, be);
return be.every((In, wd) => m(gt[wd], Et[wd], M, In));
}
case "copyMap": {
if (ho(C)) return l(A, C, M);
if (ae !== "copyMap")
return M(
!1,
V`${A} - Must be a copyMap to match a copyMap pattern: ${Sr(C)}`,
);
let me = zd(C),
be = zd(A);
if (!m(be, me, M)) return !1;
let Pe = [],
We = [],
gt = Yd(C, A, Yi, void 0);
for (let [Et, In, wd] of gt) (Pe.push(In), We.push(wd));
return m(harden(We), harden(Pe), M);
}
default: {
let me = e(Z);
if (me) return me.checkMatches(A, C.payload, M);
throw f`internal: should have recognized ${x(Z)} `;
}
}
},
h = (A, C) => m(A, C, Xe),
g = (A, C, M = void 0) => {
let Z;
try {
if (m(A, C, Xe, void 0)) return;
} catch (me) {
Z = me;
}
m(A, C, Te, M);
let ae = Se(
V`internal: ${M}: inconsistent pattern match: ${Sr(C)}`,
);
throw (Z !== void 0 && Ze(ae, V`caused by ${Z}`), ae);
},
S = (A, C) => {
if (ho(A)) {
let Z = C(A);
if (Z !== void 0) return [Z, `${Z}~`];
}
let M = ce(A);
switch (M) {
case "copyArray":
break;
case "copyRecord":
break;
case "tagged": {
let Z = $e(A),
ae = e(Z);
if (ae) return ae.getRankCover(A.payload, C);
switch (Z) {
case "copySet":
break;
case "copyMap":
break;
default:
break;
}
break;
}
default:
break;
}
return st(M);
},
w = (A, C, M, Z = "") =>
c(C, "match:any")
? !0
: A.every((ae, me) => m(ae, C, M, `${Z}[${me}]`)),
I = se("match:any helper", {
checkMatches: (A, C, M) => !0,
checkIsWellFormed: (A, C) =>
A === void 0 ||
C(!1, V`match:any payload: ${A} - Must be undefined`),
getRankCover: (A, C) => ["", "{"],
}),
E = se("match:and helper", {
checkMatches: (A, C, M) => C.every((Z) => m(A, Z, M)),
checkIsWellFormed: (A, C) => {
let M = (Z) => u(Z, C);
return (
(ce(A) === "copyArray" ||
C(!1, V`Needs array of sub-patterns: ${Sr(A)}`)) &&
A.every(M)
);
},
getRankCover: (A, C) =>
wm(
nr,
A.map((M) => S(M, C)),
),
}),
K = se("match:or helper", {
checkMatches: (A, C, M) => {
let { length: Z } = C;
if (Z === 0)
return M(!1, V`${A} - no pattern disjuncts to match: ${Sr(C)}`);
let ae = C.length === 2 ? C.findIndex((me) => d(me)) : -1;
return ae !== -1
? A === void 0 || m(A, C[1 - ae], M)
: C.some((me) => h(A, me))
? !0
: M(!1, V`${A} - Must match one of ${Sr(C)}`);
},
checkIsWellFormed: E.checkIsWellFormed,
getRankCover: (A, C) =>
Hd(
nr,
A.map((M) => S(M, C)),
),
}),
J = se("match:not helper", {
checkMatches: (A, C, M) =>
h(A, C)
? M(!1, V`${A} - Must fail negated pattern: ${Sr(C)}`)
: !0,
checkIsWellFormed: u,
getRankCover: (A, C) => ["", "{"],
}),
P = se("match:scalar helper", {
checkMatches: (A, C, M) => qd(A, M),
checkIsWellFormed: I.checkIsWellFormed,
getRankCover: (A, C) => ["a", "z~"],
}),
k = se("match:key helper", {
checkMatches: (A, C, M) => sr(A, M),
checkIsWellFormed: I.checkIsWellFormed,
getRankCover: (A, C) => ["a", "z~"],
}),
U = se("match:pattern helper", {
checkMatches: (A, C, M) => u(A, M),
checkIsWellFormed: I.checkIsWellFormed,
getRankCover: (A, C) => ["a", "z~"],
}),
D = se("match:kind helper", {
checkMatches: i,
checkIsWellFormed: (A, C) =>
typeof A == "string" ||
C(
!1,
V`match:kind: payload: ${A} - A kind name must be a string`,
),
getRankCover: (A, C) => {
let M;
switch (A) {
case "copySet":
case "copyMap": {
M = "tagged";
break;
}
default: {
M = A;
break;
}
}
return st(M);
},
}),
_ = se("match:tagged helper", {
checkMatches: (A, [C, M], Z) =>
ce(A) !== "tagged"
? Z(!1, V`Expected tagged object, not ${x(ce(A))}: ${A}`)
: m($e(A), C, Z, "tag") && m(A.payload, M, Z, "payload"),
checkIsWellFormed: (A, C) =>
m(
A,
harden([kt.pattern(), kt.pattern()]),
C,
"match:tagged payload",
),
getRankCover: (A, C) => st("tagged"),
}),
T = se("match:bigint helper", {
checkMatches: (A, [C = void 0], M) => {
let { decimalDigitsLimit: Z } = Vr(C);
return i(A, "bigint", M) && cl(A, Z, M);
},
checkIsWellFormed: (A, C) =>
Hr(A, harden([]), C, "match:bigint payload"),
getRankCover: (A, C) => st("bigint"),
}),
R = se("match:nat helper", {
checkMatches: (A, [C = void 0], M) => {
let { decimalDigitsLimit: Z } = Vr(C);
return (
i(A, "bigint", M) &&
M(A >= 0n, V`${A} - Must be non-negative`) &&
cl(A, Z, M)
);
},
checkIsWellFormed: (A, C) =>
Hr(A, harden([]), C, "match:nat payload"),
getRankCover: (A, C) => st("bigint"),
}),
N = se("match:string helper", {
checkMatches: (A, [C = void 0], M) => {
let { stringLengthLimit: Z } = Vr(C);
return (
i(A, "string", M) &&
(A.length <= Z ||
M(!1, V`string ${A} must not be bigger than ${Z}`))
);
},
checkIsWellFormed: (A, C) =>
Hr(A, harden([]), C, "match:string payload"),
getRankCover: (A, C) => st("string"),
}),
F = se("match:symbol helper", {
checkMatches: (A, [C = void 0], M) => {
let { symbolNameLengthLimit: Z } = Vr(C);
if (!i(A, "symbol", M)) return !1;
let ae = _t(A);
if (typeof ae != "string")
throw f`internal: Passable symbol ${A} must have a passable name`;
return M(
ae.length <= Z,
V`Symbol name ${x(ae)} must not be bigger than ${Z}`,
);
},
checkIsWellFormed: (A, C) =>
Hr(A, harden([]), C, "match:symbol payload"),
getRankCover: (A, C) => st("symbol"),
}),
H = se("match:remotable helper", {
checkMatches: (A, C, M) => {
if (c(A, "remotable")) return !0;
if (M === Xe) return !1;
let { label: Z } = C,
ae = ce(A),
me = ae !== "tagged" ? tt(ae) : x($e(A));
return M(!1, V`${A} - Must be a remotable ${tt(Z)}, not ${me}`);
},
checkIsWellFormed: (A, C) =>
m(
A,
harden({ label: kt.string() }),
C,
"match:remotable payload",
),
getRankCover: (A, C) => st("remotable"),
}),
q = se("match:lte helper", {
checkMatches: (A, C, M) =>
tc(A, C) || M(!1, V`${A} - Must be <= ${C}`),
checkIsWellFormed: sr,
getRankCover: (A, C) => {
let M = ce(A),
[Z, ae] = st(M),
me = `${C(A)}~`;
return (me !== void 0 && (ae = me), [Z, ae]);
},
}),
ne = se("match:lt helper", {
checkMatches: (A, C, M) =>
ec(A, C) || M(!1, V`${A} - Must be < ${C}`),
checkIsWellFormed: sr,
getRankCover: q.getRankCover,
}),
ee = se("match:gte helper", {
checkMatches: (A, C, M) =>
rc(A, C) || M(!1, V`${A} - Must be >= ${C}`),
checkIsWellFormed: sr,
getRankCover: (A, C) => {
let M = ce(A),
[Z, ae] = st(M),
me = C(A);
return (me !== void 0 && (Z = me), [Z, ae]);
},
}),
Q = se("match:gt helper", {
checkMatches: (A, C, M) =>
oc(A, C) || M(!1, V`${A} - Must be > ${C}`),
checkIsWellFormed: sr,
getRankCover: ee.getRankCover,
}),
L = se("match:recordOf helper", {
checkMatches: (A, [C, M, Z = void 0], ae) => {
let { numPropertiesLimit: me, propertyNameLengthLimit: be } =
Vr(Z);
return (
i(A, "copyRecord", ae) &&
ae(
Em(A).length <= me,
V`Must not have more than ${x(me)} properties: ${A}`,
) &&
Om(A).every(
([Pe, We]) =>
Ka(
ae,
[
Pe.length <= be,
V`Property name must not be longer than ${x(be)}`,
],
Pe,
) && m(harden([Pe, We]), harden([C, M]), ae, Pe),
)
);
},
checkIsWellFormed: (A, C) =>
Hr(
A,
harden([kt.pattern(), kt.pattern()]),
C,
"match:recordOf payload",
),
getRankCover: (A) => st("copyRecord"),
}),
W = se("match:arrayOf helper", {
checkMatches: (A, [C, M = void 0], Z) => {
let { arrayLengthLimit: ae } = Vr(M);
return (
i(A, "copyArray", Z) &&
(A.length <= ae ||
Z(!1, V`Array length ${A.length} must be <= limit ${ae}`)) &&
w(A, C, Z)
);
},
checkIsWellFormed: (A, C) =>
Hr(A, harden([kt.pattern()]), C, "match:arrayOf payload"),
getRankCover: () => st("copyArray"),
}),
Y = se("match:byteArray helper", {
checkMatches: (A, [C = void 0], M) => {
let { byteLengthLimit: Z } = Vr(C);
return (
i(A, "byteArray", M) &&
(A.byteLength <= Z ||
M(!1, V`byteArray ${A} must not be bigger than ${Z}`))
);
},
checkIsWellFormed: (A, C) =>
Hr(A, harden([]), C, "match:byteArray payload"),
getRankCover: (A, C) => st("byteArray"),
}),
j = se("match:setOf helper", {
checkMatches: (A, [C, M = void 0], Z) => {
let { numSetElementsLimit: ae } = Vr(M);
return (
i(A, "copySet", Z) &&
Z(
A.payload.length < ae,
V`Set must not have more than ${x(ae)} elements: ${A.payload.length}`,
) &&
w(A.payload, C, Z, "set elements")
);
},
checkIsWellFormed: (A, C) =>
Hr(A, harden([kt.pattern()]), C, "match:setOf payload"),
getRankCover: () => st("tagged"),
}),
X = se("match:bagOf helper", {
checkMatches: (A, [C, M, Z = void 0], ae) => {
let { numUniqueBagElementsLimit: me, decimalDigitsLimit: be } =
Vr(Z);
return (
i(A, "copyBag", ae) &&
ae(
A.payload.length <= me,
V`Bag must not have more than ${x(me)} unique elements: ${A}`,
) &&
A.payload.every(
([Pe, We], gt) =>
m(Pe, C, ae, `bag keys[${gt}]`) &&
Ka(cl, [We, be, ae], `bag counts[${gt}]`) &&
m(We, M, ae, `bag counts[${gt}]`),
)
);
},
checkIsWellFormed: (A, C) =>
Hr(
A,
harden([kt.pattern(), kt.pattern()]),
C,
"match:bagOf payload",
),
getRankCover: () => st("tagged"),
}),
z = (A, C, M, Z = void 0, ae = void 0, me = Xe) => {
let be = 0n;
for (let Pe = A.length - 1; Pe >= 0; Pe -= 1) {
let We = A[Pe];
if (be < M)
h(We, C) ? ((be += 1n), Z && Z.push(We)) : ae && ae.push(We);
else {
if (ae === void 0) break;
ae.push(We);
}
}
return me(be >= M, V`Has only ${x(be)} matches, but needs ${x(M)}`);
},
te = (A, C, M, Z = void 0, ae = void 0, me = Xe) => {
let be = 0n;
for (let Pe = A.length - 1; Pe >= 0; Pe -= 1) {
let [We, gt] = A[Pe],
Et = M - be;
if (Et >= 1n)
h(We, C)
? gt <= Et
? ((be += gt), Z && Z.push([We, gt]))
: ((be += Et),
Z && Z.push([We, Et]),
ae && ae.push([We, gt - Et]))
: ae && ae.push([We, gt]);
else {
if (ae === void 0) break;
ae.push([We, gt]);
}
}
return me(be >= M, V`Has only ${x(be)} matches, but needs ${x(M)}`);
},
oe = (A, C, M, Z = !1, ae = !1, me = Xe) => {
let be = Z ? [] : void 0,
Pe = ae ? [] : void 0,
We = a(A);
switch (We) {
case "copyArray":
return z(A, C, M, be, Pe, me) ? [be, Pe] : !1;
case "copySet":
return z(A.payload, C, M, be, Pe, me)
? [be && Ar(be), Pe && Ar(Pe)]
: !1;
case "copyBag":
return te(A.payload, C, M, be, Pe, me)
? [be && qo(be), Pe && qo(Pe)]
: !1;
default:
return me(!1, V`unexpected ${x(We)}`);
}
},
ie = se("M.containerHas helper", {
checkMatches: (A, [C, M, Z = void 0], ae) => {
let me = a(A, ae),
{ decimalDigitsLimit: be } = Vr(Z);
return Ka(cl, [M, be, ae], `${me} matches`)
? !!oe(A, C, M, !1, !1, ae)
: !1;
},
checkIsWellFormed: (A, C) =>
Hr(
A,
harden([kt.pattern(), kt.gte(1n)]),
C,
"M.containerHas payload",
),
getRankCover: () => st("tagged"),
}),
ue = se("match:mapOf helper", {
checkMatches: (A, [C, M, Z = void 0], ae) => {
let { numMapEntriesLimit: me } = Vr(Z);
return (
i(A, "copyMap", ae) &&
ae(
A.payload.keys.length <= me,
V`CopyMap must have no more than ${x(me)} entries: ${A}`,
) &&
w(A.payload.keys, C, ae, "map keys") &&
w(A.payload.values, M, ae, "map values")
);
},
checkIsWellFormed: (A, C) =>
Hr(
A,
harden([kt.pattern(), kt.pattern()]),
C,
"match:mapOf payload",
),
getRankCover: (A) => st("tagged"),
}),
ge = (A, C, M) => {
let Z = C.length,
ae = M.length,
me = A.slice(0, Z),
be = A.slice(Z, Z + ae),
Pe = A.slice(Z + ae);
return harden({
requiredSpecimen: me,
optionalSpecimen: be,
restSpecimen: Pe,
});
},
Fe = (A, C) => harden(A.slice(0, C).map((M) => kt.opt(M))),
Ke = se("match:splitArray helper", {
checkMatches: (A, [C, M = [], Z = kt.any()], ae) => {
if (!i(A, "copyArray", ae)) return !1;
let {
requiredSpecimen: me,
optionalSpecimen: be,
restSpecimen: Pe,
} = ge(A, C, M),
We = Fe(M, be.length),
gt = 0;
return (
(me.length === C.length ||
ae(
!1,
V`Expected at least ${x(C.length)} arguments: ${A}`,
)) &&
C.every((Et, In) => m(me[In], Et, ae, `arg ${gt++}`)) &&
We.every((Et, In) => m(be[In], Et, ae, `arg ${gt++}?`)) &&
m(Pe, Z, ae, "...rest")
);
},
checkIsWellFormed: (A, C) => {
if (ce(A) === "copyArray" && (A.length >= 1 || A.length <= 3)) {
let [M, Z = void 0, ae = void 0] = A;
if (
y(M) &&
ce(M) === "copyArray" &&
(Z === void 0 || (y(Z) && ce(Z) === "copyArray")) &&
(ae === void 0 || y(ae))
)
return !0;
}
return C(
!1,
V`Must be an array of a requiredPatt array, an optional optionalPatt array, and an optional restPatt: ${x(A)}`,
);
},
getRankCover: ([A, C = void 0, M = void 0]) => st("copyArray"),
}),
vt = (A, C, M) => {
let Z = [],
ae = [],
me = [];
for (let [be, Pe] of Om(A))
Pv(C, be)
? Z.push([be, Pe])
: Pv(M, be)
? ae.push([be, Pe])
: me.push([be, Pe]);
return harden({
requiredSpecimen: So(Z),
optionalSpecimen: So(ae),
restSpecimen: So(me),
});
},
tr = (A, C) => So(C.map((M) => [M, kt.opt(A[M])])),
Gt = se("match:splitRecord helper", {
checkMatches: (A, [C, M = {}, Z = kt.any()], ae) => {
if (!i(A, "copyRecord", ae)) return !1;
let {
requiredSpecimen: me,
optionalSpecimen: be,
restSpecimen: Pe,
} = vt(A, C, M),
We = Em(be),
gt = tr(M, We);
return (
m(me, C, ae) &&
We.every((Et) => m(be[Et], gt[Et], ae, `${Et}?`)) &&
m(Pe, Z, ae, "...rest")
);
},
checkIsWellFormed: (A, C) => {
if (ce(A) === "copyArray" && (A.length >= 1 || A.length <= 3)) {
let [M, Z = void 0, ae = void 0] = A;
if (
y(M) &&
ce(M) === "copyRecord" &&
(Z === void 0 || (y(Z) && ce(Z) === "copyRecord")) &&
(ae === void 0 || y(ae))
)
return !0;
}
return C(
!1,
V`Must be an array of a requiredPatt record, an optional optionalPatt record, and an optional restPatt: ${x(A)}`,
);
},
getRankCover: ([A, C = void 0, M = void 0]) => st(ce(A)),
}),
Ni = harden({
"match:any": I,
"match:and": E,
"match:or": K,
"match:not": J,
"match:scalar": P,
"match:key": k,
"match:pattern": U,
"match:kind": D,
"match:tagged": _,
"match:bigint": T,
"match:nat": R,
"match:string": N,
"match:symbol": F,
"match:remotable": H,
"match:lt": ne,
"match:lte": q,
"match:gte": ee,
"match:gt": Q,
"match:arrayOf": W,
"match:byteArray": Y,
"match:recordOf": L,
"match:setOf": j,
"match:bagOf": X,
"match:containerHas": ie,
"match:mapOf": ue,
"match:splitArray": Ke,
"match:splitRecord": Gt,
}),
mt = (A, C) => {
let M = Ce(A, C);
return (b(M), M);
},
Mr = (A) => mt("match:kind", A),
yr = mt("match:any", void 0),
Jp = mt("match:scalar", void 0),
xd = mt("match:key", void 0),
Vp = mt("match:pattern", void 0),
Hp = Mr("boolean"),
Ad = Mr("number"),
k0 = Ce("match:bigint", []),
ye = Ce("match:nat", []),
he = Ce("match:string", []),
Me = Ce("match:symbol", []),
He = Ce("match:recordOf", [yr, yr]),
nt = Ce("match:arrayOf", [yr]),
gr = Ce("match:byteArray", []),
Ho = Ce("match:setOf", [yr]),
cs = Ce("match:bagOf", [yr, yr]),
Wp = Ce("match:mapOf", [yr, yr]),
Lp = Mr("remotable"),
qp = Mr("error"),
VI = Mr("promise"),
HI = Mr("undefined"),
$r = (A, C) => (
C[C.length - 1] === void 0 &&
(C = harden(C.slice(0, C.length - 1))),
mt(A, C)
),
WI = (A = void 0) =>
A === void 0 ? Lp : mt("match:remotable", harden({ label: A })),
I0 = (A, C, M = void 0, Z = void 0) =>
Z ? [C, M || A, Z] : M ? [C, M] : [C],
Oe = harden({
any: () => yr,
and: (...A) => mt("match:and", A),
or: (...A) => mt("match:or", A),
not: (A) => mt("match:not", A),
scalar: () => Jp,
key: () => xd,
pattern: () => Vp,
kind: Mr,
tagged: (A = Oe.string(), C = Oe.any()) =>
mt("match:tagged", harden([A, C])),
boolean: () => Hp,
number: () => Ad,
bigint: (A = void 0) => (A ? $r("match:bigint", [A]) : k0),
nat: (A = void 0) => (A ? $r("match:nat", [A]) : ye),
string: (A = void 0) => (A ? $r("match:string", [A]) : he),
symbol: (A = void 0) => (A ? $r("match:symbol", [A]) : Me),
record: (A = void 0) =>
A ? Oe.recordOf(Oe.any(), Oe.any(), A) : He,
array: (A = void 0) => (A ? Oe.arrayOf(Oe.any(), A) : nt),
byteArray: (A = void 0) => (A ? $r("match:byteArray", [A]) : gr),
set: (A = void 0) => (A ? Oe.setOf(Oe.any(), A) : Ho),
bag: (A = void 0) => (A ? Oe.bagOf(Oe.any(), Oe.any(), A) : cs),
map: (A = void 0) => (A ? Oe.mapOf(Oe.any(), Oe.any(), A) : Wp),
remotable: WI,
error: () => qp,
promise: () => VI,
undefined: () => HI,
null: () => null,
lt: (A) => mt("match:lt", A),
lte: (A) => mt("match:lte", A),
eq: (A) => (bo(A), A === void 0 ? Oe.undefined() : A),
neq: (A) => Oe.not(Oe.eq(A)),
gte: (A) => mt("match:gte", A),
gt: (A) => mt("match:gt", A),
recordOf: (A = Oe.any(), C = Oe.any(), M = void 0) =>
$r("match:recordOf", [A, C, M]),
arrayOf: (A = Oe.any(), C = void 0) => $r("match:arrayOf", [A, C]),
setOf: (A = Oe.any(), C = void 0) => $r("match:setOf", [A, C]),
bagOf: (A = Oe.any(), C = Oe.any(), M = void 0) =>
$r("match:bagOf", [A, C, M]),
containerHas: (A = Oe.any(), C = 1n, M = void 0) =>
$r("match:containerHas", [A, C, M]),
mapOf: (A = Oe.any(), C = Oe.any(), M = void 0) =>
$r("match:mapOf", [A, C, M]),
splitArray: (A, C = void 0, M = void 0) =>
mt("match:splitArray", I0([], A, C, M)),
splitRecord: (A, C = void 0, M = void 0) =>
mt("match:splitRecord", I0({}, A, C, M)),
split: (A, C = void 0) =>
ce(harden(A)) === "copyArray"
? Oe.splitArray(A, C && [], C)
: Oe.splitRecord(A, C && {}, C),
partial: (A, C = void 0) =>
ce(harden(A)) === "copyArray"
? Oe.splitArray([], A, C)
: Oe.splitRecord({}, A, C),
eref: (A) => Oe.or(A, Oe.promise()),
opt: (A) => Oe.or(Oe.undefined(), A),
interface: (A, C, M) => C3(A, C, M),
call: (...A) => ll("sync", A),
callWhen: (...A) => ll("async", A),
await: (A) => w3(A),
raw: () => k3(),
});
return harden({
checkMatches: m,
matches: h,
mustMatch: g,
assertPattern: b,
isPattern: y,
getRankCover: S,
M: Oe,
kindOf: a,
containerHasSplit: oe,
});
},
{
checkMatches: v3,
matches: Ve,
mustMatch: Be,
assertPattern: zt,
isPattern: Iv,
getRankCover: Tv,
M: s,
kindOf: S3,
containerHasSplit: x3,
} = b3();
kt = s;
var A3 = harden({ argGuard: s.pattern() }),
dc = s.kind("guard:awaitArgGuard"),
lc = (e) => Ve(e, dc);
harden(lc);
var uc = (e) => {
Be(e, dc, "awaitArgGuard");
};
harden(uc);
var w3 = (e) => {
let t = Ce("guard:awaitArgGuard", { argGuard: e });
return (uc(t), t);
},
P3 = s.record(),
pc = s.kind("guard:rawGuard"),
Ja = (e) => Ve(e, pc);
var k3 = () => Ce("guard:rawGuard", {}),
xo = s.or(pc, s.pattern()),
cc = s.arrayOf(xo),
I3 = s.or(pc, dc, s.pattern()),
dl = s.arrayOf(I3),
T3 = harden({
callKind: "sync",
argGuards: cc,
optionalArgGuards: s.opt(cc),
restArgGuard: s.opt(xo),
returnGuard: xo,
}),
U3 = harden({
callKind: "async",
argGuards: dl,
optionalArgGuards: s.opt(dl),
restArgGuard: s.opt(xo),
returnGuard: xo,
}),
Dm = s.or(T3, U3),
bs = s.kind("guard:methodGuard"),
Nm = (e) => {
Be(e, bs, "methodGuard");
};
harden(Nm);
var ll = (e, t, r = void 0, o = void 0) =>
harden({
optional: (...n) => (
r === void 0 || f`Can only have one set of optional guards`,
o === void 0 || f`optional arg guards must come before rest arg`,
ll(e, t, n)
),
rest: (n) => (
o === void 0 || f`Can only have one rest arg`,
ll(e, t, r, n)
),
returns: (n = s.undefined()) => {
let a = Ce("guard:methodGuard", {
callKind: e,
argGuards: t,
optionalArgGuards: r,
restArgGuard: o,
returnGuard: n,
});
return (Nm(a), a);
},
}),
Bm = s.splitRecord(
{ interfaceName: s.string(), methodGuards: s.recordOf(s.string(), bs) },
{
defaultGuards: s.or(s.undefined(), "passable", "raw"),
sloppy: s.boolean(),
symbolMethodGuards: s.mapOf(s.symbol(), bs),
},
),
Mm = s.kind("guard:interfaceGuard"),
$m = (e) => {
Be(e, Mm, "interfaceGuard");
};
harden($m);
var C3 = (e, t, r = {}) => {
let { sloppy: o = !1, defaultGuards: n = o ? "passable" : void 0 } = r,
a = {},
i = [];
for (let d of Em(t)) {
let l = t[d];
typeof d == "symbol" ? i.push([d, l]) : (a[d] = l);
}
let c = Ce("guard:interfaceGuard", {
interfaceName: e,
methodGuards: a,
...(i.length ? { symbolMethodGuards: jo(i) } : {}),
defaultGuards: n,
});
return ($m(c), c);
},
R3 = harden({
"guard:awaitArgGuard": A3,
"guard:rawGuard": P3,
"guard:methodGuard": Dm,
"guard:interfaceGuard": Bm,
});
var _m = harden({ klass: "awaitArg", argGuard: s.pattern() }),
mc = (e) => {
if (Ve(e, _m)) {
let { klass: t, ...r } = e;
return r;
}
return (uc(e), e.payload);
};
harden(mc);
var O3 = s.splitRecord(
{
klass: "methodGuard",
callKind: "sync",
argGuards: cc,
returnGuard: xo,
},
{ optionalArgGuards: cc, restArgGuard: xo },
),
E3 = s.or(pc, dc, _m, s.pattern()),
D3 = s.arrayOf(E3),
N3 = s.splitRecord(
{
klass: "methodGuard",
callKind: "async",
argGuards: D3,
returnGuard: xo,
},
{ optionalArgGuards: dl, restArgGuard: xo },
),
Fm = s.or(O3, N3),
Uv = (e) => (Ve(e, _m) ? s.await(mc(e).argGuard) : e),
fc = (e) => {
if (Ve(e, bs)) return e.payload;
Be(e, Fm, "legacyMethodGuard");
let { klass: t, callKind: r, returnGuard: o, restArgGuard: n } = e,
{ argGuards: a, optionalArgGuards: i } = e;
r === "async" && ((a = a.map(Uv)), (i = i && i.map(Uv)));
let c = harden({
callKind: r,
argGuards: a,
optionalArgGuards: i,
restArgGuard: n,
returnGuard: o,
});
return (Be(c, Dm, "internalMethodGuardAdaptor"), c);
};
harden(fc);
var B3 = s.splitRecord(
{
klass: "Interface",
interfaceName: s.string(),
methodGuards: s.recordOf(s.string(), s.or(bs, Fm)),
},
{
defaultGuards: s.or(s.undefined(), "passable", "raw"),
sloppy: s.boolean(),
symbolMethodGuards: s.mapOf(s.symbol(), bs),
},
),
M3 = (e) => {
if (Ve(e, Fm)) {
let {
callKind: t,
argGuards: r,
optionalArgGuards: o = [],
restArgGuard: n = s.any(),
returnGuard: a,
} = fc(e);
return (t === "sync" ? s.call : s.callWhen)(...r)
.optional(...o)
.rest(n)
.returns(a);
}
return e;
},
Ao = (e) => {
if (Ve(e, Mm)) return e.payload;
Be(e, B3, "legacyInterfaceGuard");
let { klass: t, interfaceName: r, methodGuards: o, ...n } = e;
o = Ne(o, M3);
let a = harden({ interfaceName: r, methodGuards: o, ...n });
return (Be(a, Bm, "internalInterfaceGuardAdaptor"), a);
};
harden(Ao);
var $3 = jo([]),
ul = (e) => {
let { methodGuards: t, symbolMethodGuards: r = $3 } = Ao(e);
return harden([...Reflect.ownKeys(t), ...Qd(r)]);
};
harden(ul);
var Km = (e, t, r = void 0, o = "key") => {
let n = (a) => e.has(a) || f`${x(o)} not found: ${a}`;
return harden({
has: (a) => e.has(a),
add: (a) => {
(t(a), e.add(a));
},
delete: (a) => {
(n(a), r !== void 0 && r(a), e.delete(a));
},
addAll: (a) => {
typeof a[Symbol.iterator] != "function" &&
(Object.isFrozen(a) && Ba(a)
? (a = vo(a))
: f`provided data source is not iterable: ${a}`);
for (let i of a) (t(i), e.add(i));
},
});
},
yc = (e = "key", { longLived: t = !0, keyShape: r = void 0 } = {}) => {
let o = new (t ? WeakSet : Set)();
r !== void 0 && zt(r);
let n = (a) => {
(harden(a),
ce(a) === "remotable" ||
f`Only remotables can be keys of scalar WeakStores: ${a}`,
r !== void 0 && Be(a, r, "weakSetStore key"));
};
return se(`scalar WeakSetStore of ${x(e)}`, { ...Km(o, n, void 0, e) });
};
harden(yc);
var gc = (e, t, r, o, n, a = "key") => {
let i = 0,
c,
d = (y, b = void 0) => {
(o(y, b), (i += 1), (c = void 0));
},
l = (y) => n && n(y),
u = () => (c === void 0 && (c = harden([...e()].sort(r))), c),
p = se("Iterable of keys", {
[Symbol.iterator]: () => {
let y = i;
u();
let b = c.length,
m = 0;
return se("Iterator of keys", {
next: () => {
for (y === i || f`Store ${x(a)} cursor stale`; ; )
if (m < b) {
let v = c[m];
if (((m += 1), t(v))) return harden({ done: !1, value: v });
} else return harden({ done: !0, value: void 0 });
},
});
},
});
return harden({
assertUpdateOnAdd: d,
assertUpdateOnDelete: l,
iterableKeys: p,
});
};
harden(gc);
var En = (e, t, r) => (e.has(t) || e.init(t, r(t)), e.get(t));
harden(En);
var Cv = (e) => {
let t = new Map(),
r = (o, n, a) => {
if (e.has(o)) return Promise.resolve(e.get(o));
if (!t.has(o)) {
let c = n(o)
.then((d) => (e.init(o, d), d))
.then((d) => (a ? a(o, d).then(() => d) : d))
.finally(() => {
t.delete(o);
});
t.set(o, c);
}
let i = t.get(o);
return (assert(i), i);
};
return harden({ provideAsync: r });
};
harden(Cv);
var _3 = (e, t, r) => {
if (e.has(t)) {
let o = e.get(t);
e.set(t, harden([...o, r]));
} else e.init(t, harden([r]));
};
harden(_3);
var F3 = (e, t, r, o = "key") => {
let {
assertUpdateOnAdd: n,
assertUpdateOnDelete: a,
iterableKeys: i,
} = gc(
() => e.keys(),
(d) => e.has(d),
nr,
t,
r,
o,
),
c = (d) => (d === void 0 ? i : Ta(i, (l) => Ve(l, d)));
return harden({
...Km(e, n, a, o),
keys: c,
values: c,
snapshot: (d = void 0) => Ar(c(d)),
getSize: (d = void 0) => (d === void 0 ? e.size : [...c(d)].length),
clear: (d = void 0) => {
d === void 0 && e.clear();
for (let l of c(d)) e.delete(l);
},
});
},
hc = (e = "key", { keyShape: t } = {}) => {
let r = new Set();
t !== void 0 && zt(t);
let o = (n) => {
(harden(n), fs(n), t !== void 0 && Be(n, t, "setStore key"));
};
return se(`scalar SetStore of ${x(e)}`, { ...F3(r, o, void 0, e) });
};
harden(hc);
var Jm = (e, t, r, o = void 0, n = "key") => {
let a = (c) => !e.has(c) || f`${x(n)} already registered: ${c}`,
i = (c) => e.has(c) || f`${x(n)} not found: ${c}`;
return harden({
has: (c) => e.has(c),
get: (c) => (i(c), e.get(c)),
init: (c, d) => {
(a(c), t(c, d), e.set(c, d));
},
set: (c, d) => {
(i(c), r(c, d), e.set(c, d));
},
delete: (c) => {
(i(c), o !== void 0 && o(c), e.delete(c));
},
addAll: (c) => {
typeof c[Symbol.iterator] != "function" &&
(Object.isFrozen(c) && _a(c)
? (c = gs(c))
: f`provided data source is not iterable: ${c}`);
for (let [d, l] of c) (t(d, l), e.set(d, l));
},
});
},
vs = (
e = "key",
{
longLived: t = !0,
keyShape: r = void 0,
valueShape: o = void 0,
} = {},
) => {
let n = t ? new WeakMap() : new Map();
(r !== void 0 && zt(r), o !== void 0 && zt(o));
let a = (c, d) => {
(harden(d), fo(d), o !== void 0 && Be(d, o, "weakMapStore value"));
},
i = (c, d) => {
(harden(c),
ce(c) === "remotable" ||
f`Only remotables can be keys of scalar WeakMapStores: ${c}`,
r !== void 0 && Be(c, r, "weakMapStore key"),
a(c, d));
};
return se(`scalar WeakMapStore of ${x(e)}`, {
...Jm(n, i, a, void 0, e),
});
};
harden(vs);
var K3 = (e, t, r, o, n = "key") => {
let {
assertUpdateOnAdd: a,
assertUpdateOnDelete: i,
iterableKeys: c,
} = gc(
() => e.keys(),
(p) => e.has(p),
nr,
t,
o,
n,
),
d = (p, y) =>
p === void 0 && y === void 0
? c
: Ta(
c,
(m) =>
!(
(p !== void 0 && !Ve(m, p)) ||
(y !== void 0 && !Ve(e.get(m), y))
),
),
l = (p, y) => _i(d(p, y), (b) => e.get(b)),
u = (p, y) => _i(d(p, y), (b) => [b, e.get(b)]);
return harden({
...Jm(e, a, r, i, n),
keys: d,
values: l,
entries: u,
snapshot: (p = void 0, y = void 0) => jo(u(p, y)),
getSize: (p = void 0, y = void 0) =>
p === void 0 && y === void 0 ? e.size : [...d(p, y)].length,
clear: (p = void 0, y = void 0) => {
p === void 0 && y === void 0 && e.clear();
for (let b of d(p, y)) e.delete(b);
},
});
},
Go = (e = "key", { keyShape: t, valueShape: r } = {}) => {
let o = new Map();
(t !== void 0 && zt(t), r !== void 0 && zt(r));
let n = (i, c) => {
(harden(c), fo(c), r !== void 0 && Be(c, r, "mapStore value"));
},
a = (i, c) => {
(harden(i),
fs(i),
t !== void 0 && Be(i, t, "mapStore key"),
n(i, c));
};
return se(`scalar MapStore of ${x(e)}`, { ...K3(o, a, n, void 0, e) });
};
harden(Go);
var Ss = "__getInterfaceGuard__";
var { apply: Ev, ownKeys: pl } = Reflect,
{ defineProperties: J3, fromEntries: V3, hasOwn: H3 } = Object,
Rv = s.call().rest(s.raw()).returns(s.raw()),
ml = "<redacted raw arg>",
Vm = s.call().rest(s.any()).returns(s.any()),
Dv = (e, t, r = void 0) => {
let {
declaredLen: o,
hasRestArgGuard: n,
restArgGuardIsRaw: a,
paramsPattern: i,
redactedIndices: c,
} = t,
d = e;
if (a && e.length > o) {
let l = e.length - o,
u = Array(l).fill(ml);
d = [...e.slice(0, o), ...u];
} else c.length > 0 && c[0] < e.length && (d = [...e]);
for (let l of c) {
if (l >= d.length) break;
d[l] = ml;
}
return (
Be(harden(d), i, r),
n ||
e.length <= o ||
f`${x(r)} accepts at most ${x(o)} arguments, not ${x(e.length)}: ${e}`,
e
);
},
Nv = (e) => {
let { argGuards: t, optionalArgGuards: r = [], restArgGuard: o } = e,
n = [...t, ...r],
a = [];
for (let l = 0; l < n.length; l += 1)
Ja(n[l]) && ((n[l] = ml), a.push(l));
let i = o;
Ja(i) && (i = s.arrayOf(ml));
let c = harden({
...e,
argGuards: n.slice(0, t.length),
optionalArgGuards: n.slice(t.length),
restArgGuard: i,
}),
d = s.splitArray(c.argGuards, c.optionalArgGuards, c.restArgGuard);
return harden({
declaredLen: n.length,
hasRestArgGuard: o !== void 0,
restArgGuardIsRaw: o !== i,
paramsPattern: d,
redactedIndices: a,
matchableMethodGuardPayload: c,
});
},
W3 = (e, t, r, o) => {
let { returnGuard: n } = r,
a = Ja(n),
i = Nv(r),
{ syncMethod: c } = {
syncMethod(...d) {
try {
let l = e(this),
u = Dv(d, i, o),
p = Ev(t, l, u);
return (a || Be(harden(p), n, `${o}: result`), p);
} catch (l) {
throw Wo(l);
}
},
};
return c;
},
L3 = (e) => {
let { argGuards: t, optionalArgGuards: r = [], restArgGuard: o } = e;
!lc(o) || f`Rest args may not be awaited: ${o}`;
let n = [...t, ...r],
a = [];
for (let i = 0; i < n.length; i += 1) {
let c = n[i];
lc(c) && ((n[i] = mc(c).argGuard), a.push(i));
}
return {
awaitIndexes: a,
rawMethodGuardPayload: {
...e,
argGuards: n.slice(0, t.length),
optionalArgGuards: n.slice(t.length),
},
};
},
q3 = (e, t, r, o) => {
let { returnGuard: n } = r,
a = Ja(n),
{ awaitIndexes: i, rawMethodGuardPayload: c } = L3(r),
d = Nv(c),
{ asyncMethod: l } = {
asyncMethod(...u) {
let p = [];
for (let v of i) {
if (v >= u.length) break;
p.push(u[v]);
}
let y = Promise.all(p),
b = [...u],
m = O.when(y, (v) => {
for (let S = 0; S < v.length; S += 1) b[i[S]] = v[S];
let h = e(this),
g = Dv(b, d, o);
return Ev(t, h, g);
});
return O.when(
m,
(v) => (a || Be(harden(v), n, `${o}: result`), v),
).catch((v) => Promise.reject(Wo(v)));
},
};
return l;
},
j3 = (e, t, r, o) => {
let n = fc(r),
{ callKind: a } = n;
return a === "sync"
? W3(e, t, n, o)
: (assert(a === "async"), q3(e, t, n, o));
},
Ov = (e, t, r, o) => {
assert.typeof(r, "function");
let a = j3(
(i) => {
i || f`Method ${e} called without 'this' object`;
let c = t(i);
if (c === void 0)
throw f`${x(e)} may only be applied to a valid instance: ${i}`;
return c;
},
r,
o,
e,
);
return (J3(a, { name: { value: e }, length: { value: r.length } }), a);
},
fl = (e, t, r, o = !1, n = void 0) => {
let a = {},
i = Ed(r).filter((l) => {
if (l !== "constructor") return !0;
let u = r.constructor;
return !(u.prototype && u.prototype.constructor === u);
}),
c,
d;
if (n) {
let {
interfaceName: l,
methodGuards: u,
symbolMethodGuards: p,
sloppy: y,
defaultGuards: b = y ? "passable" : d,
} = Ao(n);
((c = harden({ ...u, ...(p && V3(gs(p))) })), (d = b));
{
let m = pl(c),
v = wr(m, i);
if (
(v.length === 0 || f`methods ${x(v)} not implemented by ${x(e)}`,
d === void 0)
) {
let h = wr(i, m);
h.length === 0 || f`methods ${x(h)} not guarded by ${x(l)}`;
}
}
}
for (let l of i) {
let u = r[l],
{ shiftedMethod: p } = {
shiftedMethod(...m) {
return u(this, ...m);
},
},
y = o ? u : p,
b = c && c[l];
if (!b)
switch (d) {
case void 0: {
o ? (b = Vm) : (b = Rv);
break;
}
case "passable": {
b = Vm;
break;
}
case "raw": {
b = Rv;
break;
}
default:
throw f`Unrecognized defaultGuards ${x(d)}`;
}
a[l] = Ov(`In ${x(l)} method of (${e})`, t, y, b);
}
if (!H3(a, Ss)) {
let l = {
[Ss]() {
return n;
},
}[Ss];
a[Ss] = Ov(`In ${x(Ss)} method of (${e})`, t, l, Vm);
}
return se(e, a);
};
harden(fl);
var Bv = (e, t, r, o = !1, n = void 0) => {
let a = pl(r).sort();
if (
(a.length > 1 || f`A multi-facet object must have multiple facets`, n)
) {
let u = pl(n),
p = wr(a, u);
p.length === 0 || f`Interfaces ${x(p)} not implemented by ${x(e)}`;
let y = wr(u, a);
y.length === 0 ||
f`Facets ${x(y)} of ${x(e)} not guarded by interfaces`;
}
let i = pl(t),
c = wr(a, i);
c.length === 0 || f`Contexts ${x(c)} not implemented by ${x(e)}`;
let d = wr(i, a);
return (
d.length === 0 || f`Facets ${x(d)} of ${x(e)} missing contexts`,
Ne(r, (u, p) => fl(`${e} ${String(p)}`, t[p], u, o, n && n[p]))
);
};
var {
create: G3,
seal: $v,
freeze: _v,
defineProperty: Q3,
values: Mv,
} = Object,
z3 = Pa("DEBUG", "label-instances"),
Fv = (e, t) => {
let r = G3(e);
return (
z3 &&
Q3(r, Symbol.toStringTag, {
value: `${e[Symbol.toStringTag]}#${t}`,
writable: !1,
enumerable: !1,
configurable: !1,
}),
harden(r)
);
},
Y3 = harden({}),
Va = () => Y3,
bc = (e, t, r, o, n = {}) => {
harden(o);
let {
finish: a = void 0,
receiveAmplifier: i = void 0,
receiveInstanceTester: c = void 0,
} = n;
i === void 0 ||
f`Only facets of an exo class kit can be amplified ${x(e)}`;
let d = new WeakMap(),
l = fl(e, (y) => d.get(y), o, !0, t),
u = 0,
p = (...y) => {
let b = $v(r(...y));
u += 1;
let m = Fv(l, u),
v = _v({ state: b, self: m });
return (d.set(m, v), a && a(v), m);
};
if (c) {
let y = (b, m = void 0) => (
m === void 0 ||
f`facetName can only be used with an exo class kit: ${x(e)} has no facet ${x(m)}`,
d.has(b)
);
(harden(y), c(y));
}
return harden(p);
};
harden(bc);
var yl = (e, t, r, o, n = {}) => {
harden(o);
let {
finish: a = void 0,
receiveAmplifier: i = void 0,
receiveInstanceTester: c = void 0,
} = n,
d = Ne(o, () => new WeakMap()),
l = Ne(d, (b) => (m) => b.get(m)),
u = Bv(e, l, o, !0, t),
p = 0,
y = (...b) => {
let v = { state: $v(r(...b)), facets: null };
p += 1;
let h = Ne(u, (g, S) => {
let w = Fv(g, p);
return (d[S].set(w, v), w);
});
return ((v.facets = h), _v(v), a && a(v), v.facets);
};
if (i) {
let b = (m) => {
for (let v of Mv(d))
if (v.has(m)) {
let { facets: h } = v.get(m);
return h;
}
throw f`Must be a facet of ${x(e)}: ${m}`;
};
(harden(b), i(b));
}
if (c) {
let b = (m, v = void 0) => {
if (v === void 0) return Mv(d).some((g) => g.has(m));
assert.typeof(v, "string");
let h = d[v];
return (
h !== void 0 || f`exo class kit ${x(e)} has no facet named ${x(v)}`,
h.has(m)
);
};
(harden(b), c(b));
}
return harden(y);
};
harden(yl);
var gl = (e, t, r, o = void 0) => bc(e, t, Va, r, o)();
harden(gl);
var Kv = (e = "key") => {
let t = new Map(),
r = (n) => !t.has(n) || f`${x(e)} already registered: ${n}`,
o = (n) => t.has(n) || f`${x(e)} not found: ${n}`;
return harden({
has: (n) => t.has(n),
init: (n, a) => {
(r(n), t.set(n, a));
},
get: (n) => (o(n), t.get(n)),
set: (n, a) => {
(o(n), t.set(n, a));
},
delete: (n) => {
(o(n), t.delete(n));
},
keys: () => t.keys(),
values: () => t.values(),
entries: () => t.entries(),
getSize: () => t.size,
clear: () => t.clear(),
});
};
harden(Kv);
var Jv = (e = "key") => {
let t = new WeakMap(),
r = (n) => !t.has(n) || f`${x(e)} already registered: ${n}`,
o = (n) => t.has(n) || f`${x(e)} not found: ${n}`;
return harden({
has: (n) => t.has(n),
init: (n, a) => {
(r(n), t.set(n, a));
},
get: (n) => (o(n), t.get(n)),
set: (n, a) => {
(o(n), t.set(n, a));
},
delete: (n) => {
(o(n), t.delete(n));
},
});
};
harden(Jv);
var Kt = Be;
var Vv = 0n,
Hv = harden({
doCoerce: (e) => (
assert.typeof(e, "bigint"),
Ra(e) || f`value ${e} must be a natural number`,
Re(e)
),
doMakeEmpty: () => Vv,
doIsEmpty: (e) => e === Vv,
doIsGTE: (e, t) => e >= t,
doIsEqual: (e, t) => e === t,
doAdd: (e, t) => e + t,
doSubtract: (e, t) => Re(e - t),
});
var Z3 = harden([]),
Wv = harden({
doCoerce: (e) => ((e = Da(e)), bo(e), e),
doMakeEmpty: () => Z3,
doIsEmpty: (e) => ce(e) === "copyArray" && e.length === 0,
doIsGTE: nc,
doIsEqual: (e, t) => el(e, t) === 0,
doAdd: sc,
doSubtract: ac,
});
var X3 = Ar([]),
Lv = harden({
doCoerce: (e) => (Kt(e, s.set(), "set of amount"), e),
doMakeEmpty: () => X3,
doIsEmpty: (e) => vo(e).length === 0,
doIsGTE: rl,
doIsEqual: ar,
doAdd: ol,
doSubtract: nl,
});
var eR = qo([]),
qv = harden({
doCoerce: (e) => (Kt(e, s.bag(), "bag of amount"), e),
doMakeEmpty: () => eR,
doIsEmpty: (e) => On(e).length === 0,
doIsGTE: sl,
doIsEqual: ar,
doAdd: al,
doSubtract: il,
});
var Dn = {
NAT: "nat",
SET: "set",
COPY_SET: "copySet",
COPY_BAG: "copyBag",
};
harden(Dn);
var jv = harden(Object.values(Dn).sort()),
Sl = (e) => {
jv.includes(e) || f`The assetKind ${e} must be one of ${x(jv)}`;
};
harden(Sl);
var Gv = { nat: Hv, set: Wv, copySet: Lv, copyBag: qv },
Wm = (e) => {
let t = ce(e);
if (t === "bigint") return "nat";
if (t === "copyArray") return "set";
if (Ve(e, s.set())) return "copySet";
if (Ve(e, s.bag())) return "copyBag";
throw f`value ${e} must be a bigint, copySet, copyBag, or an array, not ${x(t)}`;
},
vl = (e) => Gv[Wm(e)],
Hm = (e, t) => {
t !== void 0 &&
(yo(t, "brand"),
e === t ||
f`amount's brand ${x(e)} did not match expected brand ${x(t)}`);
},
hl = (e, t, r = void 0) => {
(vr(e, "leftAmount"), vr(t, "rightAmount"));
let { value: o, brand: n } = e,
{ value: a, brand: i } = t;
(yo(n, "leftBrand"),
yo(i, "rightBrand"),
Hm(n, r),
Hm(i, r),
n === i ||
f`Brands in left ${x(n)} and right ${x(i)} should match but do not`);
let c = vl(o),
d = vl(a);
return (
c === d ||
f`The left ${e} and right amount ${t} had different assetKinds`,
c
);
},
bl = (e, t, r) => [e.doCoerce(t.value), e.doCoerce(r.value)],
vc = (e, t, r = void 0) => {
let o = hl(e, t, r);
return o.doIsGTE(...bl(o, e, t));
},
Le = {
make: (e, t) => {
yo(e, "brand");
let o = vl(t).doCoerce(t);
return harden({ brand: e, value: o });
},
coerce: (e, t) => {
(yo(e, "brand"), vr(t, "amount"));
let { brand: r, value: o } = t;
return (
e === r ||
f`The brand in the allegedAmount ${t} in 'coerce' didn't match the specified brand ${e}.`,
Le.make(e, o)
);
},
getValue: (e, t) => Le.coerce(e, t).value,
makeEmpty: (e, t = "nat") => {
(yo(e, "brand"), Sl(t));
let r = Gv[t].doMakeEmpty();
return harden({ brand: e, value: r });
},
makeEmptyFromAmount: (e) => {
vr(e, "amount");
let { brand: t, value: r } = e,
o = Wm(r);
return Le.makeEmpty(t, o);
},
isEmpty: (e, t = void 0) => {
vr(e, "amount");
let { brand: r, value: o } = e;
(yo(r, "brand"), Hm(r, t));
let n = vl(o);
return n.doIsEmpty(n.doCoerce(o));
},
isGTE: vc,
isEqual: (e, t, r = void 0) => {
let o = hl(e, t, r);
return o.doIsEqual(...bl(o, e, t));
},
add: (e, t, r = void 0) => {
let o = hl(e, t, r),
n = o.doAdd(...bl(o, e, t));
return harden({ brand: e.brand, value: n });
},
subtract: (e, t, r = void 0) => {
let o = hl(e, t, r),
n = o.doSubtract(...bl(o, e, t));
return harden({ brand: e.brand, value: n });
},
min: (e, t, r = void 0) =>
vc(e, t, r) ? t : vc(t, e, r) ? e : f`${e} and ${t} are incomparable`,
max: (e, t, r = void 0) =>
vc(e, t, r) ? e : vc(t, e) ? t : f`${e} and ${t} are incomparable`,
};
harden(Le);
var tR = (e) => {
vr(e, "amount");
let { value: t } = e;
return Wm(t);
};
harden(tR);
var Ha;
if ("VatData" in globalThis)
(globalThis.VatData || f`VatData defined in global as null or undefined`,
(Ha = globalThis.VatData));
else {
let e = () => f`VatData unavailable`;
Ha = {
defineKind: e,
defineKindMulti: e,
defineDurableKind: e,
defineDurableKindMulti: e,
makeKindHandle: e,
providePromiseWatcher: e,
watchPromise: e,
makeScalarBigMapStore: e,
makeScalarBigWeakMapStore: e,
makeScalarBigSetStore: e,
makeScalarBigWeakSetStore: e,
canBeDurable: e,
};
}
var Qv = Ha;
var {
defineKind: rR,
defineKindMulti: oR,
defineDurableKind: nR,
defineDurableKindMulti: sR,
} = Ha,
{
makeKindHandle: aR,
providePromiseWatcher: iR,
watchPromise: Lm,
makeScalarBigMapStore: qm,
makeScalarBigWeakMapStore: jm,
makeScalarBigSetStore: cR,
makeScalarBigWeakSetStore: dR,
canBeDurable: Wa,
} = Ha,
Pr =
(e, t) =>
(...r) =>
e(...r)[t];
harden(Pr);
var zv = (e, t) => {
Object.assign(e, t);
};
harden(zv);
var wo = En,
lR = (e) => {
let {
makeScalarBigMapStore: t,
makeScalarBigWeakMapStore: r,
makeScalarBigSetStore: o,
makeScalarBigWeakSetStore: n,
} = e,
a = (l, u, p = {}) => wo(l, u, () => t(u, { durable: !0, ...p }));
harden(a);
let i = (l, u, p = {}) => wo(l, u, () => r(u, { durable: !0, ...p }));
harden(i);
let c = (l, u, p = {}) => wo(l, u, () => o(u, { durable: !0, ...p }));
harden(c);
let d = (l, u, p = {}) => wo(l, u, () => n(u, { durable: !0, ...p }));
return (
harden(d),
harden({
provideDurableMapStore: a,
provideDurableWeakMapStore: i,
provideDurableSetStore: c,
provideDurableWeakSetStore: d,
})
);
},
uR = lR(Ha),
{
provideDurableMapStore: Gm,
provideDurableWeakMapStore: Qm,
provideDurableSetStore: zm,
provideDurableWeakSetStore: Ym,
} = uR;
var Yv =
(e) =>
(t, ...r) =>
e(...r);
harden(Yv);
var pR = (e) => {
let {
defineKind: t,
defineKindMulti: r,
defineDurableKind: o,
defineDurableKindMulti: n,
makeKindHandle: a,
} = e,
i = (g, S) => wo(g, `${S}_kindHandle`, () => a(S));
harden(i);
let c = (g, S, w, I, E = void 0) => o(i(g, S), w, I, E);
harden(c);
let d = (g, S, w, I, E = void 0) => n(i(g, S), w, I, E);
harden(d);
let l = (g, S, w, I, E) =>
t(g, w, I, { ...E, thisfulMethods: !0, interfaceGuard: S });
harden(l);
let u = (g, S, w, I, E) =>
r(g, w, I, { ...E, thisfulMethods: !0, interfaceGuardKit: S });
harden(u);
let p = (g, S, w, I, E) =>
o(g, w, I, { ...E, thisfulMethods: !0, interfaceGuard: S });
harden(p);
let y = (g, S, w, I, E) =>
n(g, w, I, { ...E, thisfulMethods: !0, interfaceGuardKit: S });
harden(y);
let b = (g, S, w, I, E, K = void 0) => p(i(g, S), w, I, E, K);
harden(b);
let m = (g, S, w, I, E, K = void 0) => y(i(g, S), w, I, E, K);
harden(m);
let v = (g, S, w, I, E = void 0) => {
let K = b(g, S, w, Va, I, E);
return wo(g, `${S}_singleton`, () => K());
};
harden(v);
let h = (g, S, w, I = void 0) => v(g, S, void 0, w, I);
return (
harden(h),
harden({
defineVirtualExoClass: l,
defineVirtualExoClassKit: u,
defineDurableExoClass: p,
defineDurableExoClassKit: y,
prepareExoClass: b,
prepareExoClassKit: m,
prepareExo: v,
prepareSingleton: h,
provideKindHandle: i,
prepareKind: c,
prepareKindMulti: d,
})
);
},
Zv = pR(Qv),
{
defineVirtualExoClass: mR,
defineVirtualExoClassKit: fR,
defineDurableExoClass: yR,
defineDurableExoClassKit: gR,
prepareExoClass: Sc,
prepareExoClassKit: xc,
prepareExo: Zm,
prepareSingleton: hR,
} = Zv,
{ provideKindHandle: bR, prepareKind: vR, prepareKindMulti: SR } = Zv;
var Xv = (e) => harden([e]);
harden(Xv);
var Ac = (e, t, r = void 0) => {
let o = t.detached().setStore(`${e} used keys`),
n = (c) => {
(typeof c == "string" || f`key ${c} must be a string`,
!o.has(c) ||
f`key ${c} has already been used in this zone and incarnation`,
o.add(c));
},
a =
(c, d = Xv) =>
(u, ...p) => {
for (let y of d(u)) n(y);
return c(u, ...p);
},
i = (c, d) => {
if ((n(c), r && r.has(c))) return r.get(c);
let l = d(c);
return (
t.isStorable(l) || f`maker return value ${l} is not storable`,
r && r.init(c, l),
l
);
};
return harden({ makeOnce: i, wrapProvider: a });
};
harden(Ac);
var Xm = (e) => `${e}_kindHandle`,
xR = (e) => `${e}_singleton`,
Yt = {
exoClass: (e) => harden([Xm(e)]),
exoClassKit: (e) => harden([Xm(e)]),
exo: (e) => harden([Xm(e), xR(e)]),
store: (e) => harden([e]),
zone: (e) => harden([e]),
};
harden(Yt);
var { apply: AR } = Reflect,
xl = s.call(s.raw()).rest(s.raw()).returns(),
Po = s.interface("PromiseWatcher", { onFulfilled: xl, onRejected: xl }),
mH = s.interface("PromiseWatcherFulfilled", { onFulfilled: xl }),
fH = s.interface("PromiseWatcherRejected", { onRejected: xl }),
eS = (e, t, r) => {
let o = e[t];
return o
? (assert.typeof(o, "function"),
(a) => {
AR(o, e, [a, ...r]);
})
: void 0;
},
ef = (e, t, ...r) => {
Promise.resolve(e) === e || f`watchPromise only watches promises`;
let o = eS(t, "onFulfilled", r),
n = eS(t, "onRejected", r);
(o ||
n ||
f`promise watcher must implement at least one handler method`,
O.when(e, o, n));
};
harden(ef);
var tS = (e) => or(e) && Wa(e);
harden(tS);
var rS = (e) =>
se("durableStores", {
detached: () => wR,
isStorable: tS,
mapStore: (a, i) => {
let c = e();
return Gm(c, a, i);
},
setStore: (a, i) => zm(e(), a, i),
weakMapStore: (a, i) => Qm(e(), a, i),
weakSetStore: (a, i) => Ym(e(), a, i),
}),
wR = rS(() => Go("detached")),
xs = (e, t = "durableZone") => {
e || f`baggage required`;
let r = rS(() => e),
{ makeOnce: o, wrapProvider: n } = Ac(t, r, e),
a = (...u) => Sc(e, ...u),
i = (...u) => xc(e, ...u),
c = (...u) => Zm(e, ...u),
d = n(r.mapStore, Yt.zone),
l = (u, p = {}) => {
let y = d(u, p);
return xs(y, `${t}.${u}`);
};
return se("durableZone", {
exo: n(c, Yt.exo),
exoClass: n(a, Yt.exoClass),
exoClassKit: n(i, Yt.exoClassKit),
subZone: l,
makeOnce: o,
watchPromise: Lm,
detached: r.detached,
isStorable: r.isStorable,
mapStore: n(r.mapStore, Yt.store),
setStore: n(r.setStore, Yt.store),
weakMapStore: n(r.weakMapStore, Yt.store),
weakSetStore: n(r.weakSetStore, Yt.store),
});
};
harden(xs);
var ot = s.remotable("Brand"),
ir = s.remotable("Issuer"),
Zt = s.remotable("Payment"),
sS = s.remotable("Purse"),
PR = s.remotable("DepositFacet"),
kR = s.remotable("Notifier"),
IR = s.remotable("Mint"),
aS = s.nat(),
iS = s.set(),
cS = s.arrayOf(s.key()),
dS = s.bag(),
TR = s.or(aS, iS, cS, dS),
et = { brand: ot, value: TR };
harden(et);
var oS = s.pattern(),
UR = { numerator: et, denominator: et };
harden(UR);
var CR = (e) => Ve(e, aS);
harden(CR);
var RR = (e) => Ve(e, iS);
harden(RR);
var OR = (e) => Ve(e, cS);
harden(OR);
var ER = (e) => Ve(e, dS);
harden(ER);
var nS = 100,
As = s.or("nat", "set", "copySet", "copyBag"),
ko = s.splitRecord(
{},
{ decimalPlaces: s.and(s.gte(-nS), s.lte(nS)), assetKind: As },
{},
),
tf = {
brand: ot,
mint: IR,
mintRecoveryPurse: sS,
issuer: ir,
displayInfo: ko,
};
harden(tf);
var lS = s.interface("Brand", {
isMyIssuer: s.callWhen(s.await(ir)).returns(s.boolean()),
getAllegedName: s.call().returns(s.string()),
getDisplayInfo: s.call().returns(ko),
getAmountShape: s.call().returns(s.pattern()),
}),
rf = (e = ot, t = As, r = et) => {
let o = s.interface("Issuer", {
getBrand: s.call().returns(e),
getAllegedName: s.call().returns(s.string()),
getAssetKind: s.call().returns(t),
getDisplayInfo: s.call().returns(ko),
makeEmptyPurse: s.call().returns(sS),
isLive: s.callWhen(s.await(Zt)).returns(s.boolean()),
getAmountOf: s.callWhen(s.await(Zt)).returns(r),
burn: s.callWhen(s.await(Zt)).optional(oS).returns(r),
}),
n = s.interface("Mint", {
getIssuer: s.call().returns(ir),
mintPayment: s.call(r).returns(Zt),
}),
a = s.interface("Payment", { getAllegedBrand: s.call().returns(e) }),
i = s.interface("Purse", {
getAllegedBrand: s.call().returns(e),
getCurrentAmount: s.call().returns(r),
getCurrentAmountNotifier: s.call().returns(kR),
deposit: s.call(Zt).optional(oS).returns(r),
getDepositFacet: s.call().returns(PR),
withdraw: s.call(r).returns(Zt),
getRecoverySet: s.call().returns(s.setOf(Zt)),
recoverAll: s.call().returns(r),
}),
c = s.interface("DepositFacet", {
receive: Ao(i).methodGuards.deposit,
}),
d = { purse: i, depositFacet: c };
return (
harden(d),
harden({ IssuerI: o, MintI: n, PaymentI: a, PurseIKit: d })
);
};
harden(rf);
var uS = (e, t) => {
(Kt(e, ko, "displayInfo"),
e.assetKind !== void 0 &&
(e.assetKind === t ||
f`displayInfo.assetKind was present (${e.assetKind}) and did not match the assetKind argument (${t})`));
let r = harden({ ...e, assetKind: t });
return (
r.decimalPlaces !== void 0 &&
(Number.isSafeInteger(r.decimalPlaces) ||
f`decimalPlaces ${r.decimalPlaces} is not a safe integer`),
r
);
};
var of = (e, t, r, o) =>
e.exoClass(`${t} payment`, o, Va, {
getAllegedBrand() {
return r;
},
});
harden(of);
var La = () => {},
wl = (e) => {
let t = harden(Promise.reject(e));
return (O.when(t, La, La), t);
},
sf = wl(harden(Error("Cannot read past end of iteration."))),
DR = s.interface("Publisher", {
publish: s.call(s.any()).returns(),
finish: s.call(s.any()).returns(),
fail: s.call(s.any()).returns(),
}),
NR = s.or(s.bigint(), s.number()),
af = s.interface("Subscriber", {
subscribeAfter: s.call().optional(s.bigint()).returns(s.promise()),
getUpdateSince: s.call().optional(NR).returns(s.promise()),
}),
BR = harden({ publisher: DR, subscriber: af }),
MR = s.interface("ForkableAsyncIterableIterator", {
fork: s.call().returns(s.any()),
[Symbol.asyncIterator]: s.call().returns(s.any()),
next: s.callWhen().returns(s.any()),
}),
$R = s.interface("IterableEachTopic", {
subscribeAfter: Ao(af).methodGuards.subscribeAfter,
[Symbol.asyncIterator]: s
.call()
.returns(s.remotable("ForkableAsyncIterableIterator")),
}),
_R = s.interface("IterableLatestTopic", {
getUpdateSince: Ao(af).methodGuards.getUpdateSince,
[Symbol.asyncIterator]: s
.call()
.returns(s.remotable("ForkableAsyncIterableIterator")),
}),
FR = (e) => {
let t = new WeakMap();
return (r) => {
let o = r;
if (t.has(o)) return t.get(o);
let n = e(r);
return (t.set(o, n), n);
};
},
pS = (e) => {
let {
head: { value: t, done: r },
publishCount: o,
} = e;
return r
? harden({ value: t, updateCount: void 0 })
: harden({ value: t, updateCount: o });
},
Nn = () => {
let e, t;
({ promise: e, resolve: t } = xt());
let r = 0n,
o = e,
n = (d, l, u) => {
if (t === void 0)
throw Error("Cannot update state after termination.");
((r += 1n), (o = e));
let p = t;
(d ? ((e = sf), (t = void 0)) : ({ promise: e, resolve: t } = xt()),
p(
u ||
harden({
head: { value: l, done: d },
publishCount: r,
tail: e,
}),
));
},
a = FR(pS),
i = se("Subscriber", {
subscribeAfter: (d = -1n) => {
if ((assert.typeof(d, "bigint"), d === r)) return e;
if (d < r) return o;
throw Error(
"subscribeAfter argument must be a previously-issued publishCount.",
);
},
getUpdateSince: (d) =>
d === void 0
? i.subscribeAfter().then(a)
: ((d = BigInt(d)),
i.subscribeAfter(d).then(() => i.getUpdateSince())),
}),
c = se("Publisher", {
publish: (d) => {
n(!1, d);
},
finish: (d) => {
n(!0, d);
},
fail: (d) => {
n(!0, void 0, wl(d));
},
});
return harden({ publisher: c, subscriber: i });
};
harden(Nn);
var KR = harden({
valueDurability: s.any(),
publishCount: s.any(),
status: s.any(),
hasValue: s.any(),
value: s.any(),
}),
JR = (e = {}) => {
let { valueDurability: t = "mandatory" } = e;
return (
assert.equal(t, "mandatory"),
{
valueDurability: t,
publishCount: 0n,
status: "live",
hasValue: !1,
value: void 0,
}
);
},
cf = (e) => e.publisher,
Al = new WeakMap(),
VR = (e, t, r) => {
let o = cf(t),
n = Al.get(o),
a = n && n.currentP;
if (a) return a;
let { publishCount: i, status: c, hasValue: d, value: l } = e;
if (!d) return (assert(c === "live"), r);
if (c === "live" || c === "finished") {
let u = harden({
head: { value: l, done: c !== "live" },
publishCount: i,
tail: r,
});
return O.resolve(u);
} else {
if (c === "failed") return wl(l);
throw f`Invalid durable promise kit status: ${x(c)}`;
}
},
mS = (e, t) => {
let r = cf(t),
o = Al.get(r);
if (o) return o;
let { status: n } = e,
a,
i;
if (n === "live")
(({ promise: a, resolve: i } = xt()), O.when(a, La, La));
else if (n === "finished" || n === "failed") a = sf;
else throw f`Invalid durable promise kit status: ${x(n)}`;
let c = harden({ currentP: void 0, tailP: a, tailR: i });
return (Al.set(r, c), c);
},
nf = (e, t, r = "live") => {
let { state: o, facets: n } = e,
{ valueDurability: a, status: i } = o;
if (i !== "live") throw Error("Cannot update state after termination.");
let c = r !== "live";
(c || a === "mandatory") &&
(Wa(t) || f`Cannot accept non-durable value: ${t}`);
let { tailP: d, tailR: l } = mS(o, n);
assert.typeof(l, "function");
let u = o.publishCount + 1n;
o.publishCount = u;
let p, y;
c
? ((o.status = r), (p = sf), (y = void 0))
: (({ promise: p, resolve: y } = xt()), O.when(p, La, La));
let b;
if (r === "failed") {
((o.hasValue = !0), (o.value = t));
let m = wl(t);
l(m);
} else
(c || (a !== "ignored" && Wa(t))
? ((o.hasValue = !0), (o.value = t))
: ((o.hasValue = !1), (o.value = void 0), (b = d)),
l(
harden({ head: { value: t, done: c }, publishCount: u, tail: p }),
));
Al.set(cf(n), harden({ currentP: b, tailP: p, tailR: y }));
},
Pl = (e, t) => {
let r = pS;
return xc(
e,
t,
BR,
JR,
{
publisher: {
publish(o) {
nf(this, o);
},
finish(o) {
nf(this, o, "finished");
},
fail(o) {
nf(this, o, "failed");
},
},
subscriber: {
subscribeAfter(o = -1n) {
let { state: n, facets: a } = this,
{ publishCount: i } = n,
{ currentP: c, tailP: d } = mS(n, a);
if (o === i) return d;
if (o < i) return c || VR(n, a, d);
throw Error(
"subscribeAfter argument must be a previously-issued publishCount.",
);
},
getUpdateSince(o) {
let {
facets: { subscriber: n },
} = this;
return o === void 0
? n.subscribeAfter().then(r)
: ((o = BigInt(o)),
n.subscribeAfter(o).then(() => n.getUpdateSince()));
},
},
},
{ stateShape: KR },
);
};
harden(Pl);
var wc = s.remotable("Subscriber");
var { isFrozen: fS } = Object,
HR = harden({
name: "vatUpgraded",
upgradeMessage: s.string(),
incarnationNumber: s.number(),
}),
WR = (e, t) =>
harden({
name: "vatUpgraded",
upgradeMessage: e,
incarnationNumber: t,
});
harden(WR);
var Bn = (e) => e != null && fS(e) && Ve(e, HR);
harden(Bn);
var kl = (e) =>
e != null && fS(e) && Ve(e, s.error()) && e.message === "vat terminated";
harden(kl);
var qa = () => {},
df = async (e, t = []) => {
let r,
o = -1 / 0;
await null;
for (let n = 0; ; n += 1)
try {
return await (n < t.length ? t[n] : e());
} catch (a) {
if (Bn(a)) {
r || (r = a);
let { incarnationNumber: i } = a;
if (i > o) {
o = i;
continue;
}
}
if (!Je(a) && r && r !== a)
try {
Ze(a, V`Attempting to recover from disconnection: ${r}`);
} catch {}
throw a;
}
};
var yS = (e, t) => {
let r = se("EachIterator", {
[Symbol.asyncIterator]: () => r,
next: () => {
let { head: o, publishCount: n, tail: a } = O.get(t);
return (
(t = df(async () => {
let c = await n;
assert.typeof(c, "bigint");
let d = await O(e).subscribeAfter(c),
l = d.publishCount;
return (
l !== c + 1n &&
f`eachIterator broken by gap from publishCount ${c} to ${l}`,
d
);
}, [a])),
O.when(n, qa, qa),
O.when(t, qa, qa),
o
);
},
fork: () => yS(e, t),
});
return r;
},
ja = (e) =>
se("EachIterable", {
[Symbol.asyncIterator]: () => {
let r = df(() => O(e).subscribeAfter());
return yS(e, r);
},
});
harden(ja);
var gS = (e, t, r) => {
let o = Promise.resolve(),
n = async () => {
if (r) return r;
let { value: i, updateCount: c } = await df(() =>
O(e).getUpdateSince(t),
);
return (
(t = c),
c === void 0
? ((r = harden({ done: !0, value: i })), r)
: harden({ done: !1, value: i })
);
},
a = se("LatestIterator", {
fork: () => gS(e, t, r),
[Symbol.asyncIterator]: () => a,
next: async () => {
if (r) return r;
let i = o.then(n);
return ((o = i.then(qa, qa)), i);
},
});
return a;
},
LR = (e) => gS(e),
Pc = (e) => se("LatestIterable", { [Symbol.asyncIterator]: () => LR(e) });
harden(Pc);
var Il = (e) => {
let t = se("notifier", {
...Pc(e),
getUpdateSince: async (r) => O(e).getUpdateSince(r),
getSharableNotifierInternals: async () => e,
getStoreKey: () => harden({ notifier: t }),
});
return t;
},
lf = (e) => {
let t = harden({
getUpdateSince: (o = void 0) => O(e).getUpdateSince(o),
});
return se("notifier", { ...Il(t), ...t });
};
harden(lf);
var uf = (...e) => {
let { publisher: t, subscriber: r } = Nn(),
o = lf(r),
n = se("updater", {
updateState: (a) => t.publish(a),
finish: (a) => t.finish(a),
fail: (a) => t.fail(a),
});
return (
xe(e.length <= 1, "too many arguments"),
e.length === 1 && n.updateState(e[0]),
harden({ notifier: o, updater: n })
);
},
hS = (e) => {
let t = O(e)[Symbol.asyncIterator](),
r,
o = 0n,
n,
a = !1,
i = se("baseNotifier", {
getUpdateSince(d = -1n) {
if (d < o) {
if (n) return Promise.resolve(n);
} else if (d !== o)
throw Error(
"getUpdateSince argument must be a previously-issued updateCount.",
);
if (a) return (xe(n !== void 0), Promise.resolve(n));
if (!r) {
let l = O(t).next();
r = O.when(
l,
({ done: u, value: p }) => (
xe(!a),
u && (a = !0),
(o += 1n),
(n = harden({ value: p, updateCount: u ? void 0 : o })),
(r = void 0),
n
),
(u) => ((a = !0), (n = l), (r = void 0), n),
);
}
return r;
},
});
return se("notifier", { ...Il(i), ...i });
};
harden(hS);
var Tl = (e) => {
let t = e.subscribeAfter();
return se("PinnedHistoryTopic", {
subscribeAfter: async (r = -1n) =>
r === -1n ? t : e.subscribeAfter(r),
getUpdateSince: async (r = void 0) => e.getUpdateSince(r),
});
};
harden(Tl);
var pf = (e) => {
let t = se("Subscription", {
...ja(e),
subscribeAfter: async (r) => O(e).subscribeAfter(r),
getSharableSubscriptionInternals: async () => e,
getStoreKey: () => harden({ subscription: t }),
});
return t;
};
harden(pf);
var mf = () => {
let { publisher: e, subscriber: t } = Nn(),
r = Tl(t),
o = pf(r),
n = se("publication", {
updateState: (a) => e.publish(a),
finish: (a) => e.finish(a),
fail: (a) => e.fail(a),
});
return harden({ publication: n, subscription: o });
};
harden(mf);
var bS = (e, t) =>
new Promise((r, o) => {
let n = () => {
O.when(
O(e).next(),
({ value: a, done: i }) => {
i
? (t.finish && t.finish(a), r(void 0))
: (t.updateState && t.updateState(a), n());
},
(a) => {
(t.fail && t.fail(a), r(void 0));
},
).catch(o);
};
n();
}),
ff = (e, t) => {
let r = O(e)[Symbol.asyncIterator]();
return bS(r, t);
};
var { freeze: vS, entries: qR } = Object,
Wr = (e) => {
if (e === null || typeof e != "object")
throw TypeError("keyMirror expects a record of string keys.");
let t = { __proto__: null };
for (let [r, o] of qR(e)) {
if (o !== null && o !== r)
throw TypeError(
`Value for key "${r}" must be null or the key string; got ${String(o)}.`,
);
t[r] = r;
}
return vS(t);
};
vS(Wr);
var jR = {
BANK: "bank",
CORE: "core",
DIBC: "dibc",
STORAGE: "storage",
PROVISION: "provision",
PROVISION_SMART_WALLET: "provisionWallet",
VLOCALCHAIN: "vlocalchain",
VTRANSFER: "vtransfer",
WALLET: "wallet",
};
harden(jR);
var GR = { vbankPort: "bank", vibcPort: "dibc" };
harden(GR);
var QR = Wr({ depositFacet: null });
harden(QR);
var zR = {
reserve: {
module: "vbank/reserve",
address: "agoric1ae0lmtzlgrcnla9xjkpaarq5d5dfez63h3nucl",
},
provision: {
module: "vbank/provision",
address: "agoric1megzytg65cyrgzs6fvzxgrcqvwwl7ugpt62346",
},
};
harden(zR);
var SS = 1,
Ae = (e, t = !0) => {
let r = (n, a = t) => Ae(`${e}.${n}`, a),
o = `----- ${e},${SS} `;
switch (((SS += 1), t)) {
case !1: {
let n = (...a) => {};
return harden(Object.assign(n, { sub: r }));
}
case "verbose": {
let n = (a, ...i) => {
typeof a?.log == "function"
? console.info(o, ...i)
: console.info(o, a, ...i);
};
return harden(Object.assign(n, { sub: r }));
}
default: {
let n = (a, ...i) => {
typeof a?.log == "function"
? a.log(o, ...i)
: console.info(o, a, ...i);
};
return harden(Object.assign(n, { sub: r }));
}
}
};
harden(Ae);
var Lr = (e, t = `unexpected ${x(e)}`) => {
if (e != null) return e;
assert.fail(t);
};
harden(Lr);
var { defineProperty: bW } = Object;
var Io = Object.entries,
Qo = Object.fromEntries,
YR = Function.prototype.call.bind(Array.prototype.map),
yf = ["debug", "log", "info", "warn", "error"];
Object.freeze(yf);
var xS = (e, t, r, o) => {
if (r && typeof t == "string") {
let l = o(e, t, r);
if (l !== e) return l;
}
if (typeof e != "object" || !e) return e;
let n = !1,
a = e,
i = ([l, u]) => {
let p = xS(u, l, a, o);
return ((n ||= p !== u), [l, p]);
},
c = Io(a).map(i);
return n ? Qo(c) : e;
},
gf = (e, t) => xS(e, void 0, void 0, t);
var AS = (e, t) => {
let r = Io(e),
n = YR(r, ([i, c]) => [i, t(c, i)]);
return Qo(n);
};
var To = (e, t, r) => {
let o = e.get(t);
if (o !== void 0 || e.has(t)) return o;
let n = r(t);
return (e.set(t, n), n);
};
var wS = (e) => f`${e} is not pure data`,
PS = At(wS, wS, { serializeBodyFormat: "smallcaps" });
harden(PS);
var { create: ZR, fromEntries: XR } = Object,
{ apply: eO } = Reflect,
tO = (e) => _r(e);
harden(tO);
var rO = (e) =>
harden(
ZR(
e,
XR(
_r(e).map((t) => [
t,
{ value: (...r) => eO(e[t], e, r), enumerable: !0 },
]),
),
),
);
harden(rO);
var Ul = [5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4, 1 / 0],
oO = Ul.map((e) => e / 1e3),
TW = {
swingset_crank_processing_time: {
description: "Processing time per crank (ms)",
unit: "ms",
boundaries: Array.of(1, 11, 21, 31, 41, 51, 61, 71, 81, 91, 1 / 0),
},
swingset_block_processing_seconds: {
description: "Processing time per block",
unit: "s",
boundaries: oO,
},
swingset_vat_startup: {
description: "Vat startup time (ms)",
unit: "ms",
boundaries: Ul,
},
swingset_vat_delivery: {
description: "Vat delivery time (ms)",
unit: "ms",
boundaries: Ul,
},
swingset_meter_usage: {
description: "Vat meter usage",
unit: "ms",
boundaries: Ul,
},
},
Uo = {
unit: "s",
advice: {
explicitBucketBoundaries: [
0.1, 0.2, 0.3, 0.4, 0.5, 1, 2, 3, 4, 5, 6, 7, 10, 15, 30,
],
},
},
UW = {
swingsetRunSeconds: {
description: "Per-block time spent executing SwingSet",
...Uo,
},
swingsetChainSaveSeconds: {
description:
"Per-block time spent propagating SwingSet state into cosmos",
...Uo,
},
swingsetCommitSeconds: {
description:
"Per-block time spent committing SwingSet state to host storage",
...Uo,
},
cosmosCommitSeconds: {
description: "Per-block time spent committing cosmos state",
...Uo,
},
fullCommitSeconds: {
description:
"Per-block time spent committing state, inclusive of COMMIT_BLOCK processing plus time spent [outside of cosmic-swingset] before and after it",
...Uo,
},
interBlockSeconds: {
description: "Time spent idle between blocks",
...Uo,
},
afterCommitHangoverSeconds: {
description:
"Per-block time spent waiting for previous-block afterCommit work",
...Uo,
},
blockLagSeconds: {
description: "The delay of each block from its expected begin time",
...Uo,
advice: {
...Uo.advice,
explicitBucketBoundaries: [
...Uo.advice.explicitBucketBoundaries,
60,
120,
180,
240,
300,
600,
3600,
],
},
},
};
var nO = { Counter: "counter", Gauge: "gauge" },
sO = [
{
key: "syscalls",
name: "swingset_all_syscall_total",
description: "Total number of SwingSet kernel calls",
},
{
key: "syscallSend",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "send" },
description: "Total number of SwingSet message send kernel calls",
},
{
key: "syscallCallNow",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "callNow" },
description:
"Total number of SwingSet synchronous device kernel calls",
},
{
key: "syscallSubscribe",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "subscribe" },
description:
"Total number of SwingSet promise subscription kernel calls",
},
{
key: "syscallResolve",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "resolve" },
description:
"Total number of SwingSet promise resolution kernel calls",
},
{
key: "syscallExit",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "exit" },
description: "Total number of SwingSet vat exit kernel calls",
},
{
key: "syscallVatstoreGet",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "vatstoreGet" },
description: "Total number of SwingSet vatstore get kernel calls",
},
{
key: "syscallVatstoreSet",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "vatstoreSet" },
description: "Total number of SwingSet vatstore set kernel calls",
},
{
key: "syscallVatstoreGetNextKey",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "vatstoreGetNext" },
description:
"Total number of SwingSet vatstore getNextKey kernel calls",
},
{
key: "syscallVatstoreDelete",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "vatstoreDelete" },
description: "Total number of SwingSet vatstore delete kernel calls",
},
{
key: "syscallDropImports",
name: "swingset_syscall_total",
sub: { dimension: "syscall", value: "dropImports" },
description: "Total number of SwingSet drop imports kernel calls",
},
{
key: "dispatches",
name: "swingset_dispatch_total",
description: "Total number of SwingSet vat calls",
},
{
key: "dispatchDeliver",
name: "swingset_dispatch_deliver_total",
description: "Total number of SwingSet vat message deliveries",
},
{
key: "dispatchNotify",
name: "swingset_dispatch_notify_total",
description: "Total number of SwingSet vat promise notifications",
},
],
aO = [
{
key: "kernelObjects",
name: "swingset_kernel_objects",
description: "Active kernel objects",
},
{
key: "kernelDevices",
name: "swingset_kernel_devices",
description: "Active kernel devices",
},
{
key: "kernelPromises",
name: "swingset_kernel_promises",
description: "Active kernel promises",
},
{
key: "kpUnresolved",
name: "swingset_unresolved_kernel_promises",
description: "Unresolved kernel promises",
},
{
key: "kpFulfilled",
name: "swingset_fulfilled_kernel_promises",
description: "Fulfilled kernel promises",
},
{
key: "kpRejected",
name: "swingset_rejected_kernel_promises",
description: "Rejected kernel promises",
},
{
key: "runQueueLength",
name: "swingset_run_queue_length",
consensus: !0,
description: "Length of the kernel run queue",
},
{
key: "acceptanceQueueLength",
name: "swingset_acceptance_queue_length",
consensus: !0,
description: "Length of the kernel acceptance queue",
},
{
key: "promiseQueuesLength",
name: "swingset_promise_queues_length",
consensus: !0,
description: "Combined length of all kernel promise queues",
},
{
key: "clistEntries",
name: "swingset_clist_entries",
description: "Number of entries in the kernel c-list",
},
{
key: "vats",
name: "swingset_vats",
description: "Number of active vats",
},
],
{ Counter: iO, Gauge: cO } = nO,
dO = harden([
...sO.map((e) => ({ ...e, metricType: iO })),
...aO.map((e) => ({ ...e, metricType: cO })),
]),
hf = new Map();
for (let { key: e } of dO) hf.set(e, (hf.get(e) || 0) + 1);
var kS = [...hf.entries()].flatMap(([e, t]) => (t > 1 ? [e] : []));
if (kS.length > 0) {
let e = `Duplicate kernel stats keys ${JSON.stringify(kS)}`;
throw Error(e);
}
var lO = (e, t) => {
let r = +e - +t,
o =
(Number.isFinite(r) && r) ||
(e === t
? 0
: Number(BigInt(e) - BigInt(t)) || e.length - t.length);
return Math.sign(o);
},
Cl = (e, t) => (e > t ? 1 : e < t ? -1 : 0),
IS = /([0-9]+)/,
Rl = new Map(),
uO = (e, t) => {
Rl.size || Promise.resolve().then(() => Rl.clear());
let r = To(Rl, e, () => e.split(IS)),
o = To(Rl, t, () => t.split(IS)),
n = 0;
for (; n + 1 < r.length; n += 2)
if (n + 1 < o.length) {
let a = Cl(r[n], o[n]) || lO(r[n + 1], o[n + 1]);
if (a) return a;
} else return Cl(`${r[n]}${r[n + 1]}`, o[n]);
return o.length > r.length
? Cl(r[n], `${o[n]}${o[n + 1]}`)
: Cl(r[n], o[n]);
};
harden(uO);
var { getOwnPropertyDescriptors: pO, create: mO, fromEntries: fO } = Object,
{ ownKeys: yO } = Reflect,
TS = (e, t, r = Object.prototype) => {
let o = pO(e),
a = yO(e)
.map((i) => [i, t(o[i], i)])
.filter(([i, c]) => c !== void 0);
return harden(mO(r, fO(a)));
};
harden(TS);
var bf = Object.freeze,
Ol = () => {
let { promise: e, resolve: t } = xt();
return {
put(r) {
let { resolve: o, promise: n } = xt();
(t(bf({ value: r, promise: n })), (t = o));
},
get() {
let r = e.then((o) => o.value);
return ((e = e.then((o) => o.promise)), harden(r));
},
};
};
harden(Ol);
var vf = (e, t) => {
let r = harden({
next(o) {
return (t.put(bf({ value: o, done: !1 })), e.get());
},
return(o) {
return (t.put(bf({ value: o, done: !0 })), e.get());
},
throw(o) {
return (t.put(harden(Promise.reject(o))), e.get());
},
[Symbol.asyncIterator]() {
return r;
},
});
return r;
};
harden(vf);
var gO = () => {
let e = Ol(),
t = Ol(),
r = vf(t, e),
o = vf(e, t);
return harden([o, r]);
};
harden(gO);
var hO = async (e, t, r) => {
let o = (a) =>
O.when(
a,
(i) => (i.done ? e.return(i.value) : n(e.next(i.value))),
(i) => e.throw(i),
),
n = (a) =>
O.when(
a,
(i) => (i.done ? t.return(i.value) : o(t.next(i.value))),
(i) => t.throw(i),
);
await o(t.next(r));
};
harden(hO);
var bO = (e, t) => {
let r = e.next(t),
o;
return harden({
async next(a) {
return o === void 0 && ((o = await r), o.done) ? o : e.next(a);
},
async return(a) {
return o === void 0 && ((o = await r), o.done) ? o : e.return(a);
},
async throw(a) {
if (o === void 0 && ((o = await r), o.done)) throw a;
return e.throw(a);
},
});
};
harden(bO);
var vO = (e, t) => {
async function* r() {
for await (let o of e) yield t(o);
return void 0;
}
return (harden(r), harden(r()));
};
harden(vO);
var SO = (e, t) => {
let r = harden({
async next(o) {
return e.next(t(o));
},
async throw(o) {
return e.throw(o);
},
async return(o) {
return e.return(o);
},
[Symbol.asyncIterator]() {
return r;
},
});
return r;
};
harden(SO);
var Sf = (e) => harden(new Promise(e));
harden(Sf);
var xO = (e) => harden(new Map(e));
harden(xO);
var AO = (e) => harden(new Set(e));
harden(AO);
var wO = (e) => harden(new WeakMap(e));
harden(wO);
var PO = (e) => harden(new WeakSet(e));
harden(PO);
var xf = (e) =>
harden({
[Symbol.asyncIterator]: () => harden({ next: async () => harden(e()) }),
});
harden(xf);
var kO = (e) =>
Sf((t, r) => {
let o = async () => {
if (!(await e())) {
t(void 0);
return;
}
o().catch(r);
};
o().catch(r);
});
harden(kO);
var { fromEntries: US, keys: IO, values: TO } = Object,
UO = (e) => {
let t = US(yf.map((r) => [r, e(r)]));
return harden(t);
};
harden(UO);
var CS = async (e) => (!Je(e) || f`param must be an object`, Lo(e));
var RS = (e, t) => (
t.startsWith(e) || f`${t} is missing prefix ${x(e)}`,
t.slice(e.length)
);
var kc = (e) => {
let t = [];
for (let [r, o] of Object.entries(e)) o === void 0 && t.push(r);
t.length > 0 && f`missing ${x(t)}`;
};
var CO = harden({ done: !1, value: void 0 }),
a7 = harden({ done: !0, value: void 0 }),
i7 = xf(() => CO);
var RO = (e, t) => harden(e.map((r, o) => [r, t[+o]])),
OS = async (e) => {
let t = await Promise.all(TO(e));
return harden(US(RO(IO(e), t)));
};
var zo = Be;
var ES = s.remotable("StorageNode"),
m7 = s.interface("helper", {}, { defaultGuards: "passable" }),
f7 = s.or(s.number(), s.string());
var Mn = se("heapStores", {
detached: () => Mn,
isStorable: or,
setStore: hc,
mapStore: Go,
weakMapStore: vs,
weakSetStore: yc,
}),
Yo = (e = "heapZone") => {
let { makeOnce: t, wrapProvider: r } = Ac(e, Mn),
o = (n, a) => Yo(`${e}.${n}`);
return se("heapZone", {
exo: r(gl, Yt.exo),
exoClass: r(bc, Yt.exoClass),
exoClassKit: r(yl, Yt.exoClassKit),
subZone: r(o),
makeOnce: t,
watchPromise: ef,
detached: Mn.detached,
isStorable: Mn.isStorable,
mapStore: r(Mn.mapStore),
setStore: r(Mn.setStore),
weakMapStore: r(Mn.weakMapStore),
weakSetStore: r(Mn.weakSetStore),
});
};
harden(Yo);
var { fromEntries: OO } = Object,
{ ownKeys: EO } = Reflect,
DO = EO,
NO = (e) => {
switch (typeof e) {
case "string":
case "number":
case "symbol":
return !0;
default:
return !1;
}
},
DS = (e, ...t) => {
let { target: r, methodName: o, bound: n } = e;
return o === void 0 ? r(...n, ...t) : r[o](...n, ...t);
};
harden(DS);
var Ic = (e, ...t) => {
let { target: r, methodName: o, bound: n } = e;
return o === void 0 ? O(r)(...n, ...t) : O(r)[o](...n, ...t);
};
harden(Ic);
var BO = (e, ...t) => (
typeof e == "function" ||
f`sync function callback target must be a function: ${e}`,
harden({ target: e, bound: t, isSync: !0 })
);
harden(BO);
var Af = (e, ...t) => (
!Je(e) || f`function callback target must be a function presence: ${e}`,
harden({ target: e, bound: t })
);
harden(Af);
var NS = (e, t, ...r) => (
!Je(e) || f`sync method callback target must be an object: ${e}`,
typeof t == "string" ||
ps(t) ||
f`method name must be a string or passable symbol: ${t}`,
harden({ target: e, methodName: t, bound: r, isSync: !0 })
);
harden(NS);
var BS = (e, t, ...r) => (
!Je(e) || f`method callback target must be an object: ${e}`,
typeof t == "string" ||
ps(t) ||
f`method name must be a string or passable symbol: ${t}`,
harden({ target: e, methodName: t, bound: r })
);
harden(BS);
var MS = (e) => {
if (Je(e)) return !1;
let { target: t, methodName: r, bound: o } = e;
return (
!Je(t) &&
(r === void 0 || typeof r == "string" || ps(r)) &&
Array.isArray(o)
);
};
harden(MS);
var $S = (e, t, { interfaceGuard: r, tag: o = "Attenuator" } = {}) => {
let n = OO(
t.map((i) => {
if (!NO(i)) throw f`key ${x(i)} is not a PropertyKey`;
let c = {
[i](...d) {
let l = this.state.cbs[i];
if (!l) {
let u = Se(`unimplemented ${x(o)} method ${x(i)}`);
if (this.state.isSync) throw u;
return Promise.reject(u);
}
return l.isSync ? DS(l, ...d) : Ic(l, ...d);
},
}[i];
return [i, c];
}),
);
return e.exoClass(
o,
r,
({ target: i = null, isSync: c = !1, overrides: d = {} }) => {
let l = {},
u = new Set(t);
for (let p of DO(d)) {
(u.has(p) ||
f`${x(o)} overrides[${x(p)}] not allowed by methodNames`,
u.delete(p));
let y = d[p];
(y == null ||
MS(y) ||
f`${x(o)} overrides[${x(p)}] is not a callback; got ${y}`,
(l[p] = y));
}
for (let p of u) c ? (l[p] = NS(i, p)) : (l[p] = BS(i, p));
return harden({ cbs: l, isSync: c });
},
n,
);
};
harden($S);
var MO = (e, t, r = {}) => {
let o = ul(t);
return $S(e, o, { ...r, interfaceGuard: t });
};
harden(MO);
var Q7 = harden({ blockHeight: s.string(), values: s.array() }),
_O = s.interface("StorageNode", {
setValue: s.callWhen(s.string()).returns(),
getPath: s.call().returns(s.string()),
getStoreKey: s.callWhen().returns(s.record()),
makeChildNode: s
.call(s.string())
.optional(s.splitRecord({}, { sequence: s.boolean() }, {}))
.returns(s.remotable("StorageNode")),
}),
FO = (e) =>
e &&
typeof e == "object" &&
Array.isArray(e.values) &&
typeof e.blockHeight == "string" &&
/^0$|^[1-9][0-9]*$/.test(e.blockHeight);
harden(FO);
var KO = /^[a-zA-Z0-9_-]{1,100}$/,
_S = (e) => {
KO.test(e) ||
f`Path segment names must consist of 1 to 100 characters limited to ASCII alphanumerics, underscores, and/or dashes: ${e}`;
};
harden(_S);
var JO = (e) => {
let t = e.exoClass(
"ChainStorageNode",
_O,
(r, o, { sequence: n = !1 } = {}) => (
assert.typeof(o, "string"),
assert.typeof(n, "boolean"),
harden({ path: o, messenger: r, sequence: n })
),
{
getPath() {
return this.state.path;
},
async getStoreKey() {
let { path: r, messenger: o } = this.state;
return Ic(o, { method: "getStoreKey", args: [r] });
},
makeChildNode(r, o = {}) {
let { sequence: n, path: a, messenger: i } = this.state;
_S(r);
let c = { sequence: n, ...o };
return t(i, `${a}.${r}`, c);
},
async setValue(r) {
let { sequence: o, path: n, messenger: a } = this.state;
assert.typeof(r, "string");
let i;
(!o && !r ? (i = [n]) : (i = [n, r]),
await Ic(a, { method: o ? "append" : "set", args: [i] }));
},
},
);
return t;
},
VO = JO(Yo());
function HO(e, t, r = {}) {
let o = Af(e);
return VO(o, t, r);
}
var WO = () =>
HO(
se("NullMessenger", () => null),
"null",
);
async function LO(e, t) {
let o = (await e) || WO();
return O(o).makeChildNode(t);
}
harden(LO);
var wf = (e, t) => async (r) => {
let o = await O(t).toCapData(r),
n = JSON.stringify(o);
return O(e).setValue(n);
};
var qO = async (e, t) => {
let r = ja(e)[Symbol.asyncIterator](),
o = !1;
for (await null; !o; ) {
let { value: n, done: a } = await r.next();
(await t(n), (o = !!a));
}
},
jO = (e, t, r) => {
kc({ subscriber: e, storageNode: t, marshaller: r });
let o = wf(t, r);
qO(e, o).catch((i) => {
console.error("StoredSubscriber failed to iterate", i);
});
let n = se("unserializer", {
fromCapData: (i) => O(r).fromCapData(i),
unserialize: (i) => O(r).fromCapData(i),
});
return se("StoredSubscriber", {
subscribeAfter: (i) => e.subscribeAfter(i),
getUpdateSince: (i) => e.getUpdateSince(i),
getPath: () => O(t).getPath(),
getStoreKey: () => O(t).getStoreKey(),
getUnserializer: () => n,
});
},
GO = (
e,
t,
r = At(void 0, void 0, {
marshalSaveError: () => {},
serializeBodyFormat: "smallcaps",
}),
) => {
let o = se("unserializer", {
fromCapData: (l) => O(r).fromCapData(l),
unserialize: (l) => O(r).fromCapData(l),
}),
n = !1,
a,
i = (l) => {
((n = !0), (a = l));
},
c = (l) => {
if ((assert(t), n)) throw a;
O(r)
.toCapData(l)
.then((u) => {
let p = JSON.stringify(u);
return O(t).setValue(p);
})
.catch(i);
};
return (
t && ff(e, { updateState: c, finish: c }).catch(i),
se("StoredSubscription", {
getStoreKey: async () => {
if (!t) return harden({ subscription: e });
let l = await O(t).getStoreKey();
return harden({ ...l, subscription: e });
},
getUnserializer: () => o,
getSharableSubscriptionInternals: () =>
e.getSharableSubscriptionInternals(),
[Symbol.asyncIterator]: () => e[Symbol.asyncIterator](),
subscribeAfter: (l) => e.subscribeAfter(l),
})
);
};
harden(GO);
var QO = (e, t) => {
let { publisher: r, subscriber: o } = Nn();
return { publisher: r, subscriber: jO(o, e, t) };
};
harden(QO);
var Pf = () => {
let e = jm("transientNotiferKits"),
t = (n) => En(e, n, () => uf(n.getCurrentAmount()));
return {
provideNotifier: (n) => t(n).notifier,
update: (n, a) => {
if (e.has(n)) {
let { updater: i } = e.get(n);
i.updateState(a);
}
},
};
};
harden(Pf);
var Tc = (e, t) =>
harden({
getAmount: () => e[t],
increment: (r) => {
e[t] = Le.add(e[t], r);
},
decrement: (r) =>
Le.isGTE(e[t], r) ? ((e[t] = Le.subtract(e[t], r)), !0) : !1,
});
harden(Tc);
var YO = Ar([]),
kf = (e, t, r, o, n, a, i, c) => {
let d = o.getAmountShape(),
{ provideNotifier: l, update: u } = Pf(),
p = (v) => {
let { recoverySet: h } = v;
if (i === "hasRecoverySets") return h;
(i === "noRecoverySets" ||
f`recoverSetsState must be noRecoverySets if it isn't hasRecoverSets`,
c !== void 0 || f`paymentRecoverySets must always be defined`,
h.getSize() === 0 ||
f`With noRecoverySets, recoverySet must be empty`);
},
{ depositInternal: y, withdrawInternal: b } = a,
m = e.exoClassKit(
`${t} Purse`,
n,
() => {
let v = Le.makeEmpty(o, r),
h = e.detached().setStore("recovery set");
return { currentBalance: v, recoverySet: h };
},
{
purse: {
deposit(v, h = void 0) {
let { state: g } = this,
{ purse: S } = this.facets,
w = Tc(g, "currentBalance"),
I = y(w, v, h);
return (u(S, w.getAmount()), I);
},
withdraw(v) {
let { state: h } = this,
{ purse: g } = this.facets,
S = p(h),
w = Tc(h, "currentBalance"),
I = b(w, v, S);
return (u(g, w.getAmount()), I);
},
getCurrentAmount() {
let { state: v } = this;
return Tc(v, "currentBalance").getAmount();
},
getCurrentAmountNotifier() {
return l(this.facets.purse);
},
getAllegedBrand() {
return o;
},
getDepositFacet() {
return this.facets.depositFacet;
},
getRecoverySet() {
let { state: v } = this,
h = p(v);
return h === void 0 ? YO : h.snapshot();
},
recoverAll() {
let { state: v, facets: h } = this,
g = Le.makeEmpty(o, r),
S = p(v);
if (S === void 0) return g;
for (let w of S.keys()) {
let I = h.purse.deposit(w);
g = Le.add(g, I, o);
}
return (
S.getSize() === 0 ||
f`internal: Remaining unrecovered payments: ${h.purse.getRecoverySet()}`,
g
);
},
},
depositFacet: {
receive(...v) {
return this.facets.purse.deposit(...v);
},
},
},
{
stateShape: {
currentBalance: d,
recoverySet: s.remotable("recoverySet"),
},
},
);
return () => m().purse;
};
harden(kf);
var ZO = (e, t, r) => {
let o;
switch (t) {
case "nat": {
((o = s.nat()),
r === void 0 ||
f`Fungible assets cannot have an elementShape: ${x(r)}`);
break;
}
case "set": {
r === void 0
? (o = s.arrayOf(s.key()))
: (o = s.arrayOf(s.and(s.key(), r)));
break;
}
case "copySet": {
r === void 0 ? (o = s.set()) : (o = s.setOf(r));
break;
}
case "copyBag": {
r === void 0 ? (o = s.bag()) : (o = s.bagOf(r));
break;
}
default:
f`unexpected asset kind ${x(t)}`;
}
return harden({ brand: e, value: o });
},
If = (e, t, r, o, n, a, i = void 0) => {
let c = e.exo(`${t} brand`, lS, {
isMyIssuer(T) {
return T === k;
},
getAllegedName() {
return t;
},
getDisplayInfo() {
return o;
},
getAmountShape() {
return d;
},
}),
d = ZO(c, r, n),
{ IssuerI: l, MintI: u, PaymentI: p, PurseIKit: y } = rf(c, r, d),
b = of(e, t, c, p),
m = (T) => {
if (i !== void 0)
try {
i(T);
} catch (R) {
throw (Ze(R, V`Caused by: ${T}`), R);
}
throw T;
},
v = e.weakMapStore("paymentLedger", { valueShape: d }),
h = e.weakMapStore("paymentRecoverySets"),
g = (T, R, N = void 0) => {
(a === "noRecoverySets" &&
(N === void 0 ||
f`when recoverSetsState === 'noRecoverySets', optRecoverySet must be empty`),
N !== void 0 && !Le.isEmpty(R) && (N.add(T), h.init(T, N)),
v.init(T, R));
},
S = (T) => {
if ((v.delete(T), h.has(T))) {
let R = h.get(T);
(h.delete(T), R.delete(T));
}
},
w = (T) => Le.coerce(c, T),
I = (T, R) => {
R !== void 0 && Be(T, R, "amount");
},
E = (T) => {
v.has(T) ||
f`${T} was not a live payment for brand ${x(c)}. It could be a used-up payment, a payment for another brand, or it might not be a payment at all.`;
},
K = (T, R, N = void 0) => {
(!rr(R) ||
assert.fail(
"deposit does not accept promises as first argument. Instead of passing the promise (deposit(paymentPromise)), consider unwrapping the promise first: E.when(paymentPromise, (actualPayment => deposit(actualPayment))",
TypeError,
),
E(R));
let F = v.get(R);
I(F, N);
try {
(S(R), T.increment(F));
} catch (H) {
throw (m(H), H);
}
return F;
},
J = (T, R, N = void 0) => {
R = w(R);
let F = b();
T.decrement(R) ||
f`Withdrawal of ${R} failed because the purse only contained ${T.getAmount()}`;
try {
g(F, R, N);
} catch (H) {
throw (m(H), H);
}
return F;
},
P = kf(
e,
t,
r,
c,
y,
harden({ depositInternal: K, withdrawInternal: J }),
a,
h,
),
k = e.exo(`${t} issuer`, l, {
getBrand() {
return c;
},
getAllegedName() {
return t;
},
getAssetKind() {
return r;
},
getDisplayInfo() {
return o;
},
makeEmptyPurse() {
return P();
},
isLive(T) {
return v.has(T);
},
getAmountOf(T) {
return (E(T), v.get(T));
},
burn(T, R = void 0) {
E(T);
let N = v.get(T);
I(N, R);
try {
S(T);
} catch (F) {
throw (m(F), F);
}
return N;
},
}),
U = e.makeOnce("mintRecoveryPurse", () => P()),
D = e.exo(`${t} mint`, u, {
getIssuer() {
return k;
},
mintPayment(T) {
((T = w(T)), Be(T, d, "minted amount"));
let R = b();
g(R, T, void 0);
let N = U.getCurrentAmount();
U.deposit(R, T);
let F = U.withdraw(T),
H = U.getCurrentAmount();
return (assert(ar(N, H)), F);
},
});
return harden({ issuer: k, mint: D, brand: c, mintRecoveryPurse: U });
};
harden(If);
var Uf = (
{ name: e, assetKind: t, displayInfo: r, elementShape: o },
n,
a,
i = void 0,
) => {
(xe.typeof(e, "string"), Sl(t));
let c = uS(r, t);
(i !== void 0 && xe.typeof(i, "function"), o !== void 0 && zt(o));
let {
issuer: d,
mint: l,
brand: u,
mintRecoveryPurse: p,
} = If(n, e, t, c, o, a, i);
return harden({
brand: u,
issuer: d,
mint: l,
mintRecoveryPurse: p,
displayInfo: c,
});
};
harden(Uf);
var Cf = "issuer",
Tf = "recoverySetsState",
FS = (e, t = void 0, r = void 0) => {
let o = e.get(Cf),
n = xs(e),
a = e.has(Tf) ? e.get(Tf) : "hasRecoverySets";
return (
a === "noRecoverySets" &&
r === "hasRecoverySets" &&
f`Cannot (yet?) upgrade from 'noRecoverySets' to 'hasRecoverySets'`,
Uf(o, n, r || a, t)
);
};
harden(FS);
var XO = (e) => e.has(Cf),
Rf = (
e,
t,
r = Dn.NAT,
o = harden({}),
n = void 0,
{ elementShape: a = void 0, recoverySetsOption: i = void 0 } = {},
) => {
let c = harden({
name: t,
assetKind: r,
displayInfo: o,
elementShape: a,
});
e.init(Cf, c);
let d = xs(e),
l = i || "hasRecoverySets";
return (e.init(Tf, l), Uf(c, d, l, n));
};
harden(Rf);
var eE = (e, t, r = Dn.NAT, o = harden({}), n = void 0, a = {}) => {
if (XO(e)) {
let { elementShape: i = void 0, recoverySetsOption: c = void 0 } = a;
return FS(e, n, c);
} else return Rf(e, t, r, o, n, a);
};
harden(eE);
var KS = (
e,
t = Dn.NAT,
r = harden({}),
o = void 0,
{ elementShape: n = void 0, recoverySetsOption: a = void 0 } = {},
) =>
Rf(qm("dropped issuer kit", { durable: !0 }), e, t, r, o, {
elementShape: n,
recoverySetsOption: a,
});
harden(KS);
var { freeze: tE } = Object,
ws = "=",
kr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
El = {};
for (let e = 0; e < kr.length; e += 1) {
let t = kr[e];
El[t] = e;
}
tE(El);
var rE = (e) => {
let t = "",
r = 0,
o = 0;
for (let n = 0; n < e.length; n += 1) {
let a = e[n];
((r = (r << 8) | a),
(o += 8),
o === 24 &&
((t +=
kr[(r >>> 18) & 63] +
kr[(r >>> 12) & 63] +
kr[(r >>> 6) & 63] +
kr[(r >>> 0) & 63]),
(r = 0),
(o = 0)));
}
switch (o) {
case 0:
break;
case 8:
t += kr[(r >>> 2) & 63] + kr[(r << 4) & 63] + ws + ws;
break;
case 16:
t +=
kr[(r >>> 10) & 63] + kr[(r >>> 4) & 63] + kr[(r << 2) & 63] + ws;
break;
default:
throw Error(`internal: bad quantum ${o}`);
}
return t;
},
Ee = globalThis.Base64 !== void 0 ? globalThis.Base64.encode : rE;
var oE = (e, t = "<unknown>") => {
let r = new Uint8Array(Math.ceil((e.length * 4) / 3)),
o = 0,
n = 0,
a = 0,
i = 0;
for (; a < e.length && e[a] !== ws; ) {
let c = El[e[a]];
if (c === void 0)
throw Error(`Invalid base64 character ${e[a]} in string ${t}`);
((o = (o << 6) | c),
(n += 6),
n >= 8 &&
((n -= 8), (r[i] = o >>> n), (i += 1), (o &= (1 << n) - 1)),
(a += 1));
}
for (; n > 0; ) {
if (a === e.length || e[a] !== ws)
throw Error(`Missing padding at offset ${a} of string ${t}`);
((a += 1), (n -= 2));
}
if (a < e.length)
throw Error(
`Base64 string has trailing garbage ${e.substr(a)} in string ${t}`,
);
return r.subarray(0, i);
},
nE =
(e) =>
(...t) => {
let r = e(...t);
return r instanceof Uint8Array ? r : new Uint8Array(r);
},
ke = globalThis.Base64 !== void 0 ? nE(globalThis.Base64.decode) : oE;
var Of = (e) => {
let t = ke(e);
return String.fromCharCode(...t);
};
var sE = (e) =>
typeof e == "string"
? Uint8Array.from(e, (t) => {
let r = t.charCodeAt(0);
return (
r <= 255 || f`character cannot be coerced to an octet: ${t}`,
r
);
})
: e instanceof Uint8Array
? new Uint8Array(e.buffer, e.byteOffset, e.byteLength)
: new Uint8Array(e);
function JS(e) {
let t = sE(e);
return String.fromCharCode(...t);
}
function VS(e) {
return JS(ke(e));
}
var Uc = {
Data: s.string(),
Bytes: s.string(),
Endpoint: s.string(),
Vow: s.tagged("Vow", harden({ vowV0: s.remotable("VowV0") })),
ConnectionHandler: s.remotable("ConnectionHandler"),
Connection: s.remotable("Connection"),
InboundAttempt: s.remotable("InboundAttempt"),
Listener: s.remotable("Listener"),
ListenHandler: s.remotable("ListenHandler"),
Port: s.remotable("Port"),
ProtocolHandler: s.remotable("ProtocolHandler"),
ProtocolImpl: s.remotable("ProtocolImpl"),
},
Ef = s.splitRecord({}, { relativeTimeoutNs: s.bigint() }),
de = {
...Uc,
Vow$: (e) => s.or(e, Uc.Vow),
AttemptDescription: s.splitRecord(
{ handler: Uc.ConnectionHandler },
{ remoteAddress: Uc.Endpoint, localAddress: Uc.Endpoint },
),
Opts: Ef,
},
dt = harden({
...de,
ConnectionI: {
connection: s.interface("Connection", {
send: s
.callWhen(de.Data)
.optional(de.Opts)
.returns(de.Vow$(de.Bytes)),
close: s.callWhen().returns(de.Vow$(s.undefined())),
getLocalAddress: s.call().returns(de.Endpoint),
getRemoteAddress: s.call().returns(de.Endpoint),
}),
openConnectionAckWatcher: s.interface("OpenConnectionAckWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()),
}),
rethrowUnlessMissingWatcher: s.interface(
"RethrowUnlessMissingWatcher",
{ onRejected: s.call(s.any()).rest(s.any()).returns(s.any()) },
),
sinkWatcher: s.interface("SinkWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(),
}),
},
InboundAttemptI: {
inboundAttempt: s.interface("InboundAttempt", {
accept: s
.callWhen(de.AttemptDescription)
.returns(de.Vow$(de.Connection)),
getLocalAddress: s.call().returns(de.Endpoint),
getRemoteAddress: s.call().returns(de.Endpoint),
close: s.callWhen().returns(de.Vow$(s.undefined())),
}),
inboundAttemptAcceptWatcher: s.interface(
"InboundAttemptAcceptWatcher",
{ onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()) },
),
rethrowUnlessMissingWatcher: s.interface(
"RethrowUnlessMissingWatcher",
{ onRejected: s.call(s.any()).rest(s.any()).returns(s.any()) },
),
sinkWatcher: s.interface("SinkWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(),
}),
},
PortI: {
port: s.interface("Port", {
getLocalAddress: s.call().returns(de.Endpoint),
addListener: s
.callWhen(de.Listener)
.returns(de.Vow$(s.undefined())),
connect: s
.callWhen(de.Endpoint)
.optional(de.ConnectionHandler)
.returns(de.Vow$(de.Connection)),
removeListener: s
.callWhen(de.Listener)
.returns(de.Vow$(s.undefined())),
revoke: s.callWhen().returns(de.Vow$(s.undefined())),
}),
portAddListenerWatcher: s.interface("PortAddListenerWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()),
}),
portRemoveListenerWatcher: s.interface("PortRemoveListenerWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()),
}),
portConnectWatcher: s.interface("PortConnectWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()),
}),
portRevokeWatcher: s.interface("PortRevokeWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()),
}),
portRevokeCleanupWatcher: s.interface("PortRevokeCleanupWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()),
}),
rethrowUnlessMissingWatcher: s.interface(
"RethrowUnlessMissingWatcher",
{ onRejected: s.call(s.any()).rest(s.any()).returns(s.any()) },
),
sinkWatcher: s.interface("SinkWatcher", {
onFulfilled: s.call(s.any()).rest(s.any()).returns(),
onRejected: s.call(s.any()).rest(s.any()).returns(s.any()),
}),
},
ProtocolHandlerI: {
protocolHandler: s.interface("ProtocolHandler", {
onCreate: s
.callWhen(s.remotable(), de.ProtocolHandler)
.returns(de.Vow$(s.undefined())),
generatePortID: s
.callWhen(de.Endpoint, de.ProtocolHandler)
.returns(de.Vow$(s.string())),
onBind: s
.callWhen(de.Port, de.Endpoint, de.ProtocolHandler)
.returns(de.Vow$(s.undefined())),
onListen: s
.callWhen(
de.Port,
de.Endpoint,
de.ListenHandler,
de.ProtocolHandler,
)
.returns(de.Vow$(s.undefined())),
onListenRemove: s
.callWhen(
de.Port,
de.Endpoint,
de.ListenHandler,
de.ProtocolHandler,
)
.returns(de.Vow$(s.undefined())),
onInstantiate: s
.callWhen(de.Port, de.Endpoint, de.Endpoint, de.ProtocolHandler)
.returns(de.Vow$(de.Endpoint)),
onConnect: s
.callWhen(
de.Port,
de.Endpoint,
de.Endpoint,
de.ConnectionHandler,
de.ProtocolHandler,
)
.returns(de.Vow$(de.AttemptDescription)),
onRevoke: s
.callWhen(de.Port, de.Endpoint, de.ProtocolHandler)
.returns(de.Vow$(s.undefined())),
}),
protocolHandlerAcceptWatcher: s.interface(
"ProtocolHandlerAcceptWatcher",
{ onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()) },
),
protocolHandlerInstantiateWatcher: s.interface(
"ProtocolHandlerInstantiateWatcher",
{ onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()) },
),
protocolHandlerConnectWatcher: s.interface(
"ProtocolHandlerConnectWatcher",
{ onFulfilled: s.call(s.any()).rest(s.any()).returns(s.any()) },
),
rethrowUnlessMissingWatcher: s.interface(
"RethrowUnlessMissingWatcher",
{ onRejected: s.call(s.any()).rest(s.any()).returns(s.any()) },
),
},
ProtocolImplI: s.interface("ProtocolImpl", {
bindPort: s.callWhen(de.Endpoint).returns(de.Vow$(de.Port)),
inbound: s
.callWhen(de.Endpoint, de.Endpoint)
.returns(de.Vow$(de.InboundAttempt)),
outbound: s
.callWhen(de.Port, de.Endpoint, de.ConnectionHandler)
.returns(de.Vow$(de.Connection)),
}),
});
var aE = () => {};
harden(aE);
var iE = "closed-by-finalizer";
var cE = { NOT_REVOKED: 0, REVOKING: 1, REVOKED: 2 };
harden(cE);
var dE = (e, { watch: t }) => {
let r = e.mapStore("objToFinalizerInfo");
return e.exo("NetworkFinalizer", void 0, {
has(o) {
return r.has(o);
},
initConnection(o, n) {
r.init(o, harden({ conn: o, handler: n }));
},
initCloser(o) {
r.init(o, harden({ closer: o }));
},
finalize(o) {
if (!r.has(o)) return;
let n = r.get(o);
if ("conn" in n) {
let { conn: a, handler: i } = n;
return (r.delete(o), t(O(i).onClose(a, iE, i)));
} else if ("closer" in n) {
let { closer: a } = n;
return (r.delete(o), t(O(a).close()));
}
},
unpin(o) {
r.delete(o);
},
});
};
harden(dE);
var FL = s.interface("Router", {
getRoutes: s.call(dt.Endpoint).returns(s.arrayOf([s.string(), s.any()])),
register: s.call(s.string(), s.any()).returns(s.undefined()),
unregister: s.call(s.string(), s.any()).returns(s.undefined()),
});
var Nf =
/^(?<hops>\/ibc-hop\/[^/]+)*\/ibc-port\/(?<portID>[^/]+)(\/(?<order>ordered|unordered)\/(?<version>[^/]+)(\/ibc-channel\/(?<channelID>[^/]+))?)?$/s;
harden(Nf);
var Df = ["ordered", "unordered", "ORDERED", "UNORDERED"];
harden(Df);
var HS = (e) => e.replaceAll("/", "\\x2f");
harden(HS);
var WS = (e) => e.replaceAll("\\x2f", "/");
harden(WS);
var LS = (e) => {
let t = e.match(Nf);
if (!(t && t.groups))
throw TypeError(
`IBC address ${e} must be '(/ibc-hop/CONNECTION)*/ibc-port/PORT/(ordered|unordered)/VERSION(/ibc-channel/CHANNEL_ID)?'`,
);
return t;
},
qS = (e) => {
let t = [];
for (; e; ) {
let r = e.match(/^\/ibc-hop\/(?<hop>[^/]+)/);
if (!r || !r.groups)
throw Error(
`internal: ${JSON.stringify(e)} did not begin with "/ibc-hop/XXX"`,
);
e = e.slice(r[0].length);
let o = r.groups.hop;
(assert(typeof o == "string" && o.startsWith("connection-")),
t.push(o));
}
return t;
};
harden(qS);
var Cc = (e) => {
let t = LS(e);
if (!t.groups)
throw Error("Unexpected error, validateRemoteIbcAddress should throw.");
let r = qS(t.groups.hops),
{ portID: o, version: n, channelID: a, order: i } = t.groups;
return {
hops: r,
portID: o,
...(i && { order: i.toUpperCase() }),
...(n && { version: WS(n) }),
...(a && { channelID: a }),
};
};
harden(Cc);
var Bf = ({
hops: e = [],
portID: t,
order: r,
version: o,
channelID: n,
}) => {
let a = (c) => typeof c == "string" && c && !c.includes("/"),
i = "";
assert(Array.isArray(e), "hops must be an array");
for (let c of e)
(assert(a(c), `invalid hop ${c}`), (i += `/ibc-hop/${c}`));
if (
(assert(a(t), `invalid portID ${t}`),
(i += `/ibc-port/${t}`),
r !== void 0)
) {
(assert(a(r), `invalid order ${r}`),
assert(
Df.includes(r),
`invalid order ${r}; ${r} not found in ${JSON.stringify(Df)}`,
));
let c = r.toLowerCase();
(assert(typeof o == "string" && o, "missing version"),
(i += `/${c}/${HS(o)}`),
n !== void 0 &&
(assert(a(n), `invalid channelID ${n}`),
(i += `/ibc-channel/${n}`)));
}
return i;
};
harden(Bf);
var jS = (e, t = !1) => {
let r = LS(e);
if (!(r && r.groups))
throw TypeError(
`Remote address ${e} must be '(/ibc-hop/CONNECTION)*/ibc-port/PORT/(ordered|unordered)/VERSION'`,
);
if (r.groups.channelID)
throw TypeError(
`Remote address ${e} must not include channelID; found ${r.groups.channelID}`,
);
return t ? r : !0;
};
harden(jS);
var lE = (e) => {
jS(e);
let { hops: t, portID: r, order: o, version: n } = Cc(e);
return (
assert(o !== void 0, "missing order"),
assert(n !== void 0, "missing version"),
{ rPortID: r, order: o, version: n, hops: t }
);
};
harden(lE);
var uE = (e) => {
let t = e.match(Nf);
if (!(t && t.groups))
throw TypeError(
`Invalid port specification ${e}; expected "/ibc-port/PORT"`,
);
for (let r of Object.keys(t.groups))
if (r !== "portID" && t.groups[r] !== void 0)
throw TypeError(
`Invalid port specification ${e}; unexpected ${r}=${t.groups[r]}`,
);
return t.groups.portID;
};
harden(uE);
var Dl = (e, t, r, o, n) =>
Bf({
hops: e,
portID: t,
order: r,
version: o,
...(n && { channelID: n }),
});
harden(Dl);
var pE = (e, t, r) => Bf({ portID: e, order: t, version: r });
harden(pE);
var Wl = Pd(Hl(), 1);
function LE(e) {
if (e.length >= 255) throw new TypeError("Alphabet too long");
let t = new Uint8Array(256);
for (let l = 0; l < t.length; l++) t[l] = 255;
for (let l = 0; l < e.length; l++) {
let u = e.charAt(l),
p = u.charCodeAt(0);
if (t[p] !== 255) throw new TypeError(u + " is ambiguous");
t[p] = l;
}
let r = e.length,
o = e.charAt(0),
n = Math.log(r) / Math.log(256),
a = Math.log(256) / Math.log(r);
function i(l) {
if (
(l instanceof Uint8Array ||
(ArrayBuffer.isView(l)
? (l = new Uint8Array(l.buffer, l.byteOffset, l.byteLength))
: Array.isArray(l) && (l = Uint8Array.from(l))),
!(l instanceof Uint8Array))
)
throw new TypeError("Expected Uint8Array");
if (l.length === 0) return "";
let u = 0,
p = 0,
y = 0,
b = l.length;
for (; y !== b && l[y] === 0; ) (y++, u++);
let m = ((b - y) * a + 1) >>> 0,
v = new Uint8Array(m);
for (; y !== b; ) {
let S = l[y],
w = 0;
for (let I = m - 1; (S !== 0 || w < p) && I !== -1; I--, w++)
((S += (256 * v[I]) >>> 0),
(v[I] = (S % r) >>> 0),
(S = (S / r) >>> 0));
if (S !== 0) throw new Error("Non-zero carry");
((p = w), y++);
}
let h = m - p;
for (; h !== m && v[h] === 0; ) h++;
let g = o.repeat(u);
for (; h < m; ++h) g += e.charAt(v[h]);
return g;
}
function c(l) {
if (typeof l != "string") throw new TypeError("Expected String");
if (l.length === 0) return new Uint8Array();
let u = 0,
p = 0,
y = 0;
for (; l[u] === o; ) (p++, u++);
let b = ((l.length - u) * n + 1) >>> 0,
m = new Uint8Array(b);
for (; u < l.length; ) {
let S = l.charCodeAt(u);
if (S > 255) return;
let w = t[S];
if (w === 255) return;
let I = 0;
for (let E = b - 1; (w !== 0 || I < y) && E !== -1; E--, I++)
((w += (r * m[E]) >>> 0),
(m[E] = (w % 256) >>> 0),
(w = (w / 256) >>> 0));
if (w !== 0) throw new Error("Non-zero carry");
((y = I), u++);
}
let v = b - y;
for (; v !== b && m[v] === 0; ) v++;
let h = new Uint8Array(p + (b - v)),
g = p;
for (; v !== b; ) h[g++] = m[v++];
return h;
}
function d(l) {
let u = c(l);
if (u) return u;
throw new Error("Non-base" + r + " character");
}
return { encode: i, decodeUnsafe: c, decode: d };
}
var yx = LE;
var qE = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
gx = yx(qE);
var Ff = (
e,
t,
{
version: r = "ics27-1",
encoding: o = "proto3",
ordering: n = "ordered",
txType: a = "sdk_multi_msg",
} = {},
) => {
(e || f`hostConnectionId is required`,
t || f`controllerConnectionId is required`);
let i = JSON.stringify({
version: r,
controllerConnectionId: t,
hostConnectionId: e,
address: "",
encoding: o,
txType: a,
});
return Dl([t], "icahost", n, i);
};
harden(Ff);
var Kf = "icq-1",
Jf = (e, t = Kf) => (
e || f`controllerConnectionId is required`,
Dl([e], "icqhost", "unordered", t)
);
harden(Jf);
var Vf = (e) => {
try {
let t = e?.match(/{.*?}/)?.[0],
r = t ? JSON.parse(t) : void 0;
return r?.address?.length ? r.address : void 0;
} catch {
return;
}
};
harden(Vf);
var hx = (e) => {
assert(e, "address is required");
let t = e.lastIndexOf("1");
return t === -1
? f`No separator character for ${x(e)}`
: t === 0
? f`Missing prefix for ${x(e)}`
: e.slice(0, t);
},
qe = (e, t) => e.toLowerCase() === t?.toLowerCase();
harden(qe);
var Dt = (e) =>
typeof e == "string" ? e : `cosmos:${e.chainId}:${e.value}`;
harden(Dt);
var Oc = (e) =>
typeof e == "string"
? jr(e)
: {
namespace: "cosmos",
reference: e.chainId,
accountAddress: e.value,
};
harden(Oc);
var jr = (e) => {
let t = e.split(":");
t.length === 3 || f`malformed CAIP-10 accountId: ${x(e)}`;
let [r, o, n] = t;
return { namespace: r, reference: o, accountAddress: n };
};
harden(jr);
var Hf = (e) => {
let { namespace: t, reference: r } = Oc(e);
return `${t}:${r}`;
},
bx = (e) => {
if (typeof e != "string") return !1;
try {
let t = (0, Wl.fromBech32)(e);
return !!t && t.data.length > 0;
} catch {
return !1;
}
};
harden(bx);
function jE(e) {
bx(e) || f`Expected a valid Bech32 address, got ${x(e)}`;
}
harden(jE);
var Ll = (e) => {
let t = e.replace(/^0x/, ""),
r = 64 - t.length,
o = "0".repeat(r) + t;
return (0, Wl.fromHex)(o);
},
GE = (e) => gx.decode(e),
Wf = (e) => {
let { namespace: t, accountAddress: r } = jr(e);
switch (t) {
case "eip155":
return Ll(r);
case "solana":
return GE(r);
default:
throw new Error(`namespace ${t} not supported`);
}
};
var Lf = () => {};
harden(Lf);
var le = s.tagged("Vow", s.splitRecord({ vowV0: s.remotable("VowV0") })),
cr = (e) => or(e) && Ve(e, le);
harden(cr);
var $n = (e) => (cr(e) ? e.payload : void 0);
harden($n);
var ht = (e) => {
let t = $n(e);
if (t === void 0) return e;
let { vowV0: r } = t;
return r;
};
harden(ht);
var Ec = (e) => {
let t = (r) => {
let o;
try {
o = r();
} catch (i) {
o = Promise.reject(i);
}
if (cr(o)) return o;
let { vow: n, resolver: a } = e();
return (a.resolve(o), n);
};
return harden(t);
};
harden(Ec);
var { details: vx } = assert,
Sx = () => {};
harden(Sx);
var qf = (e, t) => {
let r = new WeakMap(),
o = new WeakMap(),
n = (d, l) => {
let u = r.get(d);
return (
u || ((u = xt()), u.promise.catch(Sx)),
(u = harden({ ...u, ...l })),
r.set(d, u),
u
);
},
a = (d) => {
let l = n(d);
if (l.resolve) {
let { resolve: u, reject: p, ...y } = l;
r.set(d, harden(y));
}
return l;
},
i = e.exoClassKit(
"VowInternalsKit",
{
vowV0: s.interface("VowV0", {
shorten: s.call().returns(s.promise()),
}),
resolver: s.interface("VowResolver", {
resolve: s.call().optional(s.raw()).returns(),
reject: s.call().optional(s.raw()).returns(),
}),
watchNextStep: Po,
},
() => ({
value: void 0,
stepStatus: null,
isStoredValue: !1,
vowIsHandled: !1,
extra: void 0,
}),
{
vowV0: {
async shorten() {
let {
stepStatus: d,
isStoredValue: l,
value: u,
vowIsHandled: p,
} = this.state,
{ resolver: y, vowV0: b } = this.facets;
switch (d) {
case "fulfilled": {
if ((p === !1 && (this.state.vowIsHandled = !0), l))
return u;
if (o.has(y)) return o.get(y);
throw u;
}
case "rejected":
throw (
p === !1 &&
((this.state.vowIsHandled = !0), t?.handle(b)),
o.has(y) ? o.get(y) : u
);
case null:
case "pending":
return n(this.facets.resolver, { potentiallyHandled: !0 })
.promise;
default:
throw TypeError(`unexpected stepStatus ${d}`);
}
},
},
resolver: {
resolve(d) {
let { stepStatus: l } = this.state;
if (l !== null) return;
this.state.stepStatus = "pending";
let { resolver: u } = this.facets,
{ resolve: p } = a(u);
(p && p(d),
e.watchPromise(
HandledPromise.resolve(d),
this.facets.watchNextStep,
));
},
reject(d) {
let { stepStatus: l } = this.state;
if (l !== null) return;
this.state.stepStatus = "rejected";
let { resolver: u, watchNextStep: p } = this.facets,
{ reject: y } = a(u);
(y && y(d), p.onRejected(d));
},
},
watchNextStep: {
onFulfilled(d) {
this.state.stepStatus = "fulfilled";
let { resolver: l } = this.facets,
{ resolve: u } = a(l);
(harden(d),
u && u(d),
(this.state.isStoredValue = e.isStorable(d)),
this.state.isStoredValue
? (this.state.value = d)
: (o.set(l, d),
(this.state.value = assert.error(
vx`Vow fulfillment value was not stored: ${d}`,
))));
},
onRejected(d) {
this.state.stepStatus = "rejected";
let { resolver: l, vowV0: u } = this.facets,
{ reject: p, potentiallyHandled: y } = a(l);
(harden(d),
p && p(d),
this.state.vowIsHandled === !1 &&
(y ? (this.state.vowIsHandled = !0) : t?.reject(u, d)),
(this.state.isStoredValue = e.isStorable(d)),
this.state.isStoredValue
? (this.state.value = d)
: (o.set(l, d),
(this.state.value = assert.error(
vx`Vow rejection reason was not stored: ${d}`,
))));
},
},
},
);
return () => {
let { resolver: d, vowV0: l } = i(),
u = Ce("Vow", harden({ vowV0: l }));
return harden({ resolver: d, vow: u });
};
};
harden(qf);
var { Fail: QE, bare: zE, details: YE } = assert,
jf = s.tagged("Vow", harden({ vowV0: s.remotable("VowV0") })),
Gf = (e, { watch: t, when: r, makeVowKit: o, isRetryableReason: n }) => {
let a = e.detached(),
i = new WeakMap(),
c = e.exoClassKit(
"WatchUtils",
{
utils: s.interface("Utils", {
all: s.call(s.arrayOf(s.any())).returns(jf),
allSettled: s.call(s.arrayOf(s.any())).returns(jf),
asPromise: s.call(s.raw()).rest(s.raw()).returns(s.promise()),
}),
watcher: s.interface("Watcher", {
onFulfilled: s.call(s.raw()).rest(s.raw()).returns(s.raw()),
onRejected: s.call(s.raw()).rest(s.raw()).returns(s.raw()),
}),
helper: s.interface("Helper", {
createVow: s.call(s.arrayOf(s.any()), s.boolean()).returns(jf),
processResult: s
.call(s.raw())
.rest(s.raw())
.returns(s.undefined()),
}),
retryRejectionPromiseWatcher: Po,
},
() => ({ nextId: 0n, idToVowState: a.mapStore("idToVowState") }),
{
utils: {
all(l) {
return this.facets.helper.createVow(l, !1);
},
allSettled(l) {
return this.facets.helper.createVow(l, !0);
},
asPromise(l, ...u) {
let p = t(l, ...u),
y = r(p);
return (
e.watchPromise(y, this.facets.retryRejectionPromiseWatcher),
y
);
},
},
watcher: {
onFulfilled(l, u) {
this.facets.helper.processResult(l, u, "fulfilled");
},
onRejected(l, u) {
this.facets.helper.processResult(l, u, "rejected");
},
},
helper: {
createVow(l, u) {
let { nextId: p, idToVowState: y } = this.state,
b = o();
for (let m = 0; m < l.length; m += 1)
t(l[m], this.facets.watcher, {
id: p,
index: m,
numResults: l.length,
isAllSettled: u,
});
return (
l.length > 0
? ((this.state.nextId += 1n),
y.init(
p,
harden({
resolver: b.resolver,
remaining: l.length,
resultsMap: a.mapStore("resultsMap"),
isAllSettled: u,
}),
),
To(i, this.facets.utils, () => new Map()).set(
p,
new Map(),
))
: b.resolver.resolve(harden([])),
b.vow
);
},
processResult(
l,
{ id: u, index: p, numResults: y, isAllSettled: b },
m,
) {
let { idToVowState: v } = this.state;
if (!v.has(u)) return;
let h = To(i, this.facets.utils, () => new Map()),
{ remaining: g, resultsMap: S, resolver: w } = v.get(u);
if (!b && m === "rejected") {
(v.delete(u), h.delete(u), w.reject(l));
return;
}
let I = b
? harden({
status: m,
[m === "fulfilled" ? "value" : "reason"]: l,
})
: l,
E = To(h, u, () => new Map());
e.isStorable(I) ? S.init(p, I) : E.set(p, I);
let K = harden({
remaining: g - 1,
resultsMap: S,
resolver: w,
isAllSettled: b,
});
if (K.remaining > 0) {
v.set(u, K);
return;
}
(v.delete(u), h.delete(u));
let J = new Array(y),
P = 0;
for (let k = 0; k < y; k += 1)
E.has(k)
? (J[k] = E.get(k))
: S.has(k)
? (J[k] = S.get(k))
: ((P += 1),
(J[k] = b
? {
status: "rejected",
reason: "Unstorable result was lost",
}
: void 0));
P > 0 && !b
? w.reject(
assert.error(YE`${P} unstorable results were lost`),
)
: w.resolve(harden(J));
},
},
retryRejectionPromiseWatcher: {
onFulfilled(l) {},
onRejected(l, u) {
n(l, void 0) && QE`Pending ${zE(u)} could not retry; ${l}`;
},
},
},
);
return () => {
let { utils: l } = c();
return harden(l);
};
};
harden(Gf);
var { apply: ZE } = Reflect,
XE = (e) => (t, r) => {
let o,
n = $n(t);
(n ? (o = O(n.vowV0).shorten()) : (o = O.resolve(t)),
e.watchPromise(o, r));
},
xx = async (e, t, r, o, n = []) => {
await null;
try {
let a = o,
i = t && t[r];
if (i) a = ZE(i, t, [o, ...n]);
else if (r === "onRejected") throw o;
if (e) {
e.resolve(a);
return;
}
await a;
} catch (a) {
if (e) {
e.reject(a);
return;
}
throw a;
}
},
e6 = (e, t, r) => {
let o = new WeakMap(),
n = (a) => {
let i = o.get(a);
return (i || ((i = new WeakSet()), o.set(a, i)), i);
};
return e.exoClass(
"PromiseWatcher",
Po,
(a, i, c) => ({
vow: void 0,
priorRetryValue: void 0,
resolver: a,
watcher: i,
watcherArgs: harden(c),
}),
{
onFulfilled(a) {
let { watcher: i, watcherArgs: c, resolver: d } = this.state;
if (!d)
throw Error("Unexpected multiple calls to PromiseWatcher");
let l = $n(a);
if (l) {
let u = n(this.self);
if (u.has(l.vowV0))
return this.self.onRejected(
Error("Vow resolution cycle detected"),
);
(u.add(l.vowV0), (this.state.vow = a), r(a, this.self));
return;
}
(o.delete(this.self),
(this.state.priorRetryValue = void 0),
(this.state.watcher = void 0),
(this.state.resolver = void 0),
xx(d, i, "onFulfilled", a, c));
},
onRejected(a) {
let {
vow: i,
watcher: c,
watcherArgs: d,
resolver: l,
priorRetryValue: u,
} = this.state;
if (!l)
throw Error("Unexpected multiple calls to PromiseWatcher");
let p = t(a, u);
if (p && ((this.state.priorRetryValue = p), i)) {
r(i, this.self);
return;
}
(o.delete(this.self),
(this.state.priorRetryValue = void 0),
(this.state.resolver = void 0),
(this.state.watcher = void 0),
xx(l, c, "onRejected", a, d));
},
},
);
},
Qf = (e, t, r = (o, n) => {}) => {
let o = XE(e),
n = e6(e, r, o),
a = (i, c, ...d) => {
let { resolver: l, vow: u } = t(),
p = n(l, c, d),
y = O.resolve(i);
return (e.watchPromise(y, p), u);
};
return (harden(a), a);
};
harden(Qf);
var t6 = (e, t) => () => {
(e?.catch(Lf), t?.resolve());
},
Ax = (e) => {
let t = new WeakMap(),
r = e.exo(
"UpgradeRejectionWatcher",
s.interface("UpgradeRejectionWatcher", {
onRejected: s.call(s.raw(), s.raw()).returns(),
}),
{
onRejected(n, a) {
throw assert.error(
V`VOW_REJECTION ${a} not handled before upgrade ${n}`,
);
},
},
);
return e.exo(
"VowRejectionTracker",
s.interface("VowRejectionTracker", {
handle: s.call(s.remotable()).returns(),
reject: s.call(s.remotable(), s.raw()).returns(),
}),
{
handle(n) {
let a = t.get(n);
if (!a) {
console.warn(
assert.error(
V`Now handling a VOW_REJECTION from a prior incarnation for ${n}`,
),
);
return;
}
(t.delete(n), a());
},
reject(n, a) {
if (t.has(n)) return;
harden(a);
let i = e.isStorable(a)
? a
: assert.error(V`Vow rejection reason was not stored: ${a}`),
c = xt();
e.watchPromise(c.promise, r, i);
let d = Promise.reject(a),
l = t6(d, c);
t.set(n, l);
},
},
);
};
var { defineProperties: r6 } = Object,
o6 = harden({
flow: s.interface("Flow", {
restart: s.call().returns(),
getOutcome: s.call().returns(le),
}),
resultWatcher: Po,
}),
n6 = s.interface("RetryableFlowAdmin", {
getFlowForOutcomeVow: s.call(le).returns(s.opt(s.remotable("flow"))),
}),
zf = (e, t) => {
let { makeVowKit: r, isRetryableReason: o } = t,
n = Ec(r),
a = e.mapStore("retryableFlowForOutcomeVow", {
keyShape: s.remotable("toPassableCap"),
valueShape: s.remotable("flow"),
}),
i = (l, u, p) => {
typeof p == "function" ||
f`retryableFunc must be a callable function ${p}`;
let y = l.exoClassKit(
u,
o6,
(m) => (
harden(m),
{
activationArgs: m,
outcomeKit: r(),
lastRetryReason: void 0,
runs: 0n,
isDone: !1,
}
),
{
flow: {
restart() {
let { state: m, facets: v } = this,
{ activationArgs: h, isDone: g } = m,
{ flow: S, resultWatcher: w } = v;
!g || f`Cannot restart a done retryable flow ${S}`;
let I = m.runs + 1n;
m.runs = I;
let E;
try {
E = Promise.resolve(p(...h));
} catch (K) {
E = Promise.reject(K);
}
e.watchPromise(harden(E), w, I);
},
getOutcome() {
let { state: m } = this,
{ outcomeKit: v } = m;
return v.vow;
},
},
resultWatcher: {
onFulfilled(m, v) {
let { state: h } = this,
{ runs: g, outcomeKit: S } = h;
v === g &&
(!h.isDone ||
f`Cannot resolve a done retryable flow ${this.facets.flow}`,
S.resolver.resolve(m),
a.delete(ht(S.vow)),
(h.isDone = !0));
},
onRejected(m, v) {
let { state: h } = this,
{ runs: g, outcomeKit: S } = h;
if (v !== g) return;
!h.isDone ||
f`Cannot reject a done retryable flow ${this.facets.flow}`;
let w = o(m, h.lastRetryReason);
w
? ((h.lastRetryReason = w), this.facets.flow.restart())
: (S.resolver.reject(m),
a.delete(ht(S.vow)),
(h.isDone = !0));
},
},
},
),
b = (m) => {
let v = y(m),
{ flow: h } = v,
g = h.getOutcome();
return (a.init(ht(g), h), h.restart(), v);
};
return harden(b);
},
c = (l, u, p) => {
let y = i(l, u, p),
b = `${u}_retryable`,
m = {
[b](...v) {
return n(() => {
l.isStorable(harden(v)) ||
f`retryable arguments must be storable ${v}`;
let { flow: h } = y(v);
return h.getOutcome();
});
},
}[b];
return (r6(m, { length: { value: p.length } }), harden(m));
},
d = e.exo("AdminRetryableFlow", n6, {
getFlowForOutcomeVow(l) {
return a.get(ht(l));
},
});
return harden({
prepareRetryableFlowKit: i,
adminRetryableFlow: d,
retryable: c,
});
};
harden(zf);
var Yf = (e = () => !1) => {
let t = async (o) => {
await null;
let n = await o,
a = $n(n),
i,
c = new WeakSet();
for (; a; ) {
let { vowV0: l } = a;
if (c.has(l)) throw Error("Vow resolution cycle detected");
try {
let u = await O(l).shorten();
(c.add(l), (i = void 0), (n = u));
} catch (u) {
let p = e(u, i);
if (!p) throw u;
i = p;
}
a = $n(n);
}
return n;
},
r = (o, n, a) => {
let i = t(o);
return n == null && a == null ? i : O.resolve(i).then(n, a);
};
return (harden(r), r);
};
harden(Yf);
var Zf = (e, t = {}) => {
let { isRetryableReason: r = () => !1 } = t,
o = Ax(e),
n = qf(e, o),
a = Yf(r),
i = Qf(e, n, r),
d = Gf(e, { watch: i, when: a, makeVowKit: n, isRetryableReason: r })(),
l = Ec(n),
{ retryable: u } = zf(e, { makeVowKit: n, isRetryableReason: r }),
p = (v) => d.all(v),
y = p,
b = (v) => d.allSettled(v),
m = (v, ...h) => d.asPromise(v, ...h);
return harden({
when: a,
watch: i,
makeVowKit: n,
all: p,
allVows: y,
allSettled: b,
asVow: l,
asPromise: m,
retryable: u,
retriable: u,
});
};
harden(Zf);
var za,
ql = 0,
Dc = 0,
wx = Pa("DEBUG", "track-turns"),
s6 = hr("TRACK_TURNS", "disabled", ["enabled"]) === "enabled",
a6 = (e) => (t) => {
(t instanceof Error && Ze(t, e),
wx && console.log("REJECTED at top of event loop", t));
},
i6 =
(e, t) =>
(...r) => {
((za = t), (ql += 1), (Dc = 0));
try {
let o;
try {
o = e(...r);
} catch (a) {
throw (
a instanceof Error && Ze(a, V`Thrown from: ${za}:${ql}.${Dc}`),
wx && console.log("THROWN to top of event loop", a),
a
);
}
let n = V`Rejection from: ${za}:${ql}.${Dc}`;
return (Promise.resolve(o).catch(a6(n)), o);
} finally {
za = void 0;
}
},
Px = (e) => {
if (!s6 || typeof globalThis > "u" || !globalThis.assert) return e;
Dc += 1;
let t = Error(`Event: ${ql}.${Dc}`);
return (
za !== void 0 && Ze(t, V`Caused by: ${za}`),
e.map((r) => r && i6(r, t))
);
};
var { hasOwn: c6, freeze: Nc, entries: kx } = Object,
Ix = (e) => typeof e == "object" && e !== null && !Array.isArray(e),
Xf = (e) => {
for (let t of ["Alleged: ", "DebugName: "])
if (e.startsWith(t)) return e.slice(t.length);
return e;
},
ey = (e) => {
let t = JSON.parse(hr(e, "null"));
if (t === null) return;
let r,
o = () => t;
Nc(o);
let n = (c = t) => {
Ix(c) || f`Expected ${x(e)} option to be a JSON breakpoints record`;
let d = { __proto__: null };
for (let [l, u] of kx(c)) {
(l === Xf(l) ||
f`Just use simple tag ${x(Xf(l))} rather than ${x(l)}`,
Ix(u) ||
f`Expected ${x(e)} option's ${x(l)} to be a JSON methods breakpoints record`);
for (let [p, y] of kx(u)) {
y === "*" ||
(typeof y == "number" && Number.isSafeInteger(y) && y >= 0) ||
f`Expected ${x(e)} option's ${x(l)}.${x(p)} to be "*" or a non-negative integer`;
let b = c6(d, p) ? d[p] : (d[p] = { __proto__: null });
b[l] = y;
}
}
((t = c), (r = d));
};
Nc(n);
let a = (c, d) => {
if (d == null) return !1;
let l = r[d] || r["*"];
if (l === void 0) return !1;
let u = Xf(c[Symbol.toStringTag]),
p = l[u];
return p === void 0 && ((u = "*"), (p = l[u]), p === void 0)
? !1
: p === "*" || p === 0
? !0
: (assert(typeof p == "number" && p >= 1), (l[u] = p - 1), !1);
};
Nc(a);
let i = Nc({
getBreakpoints: o,
setBreakpoints: n,
shouldBreakpoint: a,
});
return (i.setBreakpoints(), i);
};
Nc(ey);
var { assign: d6, create: l6 } = Object,
_n = ey("ENDO_SEND_BREAKPOINTS"),
ry = {
set(e, t, r) {
return !1;
},
isExtensible(e) {
return !1;
},
setPrototypeOf(e, t) {
return !1;
},
deleteProperty(e, t) {
return !1;
},
},
u6 = (e, t, r) =>
harden({
...ry,
get: (o, n, a) =>
harden(
{
[n](...i) {
if (this !== a)
return t.reject(
Se(
V`Unexpected receiver for "${x(n)}" method of E(${x(e)})`,
),
);
if (_n && _n.shouldBreakpoint(e, n)) debugger;
return r(t.applyMethod(r(e), n, i));
},
}[n],
),
apply: (o, n, a = []) => {
if (_n && _n.shouldBreakpoint(e, void 0)) debugger;
return r(t.applyFunction(r(e), a));
},
has: (o, n) => !0,
}),
p6 = (e, t, r) =>
harden({
...ry,
get: (o, n, a) =>
harden(
{
[n](...i) {
if (
(this === a ||
f`Unexpected receiver for "${x(n)}" method of E.sendOnly(${x(e)})`,
_n && _n.shouldBreakpoint(e, n))
)
debugger;
t.applyMethodSendOnly(r(e), n, i);
},
}[n],
),
apply: (o, n, a = []) => {
if (_n && _n.shouldBreakpoint(e, void 0)) debugger;
t.applyFunctionSendOnly(r(e), a);
},
has: (o, n) => !0,
}),
m6 = (e, t, r) =>
harden({ ...ry, has: (o, n) => !0, get: (o, n) => t.get(r(e), n) }),
ty = (e) => HandledPromise.resolve(e),
f6 = (e, t = {}) => {
let { additional: r = {}, unwrap: o = ty } = t;
return harden(
d6(
(n) => harden(new Proxy(() => {}, u6(n, e, o))),
{
get: (n) => harden(new Proxy(l6(null), m6(n, e, o))),
resolve: (n) => ty(o(n)),
sendOnly: (n) => harden(new Proxy(() => {}, p6(n, e, o))),
when: (n, a, i) => {
let c = ty(o(n));
return a == null && i == null ? c : c.then(...Px([a, i]));
},
},
r,
),
);
},
oy = f6;
var y6 = (e, t) => {
if (
(Bn(e) && (!Bn(t) || e.incarnationNumber > t.incarnationNumber)) ||
(kl(e) && !kl(t))
)
return e;
},
g6 = harden({ isRetryableReason: y6 }),
Fn = (e, t = {}) => Zf(e, { ...g6, ...t });
harden(Fn);
var Tx = Fn(Yo()),
Kn = oy(globalThis.HandledPromise, {
unwrap: Tx.when,
additional: { when: Tx.when },
});
var Gl = s.interface("OutboundConnectionHandler", {
onOpen: s
.callWhen(s.any(), s.string(), s.string(), s.any())
.returns(s.any()),
onClose: s.callWhen(s.any(), s.any(), s.any()).returns(s.any()),
}),
je = { chainId: s.string(), encoding: s.string(), value: s.string() };
harden(je);
var h6 = {
namespace: s.string(),
reference: s.string(),
accountAddress: s.string(),
};
harden(h6);
var Ya = s.or(s.string(), je),
ks = { typeUrl: s.string(), value: s.string() };
harden(ks);
var jl = s.string(),
b6 = s.splitRecord({
portId: s.string(),
channelId: jl,
counterPartyPortId: s.string(),
counterPartyChannelId: jl,
ordering: s.scalar(),
state: s.scalar(),
version: s.string(),
}),
Ux = s.string(),
Ql = s.splitRecord({
id: Ux,
client_id: s.string(),
state: s.scalar(),
counterparty: { client_id: s.string(), connection_id: Ux },
transferChannel: b6,
}),
Sj = s.splitRecord({
base: s.string(),
name: s.string(),
display: s.string(),
symbol: s.string(),
denom_units: s.arrayOf(
s.splitRecord({ denom: s.string(), exponent: s.number() }),
),
}),
Cx = { namespace: s.string(), reference: s.string() },
Rx = { cctpDestinationDomain: s.number() },
Ox = s.splitRecord(Cx, Rx);
harden(Ox);
var Ex = s.splitRecord(
{ chainId: s.string(), bech32Prefix: s.string(), ...Cx },
{
connections: s.record(),
icqEnabled: s.boolean(),
pfmEnabled: s.boolean(),
stakingTokens: s.arrayOf({ denom: s.string() }),
...Rx,
},
);
harden(Ex);
var Oo = s.or(Ex, Ox);
harden(Oo);
var Za = s.string(),
Bc = { amount: s.string(), denom: Za };
harden(Bc);
var sy = {
chain: s.remotable("Chain"),
base: s.remotable("Chain"),
brand: s.or(s.remotable("Brand"), s.undefined()),
baseDenom: s.string(),
};
harden(sy);
var Zo = s.splitRecord(
{ chainName: s.string(), baseName: s.string(), baseDenom: s.string() },
{ brand: ot },
);
harden(Zo);
var bt = { denom: Za, value: s.nat() };
harden(bt);
var Ut = { brand: s.remotable("Brand"), value: s.nat() };
harden(Ut);
var Jt = s.or(Ut, bt),
ay = s.splitRecord({ validator: je, amount: Jt }, { delegator: je }),
Mc = s.splitRecord(
{ path: s.string(), data: s.string() },
{ height: s.string(), prove: s.boolean() },
),
$c = s.splitRecord({ "@type": s.string() }),
Dx = s.splitRecord(
{},
{ progressTracker: s.remotable("ProgressTracker") },
),
Nx = s.and(Dx, s.splitRecord({}, { sendOpts: Ef })),
_c = {
getChainInfo: s.call().returns(le),
makeAccount: s.call().optional(Dx).returns(le),
};
harden(_c);
var iy = { seconds: s.string(), nanos: s.number() };
harden(iy);
var Bx = s.splitRecord(
{},
{
memo: s.string(),
timeoutHeight: s.bigint(),
extensionOptions: s.arrayOf(s.any()),
nonCriticalExtensionOptions: s.arrayOf(s.any()),
},
),
Gr = s.and(Nx, s.splitRecord({}, { txOpts: Bx })),
zl = s.and(Gr, Bx),
v6 = s.splitRecord({}, { height: s.bigint(), prove: s.boolean() }),
Jn = s.and(Nx, s.splitRecord({}, { queryOpts: v6 }));
var cy = s.and(s.recordOf(s.string(), Ut), s.not({})),
dy = {
agoricNames: s.remotable("AgoricNames"),
localchain: s.remotable("Localchain"),
orchestrationService: s.remotable("OrchestrationService"),
storageNode: s.remotable("StorageNode"),
timerService: s.remotable("TimerService"),
};
harden(dy);
var ny = {
receiver: s.string(),
port: "transfer",
channel: s.string(),
timeout: s.string(),
retries: s.number(),
};
harden(ny);
var ly = { forward: s.splitRecord(ny, { next: { forward: ny } }) };
harden(ly);
var uy = s.splitRecord(
{},
{ timeout: s.string(), retries: s.number(), intermediateRecipient: je },
{},
),
Xo = s.and(
s.splitRecord(
{},
{
timeoutTimestamp: s.bigint(),
timeoutHeight: {
revisionHeight: s.bigint(),
revisionNumber: s.bigint(),
},
timeoutRelativeSeconds: s.bigint(),
memo: s.string(),
forwardOpts: uy,
},
),
Gr,
);
function Mx(e) {
let t = 0,
r = 0;
for (let o = 0; o < e.length; ++o)
((r = e.charCodeAt(o)),
r < 128
? (t += 1)
: r < 2048
? (t += 2)
: (r & 64512) === 55296 && (e.charCodeAt(o + 1) & 64512) === 56320
? (++o, (t += 4))
: (t += 3));
return t;
}
function $x(e, t, r) {
if (r - t < 1) return "";
let o = [],
n = [],
a = 0,
i;
for (; t < r; )
((i = e[t++]),
i < 128
? (o[a++] = i)
: i > 191 && i < 224
? (o[a++] = ((i & 31) << 6) | (e[t++] & 63))
: i > 239 && i < 365
? ((i =
(((i & 7) << 18) |
((e[t++] & 63) << 12) |
((e[t++] & 63) << 6) |
(e[t++] & 63)) -
65536),
(o[a++] = 55296 + (i >> 10)),
(o[a++] = 56320 + (i & 1023)))
: (o[a++] =
((i & 15) << 12) | ((e[t++] & 63) << 6) | (e[t++] & 63)),
a > 8191 &&
((n || (n = [])).push(String.fromCharCode(...o)), (a = 0)));
return n
? (a && n.push(String.fromCharCode(...o.slice(0, a))), n.join(""))
: String.fromCharCode(...o.slice(0, a));
}
function _x(e, t, r) {
let o = r,
n,
a;
for (let i = 0; i < e.length; ++i)
((n = e.charCodeAt(i)),
n < 128
? (t[r++] = n)
: n < 2048
? ((t[r++] = (n >> 6) | 192), (t[r++] = (n & 63) | 128))
: (n & 64512) === 55296 &&
((a = e.charCodeAt(i + 1)) & 64512) === 56320
? ((n = 65536 + ((n & 1023) << 10) + (a & 1023)),
++i,
(t[r++] = (n >> 18) | 240),
(t[r++] = ((n >> 12) & 63) | 128),
(t[r++] = ((n >> 6) & 63) | 128),
(t[r++] = (n & 63) | 128))
: ((t[r++] = (n >> 12) | 224),
(t[r++] = ((n >> 6) & 63) | 128),
(t[r++] = (n & 63) | 128)));
return r - o;
}
function Fc() {
let e = 0,
t = 0;
for (let o = 0; o < 28; o += 7) {
let n = this.buf[this.pos++];
if (((e |= (n & 127) << o), (n & 128) == 0))
return (this.assertBounds(), [e, t]);
}
let r = this.buf[this.pos++];
if (((e |= (r & 15) << 28), (t = (r & 112) >> 4), (r & 128) == 0))
return (this.assertBounds(), [e, t]);
for (let o = 3; o <= 31; o += 7) {
let n = this.buf[this.pos++];
if (((t |= (n & 127) << o), (n & 128) == 0))
return (this.assertBounds(), [e, t]);
}
throw new Error("invalid varint");
}
var Yl = 4294967296;
function Kc(e) {
let t = e[0] === "-";
t && (e = e.slice(1));
let r = 1e6,
o = 0,
n = 0;
function a(i, c) {
let d = Number(e.slice(i, c));
((n *= r),
(o = o * r + d),
o >= Yl && ((n = n + ((o / Yl) | 0)), (o = o % Yl)));
}
return (
a(-24, -18),
a(-18, -12),
a(-12, -6),
a(-6),
t ? Kx(o, n) : py(o, n)
);
}
function Zl(e, t) {
let r = py(e, t),
o = r.hi & 2147483648;
o && (r = Kx(r.lo, r.hi));
let n = Xl(r.lo, r.hi);
return o ? "-" + n : n;
}
function Xl(e, t) {
if ((({ lo: e, hi: t } = S6(e, t)), t <= 2097151))
return String(Yl * t + e);
let r = e & 16777215,
o = ((e >>> 24) | (t << 8)) & 16777215,
n = (t >> 16) & 65535,
a = r + o * 6777216 + n * 6710656,
i = o + n * 8147497,
c = n * 2,
d = 1e7;
return (
a >= d && ((i += Math.floor(a / d)), (a %= d)),
i >= d && ((c += Math.floor(i / d)), (i %= d)),
c.toString() + Fx(i) + Fx(a)
);
}
function S6(e, t) {
return { lo: e >>> 0, hi: t >>> 0 };
}
function py(e, t) {
return { lo: e | 0, hi: t | 0 };
}
function Kx(e, t) {
return ((t = ~t), e ? (e = ~e + 1) : (t += 1), py(e, t));
}
var Fx = (e) => {
let t = String(e);
return "0000000".slice(t.length) + t;
};
function Jx() {
let e = this.buf[this.pos++],
t = e & 127;
if ((e & 128) == 0) return (this.assertBounds(), t);
if (((e = this.buf[this.pos++]), (t |= (e & 127) << 7), (e & 128) == 0))
return (this.assertBounds(), t);
if (((e = this.buf[this.pos++]), (t |= (e & 127) << 14), (e & 128) == 0))
return (this.assertBounds(), t);
if (((e = this.buf[this.pos++]), (t |= (e & 127) << 21), (e & 128) == 0))
return (this.assertBounds(), t);
((e = this.buf[this.pos++]), (t |= (e & 15) << 28));
for (let r = 5; (e & 128) !== 0 && r < 10; r++) e = this.buf[this.pos++];
if ((e & 128) != 0) throw new Error("invalid varint");
return (this.assertBounds(), t >>> 0);
}
function Vx(e, t) {
let r = t >> 31;
return (
(t = (((t << 1) | (e >>> 31)) ^ r) >>> 0),
(e = ((e << 1) ^ r) >>> 0),
[e, t]
);
}
function Hx(e, t) {
let r = -(e & 1);
return (
(e = (((e >>> 1) | (t << 31)) ^ r) >>> 0),
(t = ((t >>> 1) ^ r) >>> 0),
[e, t]
);
}
function Wx(e, t) {
return (e[t] | (e[t + 1] << 8) | (e[t + 2] << 16)) + e[t + 3] * 16777216;
}
function Lx(e, t) {
return (e[t] | (e[t + 1] << 8) | (e[t + 2] << 16)) + (e[t + 3] << 24);
}
function qx(e, t, r) {
for (; e > 127; ) ((t[r++] = (e & 127) | 128), (e >>>= 7));
t[r] = e;
}
function eu(e, t, r) {
for (; e.hi; )
((t[r++] = (e.lo & 127) | 128),
(e.lo = ((e.lo >>> 7) | (e.hi << 25)) >>> 0),
(e.hi >>>= 7));
for (; e.lo > 127; ) ((t[r++] = (e.lo & 127) | 128), (e.lo = e.lo >>> 7));
t[r++] = e.lo;
}
function my(e, t) {
let r = e,
o = ((e >>> 28) | (t << 4)) >>> 0,
n = t >>> 24;
return n === 0
? o === 0
? r < 16384
? r < 128
? 1
: 2
: r < 2097152
? 3
: 4
: o < 16384
? o < 128
? 5
: 6
: o < 2097152
? 7
: 8
: n < 128
? 9
: 10;
}
function tu(e, t, r) {
((t[r] = e & 255),
(t[r + 1] = (e >>> 8) & 255),
(t[r + 2] = (e >>> 16) & 255),
(t[r + 3] = e >>> 24));
}
function ru(e, t, r) {
t[r] = e & 255;
}
var x6 = ((e) => (
(e[(e.Varint = 0)] = "Varint"),
(e[(e.Fixed64 = 1)] = "Fixed64"),
(e[(e.Bytes = 2)] = "Bytes"),
(e[(e.Fixed32 = 5)] = "Fixed32"),
e
))(x6 || {}),
$ = class {
buf;
pos;
type;
len;
assertBounds() {
if (this.pos > this.len) throw new RangeError("premature EOF");
}
constructor(t) {
((this.buf = t ? new Uint8Array(t) : new Uint8Array(0)),
(this.pos = 0),
(this.type = 0),
(this.len = this.buf.length));
}
tag() {
let t = this.uint32(),
r = t >>> 3,
o = t & 7;
if (r <= 0 || o < 0 || o > 5)
throw new Error("illegal tag: field no " + r + " wire type " + o);
return [r, o, t];
}
skip(t) {
if (typeof t == "number") {
if (this.pos + t > this.len) throw jx(this, t);
this.pos += t;
} else
do if (this.pos >= this.len) throw jx(this);
while (this.buf[this.pos++] & 128);
return this;
}
skipType(t) {
switch (t) {
case 0:
this.skip();
break;
case 1:
this.skip(8);
break;
case 2:
this.skip(this.uint32());
break;
case 3:
for (; (t = this.uint32() & 7) !== 4; ) this.skipType(t);
break;
case 5:
this.skip(4);
break;
default:
throw Error("invalid wire type " + t + " at offset " + this.pos);
}
return this;
}
uint32() {
return Jx.bind(this)();
}
int32() {
return this.uint32() | 0;
}
sint32() {
let t = this.uint32();
return t % 2 === 1 ? (t + 1) / -2 : t / 2;
}
fixed32() {
let t = Wx(this.buf, this.pos);
return ((this.pos += 4), t);
}
sfixed32() {
let t = Lx(this.buf, this.pos);
return ((this.pos += 4), t);
}
int64() {
let [t, r] = Fc.bind(this)();
return BigInt(Zl(t, r));
}
uint64() {
let [t, r] = Fc.bind(this)();
return BigInt(Xl(t, r));
}
sint64() {
let [t, r] = Fc.bind(this)();
return (([t, r] = Hx(t, r)), BigInt(Zl(t, r)));
}
fixed64() {
let t = this.sfixed32(),
r = this.sfixed32();
return BigInt(Xl(t, r));
}
sfixed64() {
let t = this.sfixed32(),
r = this.sfixed32();
return BigInt(Zl(t, r));
}
float() {
throw new Error("float not supported");
}
double() {
throw new Error("double not supported");
}
bool() {
let [t, r] = Fc.bind(this)();
return t !== 0 || r !== 0;
}
bytes() {
let t = this.uint32(),
r = this.pos;
return (
(this.pos += t),
this.assertBounds(),
this.buf.subarray(r, r + t)
);
}
string() {
let t = this.bytes();
return $x(t, 0, t.length);
}
},
Is = class {
fn;
len;
val;
next;
constructor(t, r, o) {
((this.fn = t), (this.len = r), (this.val = o));
}
proceed(t, r) {
this.fn && this.fn(this.val, t, r);
}
},
fy = class {
head;
tail;
len;
next;
constructor(t) {
((this.head = t.head),
(this.tail = t.tail),
(this.len = t.len),
(this.next = t.states));
}
},
re = class e {
len = 0;
head;
tail;
states;
constructor() {
((this.head = new Is(null, 0, 0)),
(this.tail = this.head),
(this.states = null));
}
static create() {
return new e();
}
static alloc(t) {
return typeof Uint8Array < "u"
? w6((r) => new Uint8Array(r), Uint8Array.prototype.subarray)(t)
: new Array(t);
}
_push(t, r, o) {
return (
(this.tail = this.tail.next = new Is(t, r, o)),
(this.len += r),
this
);
}
finish() {
let t = this.head.next,
r = 0,
o = e.alloc(this.len);
for (; t; ) (t.proceed(o, r), (r += t.len), (t = t.next));
return o;
}
fork() {
return (
(this.states = new fy(this)),
(this.head = this.tail = new Is(null, 0, 0)),
(this.len = 0),
this
);
}
reset() {
return (
this.states
? ((this.head = this.states.head),
(this.tail = this.states.tail),
(this.len = this.states.len),
(this.states = this.states.next))
: ((this.head = this.tail = new Is(null, 0, 0)), (this.len = 0)),
this
);
}
ldelim() {
let t = this.head,
r = this.tail,
o = this.len;
return (
this.reset().uint32(o),
o && ((this.tail.next = t.next), (this.tail = r), (this.len += o)),
this
);
}
tag(t, r) {
return this.uint32(((t << 3) | r) >>> 0);
}
uint32(t) {
return (
(this.len += (this.tail = this.tail.next =
new Is(
qx,
(t = t >>> 0) < 128
? 1
: t < 16384
? 2
: t < 2097152
? 3
: t < 268435456
? 4
: 5,
t,
)).len),
this
);
}
int32(t) {
return t < 0 ? this._push(eu, 10, Kc(t.toString())) : this.uint32(t);
}
sint32(t) {
return this.uint32(((t << 1) ^ (t >> 31)) >>> 0);
}
int64(t) {
let { lo: r, hi: o } = Kc(t.toString());
return this._push(eu, my(r, o), { lo: r, hi: o });
}
uint64 = e.prototype.int64;
sint64(t) {
let { lo: r, hi: o } = Kc(t.toString());
return (
([r, o] = Vx(r, o)),
this._push(eu, my(r, o), { lo: r, hi: o })
);
}
fixed64(t) {
let { lo: r, hi: o } = Kc(t.toString());
return this._push(tu, 4, r)._push(tu, 4, o);
}
sfixed64 = e.prototype.fixed64;
bool(t) {
return this._push(ru, 1, t ? 1 : 0);
}
fixed32(t) {
return this._push(tu, 4, t >>> 0);
}
sfixed32 = e.prototype.fixed32;
float(t) {
throw new Error("float not supported" + t);
}
double(t) {
throw new Error("double not supported" + t);
}
bytes(t) {
let r = t.length >>> 0;
return r ? this.uint32(r)._push(A6, r, t) : this._push(ru, 1, 0);
}
string(t) {
let r = Mx(t);
return r ? this.uint32(r)._push(_x, r, t) : this._push(ru, 1, 0);
}
};
function A6(e, t, r) {
if (typeof Uint8Array < "u") t.set(e, r);
else for (let o = 0; o < e.length; ++o) t[r + o] = e[o];
}
function w6(e, t, r) {
let o = r || 8192,
n = o >>> 1,
a = null,
i = o;
return function (c) {
if (c < 1 || c > n) return e(c);
i + c > o && ((a = e(o)), (i = 0));
let d = t.call(a, i, (i += c));
return (i & 7 && (i = (i | 7) + 1), d);
};
}
function jx(e, t) {
return RangeError(
"index out of range: " + e.pos + " + " + (t || 1) + " > " + e.len,
);
}
function B(e) {
return e != null;
}
function Gx(e) {
let t = k6(e.getTime() / 1e3),
r = (e.getTime() % 1e3) * 1e6;
return { seconds: t, nanos: r };
}
function Tr(e) {
let t = Number(e.seconds) * 1e3;
return ((t += e.nanos / 1e6), new Date(t));
}
var P6 = (e) => ({
seconds: B(e.seconds) ? BigInt(e.seconds.toString()) : BigInt(0),
nanos: B(e.nanos) ? Number(e.nanos) : 0,
});
function Ur(e) {
return e instanceof Date
? Gx(e)
: typeof e == "string"
? Gx(new Date(e))
: P6(e);
}
function k6(e) {
return BigInt(Math.trunc(e));
}
function Qx() {
return {
$typeUrl: "/google.protobuf.Any",
typeUrl: "",
value: new Uint8Array(),
};
}
var fe = {
typeUrl: "/google.protobuf.Any",
is(e) {
return (
e &&
(e.$typeUrl === fe.typeUrl ||
(typeof e.typeUrl == "string" &&
(e.value instanceof Uint8Array || typeof e.value == "string")))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === fe.typeUrl ||
(typeof e.type_url == "string" &&
(e.value instanceof Uint8Array || typeof e.value == "string")))
);
},
encode(e, t = re.create()) {
return (
e.typeUrl !== "" && t.uint32(10).string(e.typeUrl),
e.value.length !== 0 && t.uint32(18).bytes(e.value),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Qx();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.typeUrl = r.string();
break;
case 2:
n.value = r.bytes();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
typeUrl: B(e.typeUrl) ? String(e.typeUrl) : "",
value: B(e.value) ? ke(e.value) : new Uint8Array(),
};
},
toJSON(e) {
let t = {};
return (
e.typeUrl !== void 0 && (t.typeUrl = e.typeUrl),
e.value !== void 0 &&
(t.value = Ee(e.value !== void 0 ? e.value : new Uint8Array())),
t
);
},
fromPartial(e) {
let t = Qx();
return (
(t.typeUrl = e.typeUrl ?? ""),
(t.value = e.value ?? new Uint8Array()),
t
);
},
fromProtoMsg(e) {
return fe.decode(e.value);
},
toProto(e) {
return fe.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/google.protobuf.Any",
value: fe.encode(e).finish(),
};
},
};
function zx() {
return { seconds: BigInt(0), nanos: 0 };
}
var we = {
typeUrl: "/google.protobuf.Timestamp",
is(e) {
return (
e &&
(e.$typeUrl === we.typeUrl ||
(typeof e.seconds == "bigint" && typeof e.nanos == "number"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === we.typeUrl ||
(typeof e.seconds == "bigint" && typeof e.nanos == "number"))
);
},
encode(e, t = re.create()) {
return (
e.seconds !== BigInt(0) && t.uint32(8).int64(e.seconds),
e.nanos !== 0 && t.uint32(16).int32(e.nanos),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = zx();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.seconds = r.int64();
break;
case 2:
n.nanos = r.int32();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
seconds: B(e.seconds) ? BigInt(e.seconds.toString()) : BigInt(0),
nanos: B(e.nanos) ? Number(e.nanos) : 0,
};
},
toJSON(e) {
let t = {};
return (
e.seconds !== void 0 &&
(t.seconds = (e.seconds || BigInt(0)).toString()),
e.nanos !== void 0 && (t.nanos = Math.round(e.nanos)),
t
);
},
fromPartial(e) {
let t = zx();
return (
(t.seconds =
e.seconds !== void 0 && e.seconds !== null
? BigInt(e.seconds.toString())
: BigInt(0)),
(t.nanos = e.nanos ?? 0),
t
);
},
fromProtoMsg(e) {
return we.decode(e.value);
},
toProto(e) {
return we.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/google.protobuf.Timestamp",
value: we.encode(e).finish(),
};
},
};
var T6 = ((e) => (
(e[(e.SIGN_MODE_UNSPECIFIED = 0)] = "SIGN_MODE_UNSPECIFIED"),
(e[(e.SIGN_MODE_DIRECT = 1)] = "SIGN_MODE_DIRECT"),
(e[(e.SIGN_MODE_TEXTUAL = 2)] = "SIGN_MODE_TEXTUAL"),
(e[(e.SIGN_MODE_DIRECT_AUX = 3)] = "SIGN_MODE_DIRECT_AUX"),
(e[(e.SIGN_MODE_LEGACY_AMINO_JSON = 127)] =
"SIGN_MODE_LEGACY_AMINO_JSON"),
(e[(e.SIGN_MODE_EIP_191 = 191)] = "SIGN_MODE_EIP_191"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(T6 || {});
var Cr = class e {
static fromUserInput(t, r) {
e.verifyFractionalDigits(r);
let o = t.match(/[^0-9.]/);
if (o) throw new Error(`Invalid character at position ${o.index + 1}`);
let n, a;
if (t === "") ((n = "0"), (a = ""));
else if (t.search(/\./) === -1) ((n = t), (a = ""));
else {
let c = t.split(".");
switch (c.length) {
case 0:
case 1:
throw new Error(
"Fewer than two elements in split result. This must not happen here.",
);
case 2:
if (!c[1]) throw new Error("Fractional part missing");
((n = c[0]), (a = c[1].replace(/0+$/, "")));
break;
default:
throw new Error("More than one separator found");
}
}
if (a.length > r)
throw new Error("Got more fractional digits than supported");
let i = `${n}${a.padEnd(r, "0")}`;
return new e(i, r);
}
static fromAtomics(t, r) {
return (e.verifyFractionalDigits(r), new e(t, r));
}
static verifyFractionalDigits(t) {
if (!Number.isInteger(t))
throw new Error("Fractional digits is not an integer");
if (t < 0) throw new Error("Fractional digits must not be negative");
if (t > 30) throw new Error("Fractional digits must not exceed 30");
}
get atomics() {
return this.data.atomics.toString();
}
get fractionalDigits() {
return this.data.fractionalDigits;
}
data;
constructor(t, r) {
if (!t.match(/^[0-9]+$/))
throw new Error(
"Invalid string format. Only non-negative integers in decimal representation supported.",
);
this.data = { atomics: BigInt(t), fractionalDigits: r };
}
toString() {
let t = BigInt(10) ** BigInt(this.data.fractionalDigits),
r = this.data.atomics / t,
o = this.data.atomics % t;
if (o === 0n) return r.toString();
{
let n = o
.toString()
.padStart(this.data.fractionalDigits, "0")
.replace(/0+$/, "");
return `${r.toString()}.${n}`;
}
}
};
function Yx() {
return { denom: "", amount: "" };
}
var G = {
typeUrl: "/cosmos.base.v1beta1.Coin",
annotations: {
"amino.dont_omitempty": { amount: !0 },
"gogoproto.nullable": { amount: !1 },
typeUrlFromField: { amount: "cosmos.Int" },
},
aminoType: "cosmos-sdk/Coin",
is(e) {
return (
e &&
(e.$typeUrl === G.typeUrl ||
(typeof e.denom == "string" && typeof e.amount == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === G.typeUrl ||
(typeof e.denom == "string" && typeof e.amount == "string"))
);
},
encode(e, t = re.create()) {
return (
e.denom !== "" && t.uint32(10).string(e.denom),
e.amount !== "" && t.uint32(18).string(e.amount),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Yx();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.denom = r.string();
break;
case 2:
n.amount = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
denom: B(e.denom) ? String(e.denom) : "",
amount: B(e.amount) ? String(e.amount) : "",
};
},
toJSON(e) {
let t = {};
return (
e.denom !== void 0 && (t.denom = e.denom),
e.amount !== void 0 && (t.amount = e.amount),
t
);
},
fromPartial(e) {
let t = Yx();
return ((t.denom = e.denom ?? ""), (t.amount = e.amount ?? ""), t);
},
fromProtoMsg(e) {
return G.decode(e.value);
},
toProto(e) {
return G.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.base.v1beta1.Coin",
value: G.encode(e).finish(),
};
},
};
function Zx() {
return { denom: "", amount: "" };
}
var Ye = {
typeUrl: "/cosmos.base.v1beta1.DecCoin",
annotations: {
"gogoproto.nullable": { amount: !1 },
typeUrlFromField: { amount: "cosmos.Dec" },
},
aminoType: "cosmos-sdk/DecCoin",
is(e) {
return (
e &&
(e.$typeUrl === Ye.typeUrl ||
(typeof e.denom == "string" && typeof e.amount == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ye.typeUrl ||
(typeof e.denom == "string" && typeof e.amount == "string"))
);
},
encode(e, t = re.create()) {
return (
e.denom !== "" && t.uint32(10).string(e.denom),
e.amount !== "" &&
t.uint32(18).string(Cr.fromUserInput(e.amount, 18).atomics),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Zx();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.denom = r.string();
break;
case 2:
n.amount = Cr.fromAtomics(r.string(), 18).toString();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
denom: B(e.denom) ? String(e.denom) : "",
amount: B(e.amount) ? String(e.amount) : "",
};
},
toJSON(e) {
let t = {};
return (
e.denom !== void 0 && (t.denom = e.denom),
e.amount !== void 0 && (t.amount = e.amount),
t
);
},
fromPartial(e) {
let t = Zx();
return ((t.denom = e.denom ?? ""), (t.amount = e.amount ?? ""), t);
},
fromProtoMsg(e) {
return Ye.decode(e.value);
},
toProto(e) {
return Ye.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.base.v1beta1.DecCoin",
value: Ye.encode(e).finish(),
};
},
};
function Xx() {
return {
messages: [],
memo: "",
timeoutHeight: BigInt(0),
unordered: !1,
timeoutTimestamp: void 0,
extensionOptions: [],
nonCriticalExtensionOptions: [],
};
}
var Ts = {
typeUrl: "/cosmos.tx.v1beta1.TxBody",
annotations: {
"gogoproto.nullable": { timeoutTimestamp: !0 },
typeUrlFromField: { timeoutTimestamp: () => we },
},
aminoType: "cosmos-sdk/TxBody",
is(e) {
return (
e &&
(e.$typeUrl === Ts.typeUrl ||
(Array.isArray(e.messages) &&
(!e.messages.length || fe.is(e.messages[0])) &&
typeof e.memo == "string" &&
typeof e.timeoutHeight == "bigint" &&
typeof e.unordered == "boolean" &&
Array.isArray(e.extensionOptions) &&
(!e.extensionOptions.length || fe.is(e.extensionOptions[0])) &&
Array.isArray(e.nonCriticalExtensionOptions) &&
(!e.nonCriticalExtensionOptions.length ||
fe.is(e.nonCriticalExtensionOptions[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ts.typeUrl ||
(Array.isArray(e.messages) &&
(!e.messages.length || fe.isSDK(e.messages[0])) &&
typeof e.memo == "string" &&
typeof e.timeout_height == "bigint" &&
typeof e.unordered == "boolean" &&
Array.isArray(e.extension_options) &&
(!e.extension_options.length ||
fe.isSDK(e.extension_options[0])) &&
Array.isArray(e.non_critical_extension_options) &&
(!e.non_critical_extension_options.length ||
fe.isSDK(e.non_critical_extension_options[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.messages) fe.encode(r, t.uint32(10).fork()).ldelim();
(e.memo !== "" && t.uint32(18).string(e.memo),
e.timeoutHeight !== BigInt(0) && t.uint32(24).uint64(e.timeoutHeight),
e.unordered === !0 && t.uint32(32).bool(e.unordered),
e.timeoutTimestamp !== void 0 &&
we.encode(e.timeoutTimestamp, t.uint32(42).fork()).ldelim());
for (let r of e.extensionOptions)
fe.encode(r, t.uint32(8186).fork()).ldelim();
for (let r of e.nonCriticalExtensionOptions)
fe.encode(r, t.uint32(16378).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Xx();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.messages.push(fe.decode(r, r.uint32()));
break;
case 2:
n.memo = r.string();
break;
case 3:
n.timeoutHeight = r.uint64();
break;
case 4:
n.unordered = r.bool();
break;
case 5:
n.timeoutTimestamp = we.decode(r, r.uint32());
break;
case 1023:
n.extensionOptions.push(fe.decode(r, r.uint32()));
break;
case 2047:
n.nonCriticalExtensionOptions.push(fe.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
messages: Array.isArray(e?.messages)
? e.messages.map((t) => fe.fromJSON(t))
: [],
memo: B(e.memo) ? String(e.memo) : "",
timeoutHeight: B(e.timeoutHeight)
? BigInt(e.timeoutHeight.toString())
: BigInt(0),
unordered: B(e.unordered) ? !!e.unordered : !1,
timeoutTimestamp: B(e.timeoutTimestamp)
? Ur(e.timeoutTimestamp)
: void 0,
extensionOptions: Array.isArray(e?.extensionOptions)
? e.extensionOptions.map((t) => fe.fromJSON(t))
: [],
nonCriticalExtensionOptions: Array.isArray(
e?.nonCriticalExtensionOptions,
)
? e.nonCriticalExtensionOptions.map((t) => fe.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.messages
? (t.messages = e.messages.map((r) => (r ? fe.toJSON(r) : void 0)))
: (t.messages = []),
e.memo !== void 0 && (t.memo = e.memo),
e.timeoutHeight !== void 0 &&
(t.timeoutHeight = (e.timeoutHeight || BigInt(0)).toString()),
e.unordered !== void 0 && (t.unordered = e.unordered),
e.timeoutTimestamp !== void 0 &&
(t.timeoutTimestamp = Tr(e.timeoutTimestamp).toISOString()),
e.extensionOptions
? (t.extensionOptions = e.extensionOptions.map((r) =>
r ? fe.toJSON(r) : void 0,
))
: (t.extensionOptions = []),
e.nonCriticalExtensionOptions
? (t.nonCriticalExtensionOptions =
e.nonCriticalExtensionOptions.map((r) =>
r ? fe.toJSON(r) : void 0,
))
: (t.nonCriticalExtensionOptions = []),
t
);
},
fromPartial(e) {
let t = Xx();
return (
(t.messages = e.messages?.map((r) => fe.fromPartial(r)) || []),
(t.memo = e.memo ?? ""),
(t.timeoutHeight =
e.timeoutHeight !== void 0 && e.timeoutHeight !== null
? BigInt(e.timeoutHeight.toString())
: BigInt(0)),
(t.unordered = e.unordered ?? !1),
(t.timeoutTimestamp =
e.timeoutTimestamp !== void 0 && e.timeoutTimestamp !== null
? we.fromPartial(e.timeoutTimestamp)
: void 0),
(t.extensionOptions =
e.extensionOptions?.map((r) => fe.fromPartial(r)) || []),
(t.nonCriticalExtensionOptions =
e.nonCriticalExtensionOptions?.map((r) => fe.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return Ts.decode(e.value);
},
toProto(e) {
return Ts.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.tx.v1beta1.TxBody",
value: Ts.encode(e).finish(),
};
},
};
function eA() {
return { type: "", key: new Uint8Array(), data: new Uint8Array() };
}
var Rr = {
typeUrl: "/tendermint.crypto.ProofOp",
is(e) {
return (
e &&
(e.$typeUrl === Rr.typeUrl ||
(typeof e.type == "string" &&
(e.key instanceof Uint8Array || typeof e.key == "string") &&
(e.data instanceof Uint8Array || typeof e.data == "string")))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Rr.typeUrl ||
(typeof e.type == "string" &&
(e.key instanceof Uint8Array || typeof e.key == "string") &&
(e.data instanceof Uint8Array || typeof e.data == "string")))
);
},
encode(e, t = re.create()) {
return (
e.type !== "" && t.uint32(10).string(e.type),
e.key.length !== 0 && t.uint32(18).bytes(e.key),
e.data.length !== 0 && t.uint32(26).bytes(e.data),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = eA();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.type = r.string();
break;
case 2:
n.key = r.bytes();
break;
case 3:
n.data = r.bytes();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
type: B(e.type) ? String(e.type) : "",
key: B(e.key) ? ke(e.key) : new Uint8Array(),
data: B(e.data) ? ke(e.data) : new Uint8Array(),
};
},
toJSON(e) {
let t = {};
return (
e.type !== void 0 && (t.type = e.type),
e.key !== void 0 &&
(t.key = Ee(e.key !== void 0 ? e.key : new Uint8Array())),
e.data !== void 0 &&
(t.data = Ee(e.data !== void 0 ? e.data : new Uint8Array())),
t
);
},
fromPartial(e) {
let t = eA();
return (
(t.type = e.type ?? ""),
(t.key = e.key ?? new Uint8Array()),
(t.data = e.data ?? new Uint8Array()),
t
);
},
fromProtoMsg(e) {
return Rr.decode(e.value);
},
toProto(e) {
return Rr.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/tendermint.crypto.ProofOp",
value: Rr.encode(e).finish(),
};
},
};
function tA() {
return { ops: [] };
}
var Qr = {
typeUrl: "/tendermint.crypto.ProofOps",
is(e) {
return (
e &&
(e.$typeUrl === Qr.typeUrl ||
(Array.isArray(e.ops) && (!e.ops.length || Rr.is(e.ops[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Qr.typeUrl ||
(Array.isArray(e.ops) && (!e.ops.length || Rr.isSDK(e.ops[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.ops) Rr.encode(r, t.uint32(10).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = tA();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.ops.push(Rr.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
ops: Array.isArray(e?.ops) ? e.ops.map((t) => Rr.fromJSON(t)) : [],
};
},
toJSON(e) {
let t = {};
return (
e.ops
? (t.ops = e.ops.map((r) => (r ? Rr.toJSON(r) : void 0)))
: (t.ops = []),
t
);
},
fromPartial(e) {
let t = tA();
return ((t.ops = e.ops?.map((r) => Rr.fromPartial(r)) || []), t);
},
fromProtoMsg(e) {
return Qr.decode(e.value);
},
toProto(e) {
return Qr.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/tendermint.crypto.ProofOps",
value: Qr.encode(e).finish(),
};
},
};
var R6 = ((e) => (
(e[(e.BLOCK_ID_FLAG_UNKNOWN = 0)] = "BLOCK_ID_FLAG_UNKNOWN"),
(e[(e.BLOCK_ID_FLAG_ABSENT = 1)] = "BLOCK_ID_FLAG_ABSENT"),
(e[(e.BLOCK_ID_FLAG_COMMIT = 2)] = "BLOCK_ID_FLAG_COMMIT"),
(e[(e.BLOCK_ID_FLAG_NIL = 3)] = "BLOCK_ID_FLAG_NIL"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(R6 || {});
var D6 = ((e) => (
(e[(e.NEW = 0)] = "NEW"),
(e[(e.RECHECK = 1)] = "RECHECK"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(D6 || {});
var N6 = ((e) => (
(e[(e.UNKNOWN = 0)] = "UNKNOWN"),
(e[(e.ACCEPT = 1)] = "ACCEPT"),
(e[(e.ABORT = 2)] = "ABORT"),
(e[(e.REJECT = 3)] = "REJECT"),
(e[(e.REJECT_FORMAT = 4)] = "REJECT_FORMAT"),
(e[(e.REJECT_SENDER = 5)] = "REJECT_SENDER"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(N6 || {});
var B6 = ((e) => (
(e[(e.UNKNOWN = 0)] = "UNKNOWN"),
(e[(e.ACCEPT = 1)] = "ACCEPT"),
(e[(e.ABORT = 2)] = "ABORT"),
(e[(e.RETRY = 3)] = "RETRY"),
(e[(e.RETRY_SNAPSHOT = 4)] = "RETRY_SNAPSHOT"),
(e[(e.REJECT_SNAPSHOT = 5)] = "REJECT_SNAPSHOT"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(B6 || {});
var M6 = ((e) => (
(e[(e.UNKNOWN = 0)] = "UNKNOWN"),
(e[(e.ACCEPT = 1)] = "ACCEPT"),
(e[(e.REJECT = 2)] = "REJECT"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(M6 || {});
var $6 = ((e) => (
(e[(e.UNKNOWN = 0)] = "UNKNOWN"),
(e[(e.ACCEPT = 1)] = "ACCEPT"),
(e[(e.REJECT = 2)] = "REJECT"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))($6 || {});
var _6 = ((e) => (
(e[(e.UNKNOWN = 0)] = "UNKNOWN"),
(e[(e.DUPLICATE_VOTE = 1)] = "DUPLICATE_VOTE"),
(e[(e.LIGHT_CLIENT_ATTACK = 2)] = "LIGHT_CLIENT_ATTACK"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(_6 || {});
function rA() {
return { data: new Uint8Array(), path: "", height: BigInt(0), prove: !1 };
}
var It = {
typeUrl: "/tendermint.abci.RequestQuery",
is(e) {
return (
e &&
(e.$typeUrl === It.typeUrl ||
((e.data instanceof Uint8Array || typeof e.data == "string") &&
typeof e.path == "string" &&
typeof e.height == "bigint" &&
typeof e.prove == "boolean"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === It.typeUrl ||
((e.data instanceof Uint8Array || typeof e.data == "string") &&
typeof e.path == "string" &&
typeof e.height == "bigint" &&
typeof e.prove == "boolean"))
);
},
encode(e, t = re.create()) {
return (
e.data.length !== 0 && t.uint32(10).bytes(e.data),
e.path !== "" && t.uint32(18).string(e.path),
e.height !== BigInt(0) && t.uint32(24).int64(e.height),
e.prove === !0 && t.uint32(32).bool(e.prove),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = rA();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.data = r.bytes();
break;
case 2:
n.path = r.string();
break;
case 3:
n.height = r.int64();
break;
case 4:
n.prove = r.bool();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
data: B(e.data) ? ke(e.data) : new Uint8Array(),
path: B(e.path) ? String(e.path) : "",
height: B(e.height) ? BigInt(e.height.toString()) : BigInt(0),
prove: B(e.prove) ? !!e.prove : !1,
};
},
toJSON(e) {
let t = {};
return (
e.data !== void 0 &&
(t.data = Ee(e.data !== void 0 ? e.data : new Uint8Array())),
e.path !== void 0 && (t.path = e.path),
e.height !== void 0 &&
(t.height = (e.height || BigInt(0)).toString()),
e.prove !== void 0 && (t.prove = e.prove),
t
);
},
fromPartial(e) {
let t = rA();
return (
(t.data = e.data ?? new Uint8Array()),
(t.path = e.path ?? ""),
(t.height =
e.height !== void 0 && e.height !== null
? BigInt(e.height.toString())
: BigInt(0)),
(t.prove = e.prove ?? !1),
t
);
},
fromProtoMsg(e) {
return It.decode(e.value);
},
toProto(e) {
return It.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/tendermint.abci.RequestQuery",
value: It.encode(e).finish(),
};
},
};
function oA() {
return {
code: 0,
log: "",
info: "",
index: BigInt(0),
key: new Uint8Array(),
value: new Uint8Array(),
proofOps: void 0,
height: BigInt(0),
codespace: "",
};
}
var Vt = {
typeUrl: "/tendermint.abci.ResponseQuery",
is(e) {
return (
e &&
(e.$typeUrl === Vt.typeUrl ||
(typeof e.code == "number" &&
typeof e.log == "string" &&
typeof e.info == "string" &&
typeof e.index == "bigint" &&
(e.key instanceof Uint8Array || typeof e.key == "string") &&
(e.value instanceof Uint8Array || typeof e.value == "string") &&
typeof e.height == "bigint" &&
typeof e.codespace == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Vt.typeUrl ||
(typeof e.code == "number" &&
typeof e.log == "string" &&
typeof e.info == "string" &&
typeof e.index == "bigint" &&
(e.key instanceof Uint8Array || typeof e.key == "string") &&
(e.value instanceof Uint8Array || typeof e.value == "string") &&
typeof e.height == "bigint" &&
typeof e.codespace == "string"))
);
},
encode(e, t = re.create()) {
return (
e.code !== 0 && t.uint32(8).uint32(e.code),
e.log !== "" && t.uint32(26).string(e.log),
e.info !== "" && t.uint32(34).string(e.info),
e.index !== BigInt(0) && t.uint32(40).int64(e.index),
e.key.length !== 0 && t.uint32(50).bytes(e.key),
e.value.length !== 0 && t.uint32(58).bytes(e.value),
e.proofOps !== void 0 &&
Qr.encode(e.proofOps, t.uint32(66).fork()).ldelim(),
e.height !== BigInt(0) && t.uint32(72).int64(e.height),
e.codespace !== "" && t.uint32(82).string(e.codespace),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = oA();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.code = r.uint32();
break;
case 3:
n.log = r.string();
break;
case 4:
n.info = r.string();
break;
case 5:
n.index = r.int64();
break;
case 6:
n.key = r.bytes();
break;
case 7:
n.value = r.bytes();
break;
case 8:
n.proofOps = Qr.decode(r, r.uint32());
break;
case 9:
n.height = r.int64();
break;
case 10:
n.codespace = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
code: B(e.code) ? Number(e.code) : 0,
log: B(e.log) ? String(e.log) : "",
info: B(e.info) ? String(e.info) : "",
index: B(e.index) ? BigInt(e.index.toString()) : BigInt(0),
key: B(e.key) ? ke(e.key) : new Uint8Array(),
value: B(e.value) ? ke(e.value) : new Uint8Array(),
proofOps: B(e.proofOps) ? Qr.fromJSON(e.proofOps) : void 0,
height: B(e.height) ? BigInt(e.height.toString()) : BigInt(0),
codespace: B(e.codespace) ? String(e.codespace) : "",
};
},
toJSON(e) {
let t = {};
return (
e.code !== void 0 && (t.code = Math.round(e.code)),
e.log !== void 0 && (t.log = e.log),
e.info !== void 0 && (t.info = e.info),
e.index !== void 0 && (t.index = (e.index || BigInt(0)).toString()),
e.key !== void 0 &&
(t.key = Ee(e.key !== void 0 ? e.key : new Uint8Array())),
e.value !== void 0 &&
(t.value = Ee(e.value !== void 0 ? e.value : new Uint8Array())),
e.proofOps !== void 0 &&
(t.proofOps = e.proofOps ? Qr.toJSON(e.proofOps) : void 0),
e.height !== void 0 &&
(t.height = (e.height || BigInt(0)).toString()),
e.codespace !== void 0 && (t.codespace = e.codespace),
t
);
},
fromPartial(e) {
let t = oA();
return (
(t.code = e.code ?? 0),
(t.log = e.log ?? ""),
(t.info = e.info ?? ""),
(t.index =
e.index !== void 0 && e.index !== null
? BigInt(e.index.toString())
: BigInt(0)),
(t.key = e.key ?? new Uint8Array()),
(t.value = e.value ?? new Uint8Array()),
(t.proofOps =
e.proofOps !== void 0 && e.proofOps !== null
? Qr.fromPartial(e.proofOps)
: void 0),
(t.height =
e.height !== void 0 && e.height !== null
? BigInt(e.height.toString())
: BigInt(0)),
(t.codespace = e.codespace ?? ""),
t
);
},
fromProtoMsg(e) {
return Vt.decode(e.value);
},
toProto(e) {
return Vt.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/tendermint.abci.ResponseQuery",
value: Vt.encode(e).finish(),
};
},
};
function nA() {
return { requests: [] };
}
var Us = {
typeUrl: "/icq.v1.CosmosQuery",
is(e) {
return (
e &&
(e.$typeUrl === Us.typeUrl ||
(Array.isArray(e.requests) &&
(!e.requests.length || It.is(e.requests[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Us.typeUrl ||
(Array.isArray(e.requests) &&
(!e.requests.length || It.isSDK(e.requests[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.requests) It.encode(r, t.uint32(10).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = nA();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.requests.push(It.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
requests: Array.isArray(e?.requests)
? e.requests.map((t) => It.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.requests
? (t.requests = e.requests.map((r) => (r ? It.toJSON(r) : void 0)))
: (t.requests = []),
t
);
},
fromPartial(e) {
let t = nA();
return (
(t.requests = e.requests?.map((r) => It.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return Us.decode(e.value);
},
toProto(e) {
return Us.encode(e).finish();
},
toProtoMsg(e) {
return { typeUrl: "/icq.v1.CosmosQuery", value: Us.encode(e).finish() };
},
};
function sA() {
return { responses: [] };
}
var Cs = {
typeUrl: "/icq.v1.CosmosResponse",
is(e) {
return (
e &&
(e.$typeUrl === Cs.typeUrl ||
(Array.isArray(e.responses) &&
(!e.responses.length || Vt.is(e.responses[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Cs.typeUrl ||
(Array.isArray(e.responses) &&
(!e.responses.length || Vt.isSDK(e.responses[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.responses) Vt.encode(r, t.uint32(10).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = sA();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.responses.push(Vt.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
responses: Array.isArray(e?.responses)
? e.responses.map((t) => Vt.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.responses
? (t.responses = e.responses.map((r) =>
r ? Vt.toJSON(r) : void 0,
))
: (t.responses = []),
t
);
},
fromPartial(e) {
let t = sA();
return (
(t.responses = e.responses?.map((r) => Vt.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return Cs.decode(e.value);
},
toProto(e) {
return Cs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/icq.v1.CosmosResponse",
value: Cs.encode(e).finish(),
};
},
};
var F6 =
/^\/(?<serviceName>\w+(?:\.\w+)*)\.Query(?<methodName>\w+)Request$/,
K6 = (e) => {
let t = e.match(F6);
if (!(t && t.groups))
throw TypeError(`Invalid typeUrl: ${e}. Must be a Query Request.`);
let { serviceName: r, methodName: o } = t.groups;
return `/${r}.Query/${o}`;
},
Eo = (e, t = {}) =>
It.toJSON(It.fromPartial({ path: K6(e.typeUrl), data: e.value, ...t }));
var J6 = (e) =>
new Map(
Object.entries(e).map(([t, r]) => [t, new Map(Object.entries(r))]),
);
var aA = (e) => {
if (typeof e == "function") return e();
if (typeof e == "object" && e !== null) return e;
},
ou = (e) => (typeof e == "string" ? e : aA(e)?.typeUrl),
iA = (e, t = new Map()) => {
let r = new Map(t),
o = new Set(),
n = (a) => {
let i = aA(a);
if (!i || o.has(i.typeUrl)) return;
o.add(i.typeUrl);
let { annotations: c } = i;
if (c) {
r.has(i.typeUrl) || r.set(i.typeUrl, J6(c));
for (let d of Object.values(c.typeUrlFromField ?? {})) n(d);
}
};
return (n(e), r);
},
V6 = { "cosmos.Int": (e) => `${BigInt(e || 0)}` },
cA = new Map(Object.entries(V6));
var { freeze: Do } = Object,
yy = (e, t, r, o) => {
let n = ou(t);
if (n == null || !n.startsWith("/")) return r;
let a = { ...(typeof r == "object" && r) },
i = o.get(n)?.get("typeUrlFromField");
for (let [c, d] of Object.entries(a)) {
let l = d,
u = i?.get(c);
(l && (l = yy(e, u, l, o)), (a[c] = l), e(a, c, o, u));
}
return (Do(a), a);
},
nu = (e, t, r) => {
let o = ou(e);
if (o == null) return t;
if (!o.startsWith("/")) {
let l = cA.get(o);
return l ? l(t) : t;
}
let n = { ...(typeof t == "object" && t) },
a = r.get(o),
i = a?.get("typeUrlFromField"),
c = a?.get("gogoproto.nullable"),
d = new Set(
[...(c?.entries() ?? [])].flatMap(([l, u]) => (u ? [] : [l])),
);
for (let [l, u] of Object.entries(n)) {
if (c?.get(l) !== !1) continue;
d.delete(l);
let p = nu(i?.get(l), u, r);
p != null && (n[l] = p);
}
for (let l of d.keys()) {
let u = nu(i?.get(l), n[l], r);
u != null && (n[l] = u);
}
return (Do(n), n);
},
H6 = (e, t, r, o) => {
let n = ou(o),
a = n ? r.get(n)?.get("gogoproto.nullable") : void 0;
e[t] == null && a?.get(t) === !1 ? (e[t] = {}) : e[t] || delete e[t];
},
W6 = (e, t, r, o) => {
e[t] === void 0 && delete e[t];
},
dA = (e, t) => {
let r = t.get(e.typeUrl),
o = r?.get("gogoproto.embed"),
n = [...(r?.get("gogoproto.nullable")?.entries() ?? [])].flatMap(
([l, u]) => (u ? [] : [l]),
);
Do(n);
let a = (l) => {
let u = { ...(typeof l == "object" && Object(l)) };
for (let [b, m] of o?.entries() ?? [])
u[m] == null && (u[m] = u[b] ?? u);
let p = nu(e.typeUrl, u, t),
y = e.fromPartial(p ?? u);
return (Do(y), y);
},
i = (l) => {
let u = a(l),
p = yy(H6, e.typeUrl, u, t);
return (Do(p), p ?? u);
},
c = (l) => {
let u = d(l),
p = yy(W6, e.typeUrl, u, t);
return Do(p);
},
d = (l) => {
let u = { ...l };
for (let y of o?.keys() ?? []) {
let b = u[y] ?? u;
if (Object(b) === b) {
for (let [m, v] of Object.entries(b))
u[m] == null && (u[m] = v);
delete u[y];
}
}
let p = nu(e.typeUrl, u, t);
return Do(p);
};
return Do({
encoderInputFromGogo3: a,
gogo3FromDecoderOutput: d,
packedFromGogo3: i,
strippedFromDecoderOutput: c,
});
},
L6 = (e) => {
if ("@type" in e) {
let { "@type": t, ...r } = e;
return { typeUrl: t, value: r };
} else if ("$typeUrl" in e) {
let { $typeUrl: t, ...r } = e;
return { typeUrl: t, value: r };
} else if ("typeUrl" in e) {
let { typeUrl: t, value: r } = e;
return { typeUrl: t, value: r instanceof Uint8Array ? r : { ...r } };
} else if ("type" in e) {
let { type: t, value: r } = e;
return { typeUrl: t, value: r };
}
throw TypeError(`Unrecognized input: ${e}`);
},
q6 = (e, t) => {
let { gogo3FromDecoderOutput: r, encoderInputFromGogo3: o } = dA(e, t),
n = {
typeUrl: e.typeUrl,
annotations: e.annotations,
encode(a, i) {
return e.encode(o(a), i);
},
decode(a, i) {
return r(e.decode(a, i));
},
fromJSON(a) {
return r(e.fromJSON(a));
},
toJSON(a) {
return e.toJSON(o(a));
},
fromPartial(a) {
return o(a);
},
fromProtoMsg(a) {
return r(e.fromProtoMsg(a));
},
toProto(a) {
return e.toProto(o(a));
},
toProtoMsg(a) {
return e.toProtoMsg(o(a));
},
};
return (Do(n), n);
};
var pe = (e, t = new Map()) => {
let r = iA(e, t),
o = q6(e, r),
{ strippedFromDecoderOutput: n, packedFromGogo3: a } = dA(o, r),
i = {
...o,
typedJson(c) {
let d = a(c);
return { "@type": e.typeUrl, ...(typeof d == "object" && d) };
},
fromTyped(c) {
let { typeUrl: d, value: l } = L6(c);
if (d !== e.typeUrl)
throw TypeError(`Invalid typeUrl: ${d}. Must be ${e.typeUrl}.`);
return l instanceof Uint8Array
? o.fromProtoMsg({ typeUrl: d, value: l })
: n(l);
},
};
return (Do(i), i);
};
var gy = ((e) => (
(e[(e.TYPE_UNSPECIFIED = 0)] = "TYPE_UNSPECIFIED"),
(e[(e.TYPE_EXECUTE_TX = 1)] = "TYPE_EXECUTE_TX"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(gy || {});
var j6 = pe(Ts),
G6 = pe(fe),
Q6 = pe(It),
z6 = pe(Vt),
lA = pe(Us),
Y6 = pe(Cs);
function hy(e, t) {
let r = e.map(G6.fromJSON);
t?.unordered &&
(t?.timeoutTimestamp ||
f`unordered packets must have a timeout timestamp`);
let o = j6.toProto({ messages: r, ...t });
return JSON.stringify({
type: gy.TYPE_EXECUTE_TX,
data: Ee(o),
memo: "",
});
}
harden(hy);
function by(e) {
let t = lA
.encode(lA.fromPartial({ requests: e.map(Q6.fromJSON) }))
.finish();
return JSON.stringify({ data: Ee(t), memo: "" });
}
harden(by);
function su(e) {
let { result: t, error: r } = JSON.parse(e);
if (t) return t;
throw r ? Error(r) : f`expected either result or error: ${e}`;
}
harden(su);
function vy(e) {
let t = su(e),
{ data: r } = JSON.parse(Of(t)),
{ responses: o = [] } = Y6.decode(ke(r));
return harden(o.map(z6.toJSON));
}
harden(vy);
var au = Ae("IcaAccountKit"),
Z6 = "UNPARSABLE_CHAIN_ADDRESS",
X6 = s.interface("IcaAccount", {
getAddress: s.call().returns(je),
getLocalAddress: s.call().returns(s.string()),
getRemoteAddress: s.call().returns(s.string()),
getPort: s.call().returns(s.remotable("Port")),
executeTx: s.call(s.arrayOf(s.record())).returns(le),
executeEncodedTx: s.call(s.arrayOf(ks)).optional(zl).returns(le),
deactivate: s.call().returns(le),
reactivate: s.call().returns(le),
}),
uA = (e, { watch: t, asVow: r }) =>
e.exoClassKit(
"IcaAccountKit",
{
account: X6,
connectionHandler: Gl,
parseTxPacketWatcher: s.interface("ParseTxPacketWatcher", {
onFulfilled: s
.call(s.string())
.optional(s.arrayOf(s.undefined()))
.returns(s.string()),
}),
},
(o, n, a) => ({
chainId: o,
port: n,
connection: void 0,
requestedRemoteAddress: a,
remoteAddress: void 0,
chainAddress: void 0,
localAddress: void 0,
isInitiatingClose: !1,
}),
{
parseTxPacketWatcher: {
onFulfilled(o) {
return su(o);
},
},
account: {
getAddress() {
return Lr(
this.state.chainAddress,
"ICA channel creation acknowledgement not yet received.",
);
},
getLocalAddress() {
return Lr(
this.state.localAddress,
"local address not available",
);
},
getRemoteAddress() {
return Lr(
this.state.remoteAddress,
"remote address not available",
);
},
getPort() {
return this.state.port;
},
executeTx() {
return r(() => f`not yet implemented`);
},
executeEncodedTx(o, n = {}) {
return r(() => {
let { connection: a } = this.state;
if (!a) throw f`Account not available or deactivated.`;
let { sendOpts: i, txOpts: c, ...d } = n,
l = { ...d, ...c };
return t(
O(a).send(hy(o, l), i),
this.facets.parseTxPacketWatcher,
);
});
},
deactivate() {
return r(() => {
let { connection: o } = this.state;
if (!o) throw f`Account not available or deactivated.`;
return ((this.state.isInitiatingClose = !0), O(o).close());
});
},
reactivate() {
return r(() => {
let {
connection: o,
port: n,
requestedRemoteAddress: a,
} = this.state;
if (o) throw f`Account is already active.`;
return t(O(n).connect(a, this.facets.connectionHandler));
});
},
},
connectionHandler: {
async onOpen(o, n, a) {
(au(`ICA Channel Opened for ${n} at ${a}`),
(this.state.connection = o),
(this.state.remoteAddress = a),
(this.state.localAddress = n));
let i = Vf(a);
(i ||
console.error(
"\u26A0\uFE0F failed to parse chain address",
a,
),
(this.state.chainAddress = harden({
value: i || Z6,
chainId: this.state.chainId,
encoding: "bech32",
})));
},
async onClose(o, n) {
(au(`ICA Channel closed. Reason: ${n}`),
(this.state.connection = void 0),
(this.state.localAddress = void 0),
(this.state.remoteAddress = void 0),
this.state.isInitiatingClose === !0
? (au(
"Account deactivated by holder. Skipping reactivation.",
),
(this.state.isInitiatingClose = !1))
: (au(
"Account closed unexpectedly. Automatically reactivating.",
),
t(this.facets.account.reactivate())));
},
},
},
);
var pA = Ae("Orchestration:ICQConnection"),
eD = s.interface("ICQConnection", {
getLocalAddress: s.call().returns(s.string()),
getRemoteAddress: s.call().returns(s.string()),
query: s.call(s.arrayOf(Mc)).returns(le),
}),
mA = (e, { watch: t, asVow: r }) =>
e.exoClassKit(
"ICQConnectionKit",
{
connection: eD,
connectionHandler: Gl,
parseQueryPacketWatcher: s.interface("ParseQueryPacketWatcher", {
onFulfilled: s
.call(s.string())
.optional(s.arrayOf(s.undefined()))
.returns(s.arrayOf(s.record())),
}),
},
(o) => ({
port: o,
connection: void 0,
remoteAddress: void 0,
localAddress: void 0,
}),
{
connection: {
getLocalAddress() {
return Lr(
this.state.localAddress,
"local address not available",
);
},
getRemoteAddress() {
return Lr(
this.state.remoteAddress,
"remote address not available",
);
},
query(o) {
return r(() => {
let { connection: n } = this.state;
if (!n) throw f`connection not available`;
return t(
O(n).send(by(o)),
this.facets.parseQueryPacketWatcher,
);
});
},
},
parseQueryPacketWatcher: {
onFulfilled(o) {
return vy(o);
},
},
connectionHandler: {
async onOpen(o, n, a) {
(pA(`ICQ Channel Opened for ${n} at ${a}`),
(this.state.connection = o),
(this.state.remoteAddress = a),
(this.state.localAddress = n));
},
async onClose(o, n) {
pA(`ICQ Channel closed. Reason: ${n}`);
},
},
},
);
var { Vow$: iu } = dt,
tD = (e, t) => `${e}:${t || Kf}`,
rD = (e, { watch: t, asVow: r }, o, n) =>
e.exoClassKit(
"Orchestration",
{
requestICAChannelWatcher: s.interface("RequestICAChannelWatcher", {
onFulfilled: s
.call(s.remotable("Port"))
.optional({ chainId: s.string(), remoteConnAddr: s.string() })
.returns(iu(dt.Connection)),
}),
requestICQChannelWatcher: s.interface("RequestICQChannelWatcher", {
onFulfilled: s
.call(s.remotable("Port"))
.optional({
remoteConnAddr: s.string(),
icqLookupKey: s.string(),
})
.returns(iu(dt.Connection)),
}),
channelOpenWatcher: s.interface("ChannelOpenWatcher", {
onFulfilled: s
.call(s.remotable("Connection"))
.optional(
s.splitRecord(
{ connectionKit: s.record(), returnFacet: s.string() },
{ icqLookupKey: s.string() },
),
)
.returns(s.remotable("ConnectionKit Holder facet")),
}),
public: s.interface("CosmosInterchainService", {
makeAccount: s
.call(s.string(), s.string(), s.string())
.optional(s.record())
.returns(iu(s.remotable("IcaAccountKit"))),
provideICQConnection: s
.call(s.string())
.optional(s.string())
.returns(iu(s.remotable("ICQConnection"))),
}),
},
(a) => (
Be(a?.portAllocator, s.remotable("PortAllocator")),
{
icqConnections: e.detached().mapStore("ICQConnections"),
sharedICQPort: void 0,
reserved: void 0,
...a,
}
),
{
requestICAChannelWatcher: {
onFulfilled(a, { chainId: i, remoteConnAddr: c }) {
let d = o(i, a, c);
return t(
O(a).connect(c, d.connectionHandler),
this.facets.channelOpenWatcher,
{ returnFacet: "account", connectionKit: d },
);
},
},
requestICQChannelWatcher: {
onFulfilled(a, { remoteConnAddr: i, icqLookupKey: c }) {
this.state.sharedICQPort || (this.state.sharedICQPort = a);
let d = n(a);
return t(
O(a).connect(i, d.connectionHandler),
this.facets.channelOpenWatcher,
{
connectionKit: d,
returnFacet: "connection",
icqLookupKey: c,
},
);
},
},
channelOpenWatcher: {
onFulfilled(
a,
{ connectionKit: i, returnFacet: c, icqLookupKey: d },
) {
return (d && this.state.icqConnections.init(d, i), i[c]);
},
},
public: {
makeAccount(a, i, c, d) {
let l = Ff(i, c, d),
{ portAllocator: u } = this.state;
return t(
O(u).allocateICAControllerPort(),
this.facets.requestICAChannelWatcher,
{ chainId: a, remoteConnAddr: l },
);
},
provideICQConnection(a, i) {
let c = tD(a, i);
if (this.state.icqConnections.has(c))
return r(() => this.state.icqConnections.get(c).connection);
let d = Jf(a, i),
{ portAllocator: l, sharedICQPort: u } = this.state,
p = u || O(l).allocateICQControllerPort();
return t(p, this.facets.requestICQChannelWatcher, {
remoteConnAddr: d,
icqLookupKey: c,
});
},
},
},
{
stateShape: {
icqConnections: s.remotable("icqConnections mapStore"),
sharedICQPort: s.or(s.remotable("Port"), s.undefined()),
portAllocator: s.remotable("PortAllocator"),
reserved: s.any(),
},
},
),
oD = (e, t) => {
let r = uA(e, t),
o = mA(e, t),
n = rD(e, t, r, o);
return Pr(n, "public");
};
harden(oD);
du();
No();
function cD(e, t, r, o) {
if (typeof e.setBigUint64 == "function") return e.setBigUint64(t, r, o);
let n = BigInt(32),
a = BigInt(4294967295),
i = Number((r >> n) & a),
c = Number(r & a),
d = o ? 4 : 0,
l = o ? 0 : 4;
(e.setUint32(t + d, i, o), e.setUint32(t + l, c, o));
}
var hA = (e, t, r) => (e & t) ^ (~e & r),
bA = (e, t, r) => (e & t) ^ (e & r) ^ (t & r),
mu = class extends ti {
constructor(t, r, o, n) {
(super(),
(this.blockLen = t),
(this.outputLen = r),
(this.padOffset = o),
(this.isLE = n),
(this.finished = !1),
(this.length = 0),
(this.pos = 0),
(this.destroyed = !1),
(this.buffer = new Uint8Array(t)),
(this.view = lu(this.buffer)));
}
update(t) {
ei(this);
let { view: r, buffer: o, blockLen: n } = this;
t = ri(t);
let a = t.length;
for (let i = 0; i < a; ) {
let c = Math.min(n - this.pos, a - i);
if (c === n) {
let d = lu(t);
for (; n <= a - i; i += n) this.process(d, i);
continue;
}
(o.set(t.subarray(i, i + c), this.pos),
(this.pos += c),
(i += c),
this.pos === n && (this.process(r, 0), (this.pos = 0)));
}
return ((this.length += t.length), this.roundClean(), this);
}
digestInto(t) {
(ei(this), cu(t, this), (this.finished = !0));
let { buffer: r, view: o, blockLen: n, isLE: a } = this,
{ pos: i } = this;
((r[i++] = 128),
this.buffer.subarray(i).fill(0),
this.padOffset > n - i && (this.process(o, 0), (i = 0)));
for (let p = i; p < n; p++) r[p] = 0;
(cD(o, n - 8, BigInt(this.length * 8), a), this.process(o, 0));
let c = lu(t),
d = this.outputLen;
if (d % 4)
throw new Error("_sha2: outputLen should be aligned to 32bit");
let l = d / 4,
u = this.get();
if (l > u.length)
throw new Error("_sha2: outputLen bigger than state");
for (let p = 0; p < l; p++) c.setUint32(4 * p, u[p], a);
}
digest() {
let { buffer: t, outputLen: r } = this;
this.digestInto(t);
let o = t.slice(0, r);
return (this.destroy(), o);
}
_cloneInto(t) {
(t || (t = new this.constructor()), t.set(...this.get()));
let {
blockLen: r,
buffer: o,
length: n,
finished: a,
destroyed: i,
pos: c,
} = this;
return (
(t.length = n),
(t.pos = c),
(t.finished = a),
(t.destroyed = i),
n % r && t.buffer.set(o),
t
);
}
};
No();
var dD = new Uint32Array([
1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993,
2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987,
1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774,
264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986,
2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711,
113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291,
1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411,
3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344,
430227734, 506948616, 659060556, 883997877, 958139571, 1322822218,
1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424,
2428436474, 2756734187, 3204031479, 3329325298,
]),
Vn = new Uint32Array([
1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924,
528734635, 1541459225,
]),
Hn = new Uint32Array(64),
wy = class extends mu {
constructor() {
(super(64, 32, 8, !1),
(this.A = Vn[0] | 0),
(this.B = Vn[1] | 0),
(this.C = Vn[2] | 0),
(this.D = Vn[3] | 0),
(this.E = Vn[4] | 0),
(this.F = Vn[5] | 0),
(this.G = Vn[6] | 0),
(this.H = Vn[7] | 0));
}
get() {
let { A: t, B: r, C: o, D: n, E: a, F: i, G: c, H: d } = this;
return [t, r, o, n, a, i, c, d];
}
set(t, r, o, n, a, i, c, d) {
((this.A = t | 0),
(this.B = r | 0),
(this.C = o | 0),
(this.D = n | 0),
(this.E = a | 0),
(this.F = i | 0),
(this.G = c | 0),
(this.H = d | 0));
}
process(t, r) {
for (let p = 0; p < 16; p++, r += 4) Hn[p] = t.getUint32(r, !1);
for (let p = 16; p < 64; p++) {
let y = Hn[p - 15],
b = Hn[p - 2],
m = zr(y, 7) ^ zr(y, 18) ^ (y >>> 3),
v = zr(b, 17) ^ zr(b, 19) ^ (b >>> 10);
Hn[p] = (v + Hn[p - 7] + m + Hn[p - 16]) | 0;
}
let { A: o, B: n, C: a, D: i, E: c, F: d, G: l, H: u } = this;
for (let p = 0; p < 64; p++) {
let y = zr(c, 6) ^ zr(c, 11) ^ zr(c, 25),
b = (u + y + hA(c, d, l) + dD[p] + Hn[p]) | 0,
v = ((zr(o, 2) ^ zr(o, 13) ^ zr(o, 22)) + bA(o, n, a)) | 0;
((u = l),
(l = d),
(d = c),
(c = (i + b) | 0),
(i = a),
(a = n),
(n = o),
(o = (b + v) | 0));
}
((o = (o + this.A) | 0),
(n = (n + this.B) | 0),
(a = (a + this.C) | 0),
(i = (i + this.D) | 0),
(c = (c + this.E) | 0),
(d = (d + this.F) | 0),
(l = (l + this.G) | 0),
(u = (u + this.H) | 0),
this.set(o, n, a, i, c, d, l, u));
}
roundClean() {
Hn.fill(0);
}
destroy() {
(this.set(0, 0, 0, 0, 0, 0, 0, 0), this.buffer.fill(0));
}
};
var Py = pu(() => new wy());
var vA = (e, t, r) => {
let o = (i, c) => {
if (c === void 0) return n(i);
try {
return n(i);
} catch (d) {
Jr(d, c);
}
},
n = (i) => {
if (Je(i)) return i;
let c = ce(i);
switch (c) {
case "copyArray":
return i.map((d, l) => o(d, l));
case "copyRecord":
return Ne(i, (d, l) => o(d, l));
case "tagged": {
if (cr(i)) return t(i);
let d = $e(i),
{ payload: l } = i;
return Ce(d, o(l, `${d} payload`));
}
case "error":
return r(i);
case "remotable":
return e(i);
case "promise":
return t(i);
default:
throw f`unexpected passStyle ${x(c)}`;
}
},
a = (i, c = void 0) => o(harden(i), c);
return harden(a);
},
ky = (e, t, r) => {
let o = vA(
(a) => {
if (e.hasGuest(a)) return e.guestToHost(a);
throw f`cannot yet send guest remotables ${a}`;
},
(a) => {
if (e.hasGuest(a)) return e.guestToHost(a);
throw f`cannot yet send guest promises ${a}`;
},
(a) => {
let i = harden(Se(a.message, br(a.name)));
return (Ze(i, V`from guest error ${a}`), i);
},
),
n = vA(
(a) => {
if (e.hasHost(a)) return e.hostToGuest(a);
let i = t(a);
return e.unwrapInit(i, a);
},
(a) => {
if (e.hasHost(a)) return e.hostToGuest(a);
let i = r(a);
return e.unwrapInit(i, a);
},
(a) => {
let i = harden(Se(a.message, br(a.name)));
return (Ze(i, V`from host error ${a}`), i);
},
);
return harden({ guestToHost: o, hostToGuest: n });
};
harden(ky);
var { is: lD } = Object,
Iy = (e) => {
let t = (o, n, a) => {
a === void 0 && r(o, n);
try {
r(o, n);
} catch (i) {
Jr(i, a);
}
},
r = (o, n) => {
if (Je(o)) {
lD(o, n) || f`unequal ${o} vs ${n}`;
return;
}
if (e.hasGuest(o) && e.guestToHost(o) === n) return;
let a = ce(o);
if (a === "promise" && cr(n))
throw f`guest promises not yet passable`;
let i = ce(n);
switch ((a === i || f`unequal passStyles ${x(a)} vs ${x(i)}`, a)) {
case "copyArray": {
(t(o.length, n.length, "length"),
o.forEach((c, d) => t(c, n[d], d)));
return;
}
case "copyRecord": {
let c = Ft(o),
d = Ft(n);
t(c, d, "propertyNames");
for (let l of c) t(o[l], n[l], l);
return;
}
case "tagged": {
(t($e(o), $e(n), "tag"), t(o.payload, n.payload, "payload"));
return;
}
case "error": {
(t(o.name, n.name, "error name"),
Ze(o, V`replay of error ${n}`),
Ze(n, V`replayed as error ${o}`));
return;
}
case "remotable":
throw f`cannot yet send guest remotables to host ${o} vs ${n}`;
case "promise":
throw f`cannot yet send guest promises to host ${o} vs ${n}`;
default:
throw f`unexpected passStyle ${x(a)}`;
}
};
return harden(t);
};
harden(Iy);
var { fromEntries: uD, defineProperties: SA, assign: pD } = Object,
Ty = (e) => {
let t = Object.fromEntries(
Object.entries(e).filter(([r]) => !r.startsWith("__")),
);
return mD(t);
},
mD = ({
log: e,
bijection: t,
vowTools: r,
watchWake: o,
panic: n,
__eventualSendForTesting: a,
}) => {
let { when: i, makeVowKit: c } = r,
d = Iy(t),
l = new WeakMap(),
u = !1,
p = (W, ...Y) => n(Se(V(W, ...Y))),
y = (W) => {
(Number.isSafeInteger(W) ||
f`generation expected integer; got ${W}`,
W >= 0 || f`generation expected non-negative; got ${W}`);
},
b = (W, Y) => {
let j = D(W),
X = l.get(j);
(!X || X === "settled") &&
f`doFulfill should only be called on a registered unresolved promise`;
let z = D(Y);
(X.resolve(z), l.set(j, "settled"));
},
m = (W, Y) => {
let j = D(W),
X = l.get(j);
(!X || X === "settled") &&
f`doReject should only be called on a registered unresolved promise`;
let z = D(Y);
(X.reject(z), l.set(j, "settled"));
},
v = (W, Y) => {
ne(W);
let j = D(Y);
return harden({ kind: "return", result: j });
},
h = (W, Y) => {
ne(W);
let j = D(Y);
return harden({ kind: "throw", problem: j });
},
g = (W, Y, j, X) => {
let z;
try {
((z = Y ? W[Y](...j) : W(...j)),
D(z, `converting ${Y || "host"} result`));
} catch (te) {
return N(T, harden(["doThrow", X, te]));
}
return N(T, harden(["doReturn", X, z]));
},
S = (W, Y, j, X) => {
if (u || !t.hasGuest(W)) {
let te =
F.length === 0 ? "" : ` with non-empty callstack ${x(F)};`;
f`Called from a previous run: ${W}${tt(te)}`;
}
let z;
try {
let te = harden(["checkCall", W, Y, j, X]);
if (e.isReplaying()) {
let oe = e.nextEntry();
(d(
te,
oe,
`replay ${X}:
${x(te)}
vs ${x(oe)}
`,
),
(z = q(X)));
} else {
let oe = U(te);
e.pushEntry(oe);
let [ie, ...ue] = oe;
(q(X), (z = g(...ue)));
}
} catch (te) {
throw n(te);
}
switch (z.kind) {
case "return":
return z.result;
case "throw":
throw z.problem;
default:
throw p`unexpected outcome kind ${x(z.kind)}`;
}
},
w = (W, Y, j) => {
try {
Y === void 0 ? Kn.sendOnly(W)(...j) : Kn.sendOnly(W)[Y](...j);
} catch (X) {
throw p`internal: eventual sendOnly synchronously failed ${X}`;
}
},
I = (W, Y, j, X, z, te) => {
let { vow: oe, resolver: ie } = z;
try {
let ue = Y === void 0 ? Kn(W)(...j) : Kn(W)[Y](...j);
ie.resolve(ue);
} catch (ue) {
throw p`internal: eventual send synchronously failed ${ue}`;
}
try {
let ue = harden(["doReturn", X, oe]);
e.pushEntry(ue);
let ge = k(oe, te);
return (v(X, oe), harden({ kind: "return", result: ge }));
} catch (ue) {
throw n(ue);
}
},
E = harden({
applyMethodSendOnly(W, Y, j) {
a ||
p`guest eventual applyMethodSendOnly not yet supported: ${W}.${tt(Y)}`;
let X = e.getIndex();
(u || !t.hasGuest(W)) && f`Sent from a previous run: ${W}`;
try {
let z = harden(["checkSendOnly", W, Y, j, X]);
if (e.isReplaying()) {
let te = e.nextEntry();
try {
d(z, te);
} catch (oe) {
Jr(
oe,
`replay ${X}:
${x(z)}
vs ${x(te)}
`,
);
}
} else {
let te = U(z);
e.pushEntry(te);
let [oe, ie, ue, ge, Fe] = te;
w(ie, Y, ge);
}
} catch (z) {
throw n(z);
}
},
applyMethod(W, Y, j, X) {
a ||
p`guest eventual applyMethod not yet supported: ${W}.${tt(Y)} -> ${tt(X)}`;
let z = e.getIndex();
(u || !t.hasGuest(W)) && f`Sent from a previous run: ${W}`;
let te = c(),
oe = t.unwrapInit(X, te.vow);
oe === X ||
f`internal: guestReturnedP should not unwrap: ${oe} vs ${X}`;
let ie;
try {
let ue = harden(["checkSend", W, Y, j, z]);
if (e.isReplaying()) {
let ge = e.nextEntry();
try {
d(ue, ge);
} catch (Fe) {
Jr(
Fe,
`replay ${z}:
${x(ue)}
vs ${x(ge)}
`,
);
}
ie = q(z);
} else {
let ge = U(ue);
e.pushEntry(ge);
let [Fe, Ke, vt, tr, Gt] = ge;
(q(z), (ie = I(Ke, Y, tr, z, te, X)));
}
} catch (ue) {
throw n(ue);
}
switch (ie.kind) {
case "return":
return ie.result;
case "throw":
throw ie.problem;
default:
throw p`unexpected outcome kind ${x(ie.kind)}`;
}
},
applyFunctionSendOnly(W, Y) {
return (
a ||
p`guest eventual applyFunctionSendOnly not yet supported: ${W}`,
E.applyMethodSendOnly(W, void 0, Y)
);
},
applyFunction(W, Y, j) {
return (
a ||
p`guest eventual applyFunction not yet supported: ${W} -> ${tt(j)}`,
E.applyMethod(W, void 0, Y, j)
);
},
getSendOnly(W, Y) {
throw p`guest eventual getSendOnly not yet supported: ${W}.${tt(Y)}`;
},
get(W, Y, j) {
throw p`guest eventual get not yet supported: ${W}.${tt(Y)} -> ${tt(j)}`;
},
}),
K = (W, Y) => {
let j;
if (
(new HandledPromise((z, te, oe) => {
j = oe(E);
}),
typeof j != "object")
)
throw f`presence expected to be object ${j}`;
pD(j, uD(Y));
let X = Ia(W, void 0, j);
return (
X === j ||
f`Remotable expected to make presence in place: ${j} vs ${X}`,
X
);
},
J = () => {
let W,
Y,
j = new HandledPromise((X, z, te) => {
((W = X), (Y = z));
}, E);
return harden({ promise: j, resolve: W, reject: Y });
},
P = (W) => {
let Y,
j = (te = void 0) => {
let oe = (...ie) => {
let ue = e.getIndex();
return S(Y, te, ie, ue);
};
return (
te
? SA(oe, {
name: { value: String(W[te].name || te) },
length: { value: Number(W[te].length || 0) },
})
: SA(oe, {
name: { value: String(W.name || "anon") },
length: { value: Number(W.length || 0) },
}),
oe
);
},
z = `${String(po(W) || "remotable")} guest wrapper`;
if (typeof W == "function")
throw (
(Y = Ia(z, void 0, j())),
f`host far functions not yet passable`
);
{
let oe = _r(W).map((ie) => [ie, j(ie)]);
Y = K(z, oe);
}
return ((W = void 0), Y);
};
harden(P);
let k = (W, Y = void 0) => {
cr(W) || f`vow expected ${W}`;
let { promise: j, resolve: X, reject: z } = J();
return (
(Y ??= j),
l.set(Y, harden({ resolve: X, reject: z })),
o(W),
i(
W,
async (te) => {
if (
(await e.promiseReplayDone(), !u && l.get(Y) !== "settled")
) {
let oe = harden(["doFulfill", W, te]);
e.pushEntry(oe);
try {
R(_, oe);
} catch {}
}
},
async (te) => {
if (
(await e.promiseReplayDone(), !u && l.get(Y) !== "settled")
) {
let oe = harden(["doReject", W, te]);
e.pushEntry(oe);
try {
R(_, oe);
} catch {}
}
},
),
j
);
};
harden(k);
let { guestToHost: U, hostToGuest: D } = ky(t, P, k),
_ = harden({ startGeneration: y, doFulfill: b, doReject: m }),
T = harden({ doReturn: v, doThrow: h }),
R = (W, [Y, ...j]) => {
try {
return (Y in W || f`unexpected dispatch op: ${x(Y)}`, W[Y](...j));
} catch (X) {
throw n(X);
}
},
N = (W, Y) => (e.pushEntry(Y), R(W, Y)),
F = [],
H = !1,
q = (W) => {
for (F.push(W); e.isReplaying() && !u; ) {
let Y = e.nextUnfilteredEntry(),
j = R(T, Y);
if (H)
return (
j || f`only unnest with an outcome: ${x(Y[0])}`,
(H = !1),
j
);
}
H = !1;
},
ne = (W) => {
(!u || f`This membrane stopped. Restart with new membrane ${L}`,
F.length >= 1 || f`Unmatched unnest: ${x(W)}`);
let Y = F.pop();
(Y === W || f`Unexpected unnest: ${x(W)} vs ${x(Y)}`,
(H = !0),
F.length === 0 && O.when(void 0, ee));
},
ee = () => {
for (; e.isReplaying() && !u; ) {
F.length === 0 || f`wake only with empty callStack: ${x(F)}`;
let W = e.peekEntry();
if (!(W[0] in _)) return;
(e.nextUnfilteredEntry(), R(_, W));
}
},
L = se("replayMembrane", {
hostToGuest: D,
guestToHost: U,
wake: ee,
stop: () => {
u = !0;
},
});
return L;
};
harden(Ty);
var xA = s.or("Running", "Sleeping", "Replaying", "Failed", "Done"),
oi = s.or(s.string(), s.symbol()),
Bo = s.or(
["startGeneration", s.number()],
["doFulfill", le, s.any()],
["doReject", le, s.any()],
["doReturn", s.number(), s.any()],
["doThrow", s.number(), s.any()],
[
"checkCall",
s.remotable("host target"),
s.opt(oi),
s.arrayOf(s.any()),
s.number(),
],
[
"checkSendOnly",
s.or(s.remotable("host target"), le),
s.opt(oi),
s.arrayOf(s.any()),
s.number(),
],
[
"checkSend",
s.or(s.remotable("host target"), le),
s.opt(oi),
s.arrayOf(s.any()),
s.number(),
],
);
var ni = (e) => {
let t = new WeakMap();
return harden({
for(r) {
return (t.has(r) || t.set(r, e(r)), t.get(r));
},
resetFor(r) {
return t.delete(r);
},
});
};
harden(ni);
var fD = s.interface("LogStore", {
reset: s.call().returns(),
dispose: s.call().returns(),
getUnfilteredIndex: s.call().returns(s.number()),
getIndex: s.call().returns(s.number()),
getLength: s.call().returns(s.number()),
isReplaying: s.call().returns(s.boolean()),
peekEntry: s.call().returns(Bo),
nextEntry: s.call().returns(Bo),
nextUnfilteredEntry: s.call().returns(Bo),
pushEntry: s.call(Bo).returns(s.number()),
dumpUnfiltered: s.call().returns(s.arrayOf(Bo)),
dump: s.call().returns(s.arrayOf(Bo)),
promiseReplayDone: s.call().returns(s.promise()),
}),
yD = (e) => {
let t = e.mapStore("LogStoreMetadata"),
r = "generation";
if (!t.has(r)) return (t.init(r, 0), 0);
let o = t.get(r) + 1;
return (t.set(r, o), o);
},
AA = (e) => {
let t = harden([["startGeneration", yD(e)]]),
r = (n) => n[0] !== "startGeneration",
o = ni((n) => {
let a = {
index: 0,
unfilteredIndex: 0,
initialPush: t,
replayDoneKit: xt(),
};
return (n.getLength() === 0 && a.replayDoneKit.resolve(void 0), a);
});
return e.exoClass(
"LogStore",
fD,
() => ({
mapStore: e
.detached()
.mapStore("logMapStore", {
keyShape: s.number(),
valueShape: Bo,
}),
}),
{
reset() {
let { self: n } = this;
o.resetFor(n);
},
dispose() {
let { state: n, self: a } = this,
{ mapStore: i } = n;
(o.resetFor(a), i.clear());
},
getUnfilteredIndex() {
let { self: n } = this;
return o.for(n).unfilteredIndex;
},
getIndex() {
let { self: n } = this;
return o.for(n).index;
},
getLength() {
let { state: n } = this,
{ mapStore: a } = n;
return a.getSize();
},
isReplaying() {
let { state: n, self: a } = this,
{ mapStore: i } = n;
return o.for(a).unfilteredIndex < i.getSize();
},
peekEntry() {
let { state: n, self: a } = this,
{ mapStore: i } = n,
c = o.for(a);
return (
a.isReplaying() ||
f`No longer replaying: ${x(c.unfilteredIndex)} vs ${x(i.getSize())}`,
i.get(c.unfilteredIndex)
);
},
nextUnfilteredEntry() {
let { self: n } = this,
a = o.for(n),
i = n.peekEntry();
return (
(a.unfilteredIndex += 1),
r(i) && (a.index += 1),
n.isReplaying() || a.replayDoneKit.resolve(void 0),
i
);
},
nextEntry() {
let { self: n } = this,
a = n.nextUnfilteredEntry();
for (; !r(a); )
(n.isReplaying() || f`Unexpected entry at log tail: ${a}`,
(a = n.nextUnfilteredEntry()));
return a;
},
pushEntry(n) {
let { state: a, self: i } = this,
{ mapStore: c } = a,
d = o.for(i);
!i.isReplaying() ||
f`still replaying: ${x(d.unfilteredIndex)} vs ${x(c.getSize())}`;
let l = (u) => {
(d.unfilteredIndex === c.getSize() ||
f`internal: unfilteredIndex confusion ${x(d.unfilteredIndex)} vs ${x(c.getSize())}`,
c.init(d.unfilteredIndex, u),
(d.unfilteredIndex += 1),
r(u) && (d.index += 1),
d.unfilteredIndex === c.getSize() ||
f`internal: unfilteredIndex confusion ${x(d.unfilteredIndex)} vs ${x(c.getSize())}`);
};
if (d.initialPush) {
let u = d.initialPush;
d.initialPush = void 0;
for (let p of u) l(p);
}
return (l(n), d.unfilteredIndex);
},
dumpUnfiltered() {
let { state: n } = this,
{ mapStore: a } = n,
i = a.getSize(),
c = [];
for (let d = 0; d < i; d += 1) c.push(a.get(d));
return harden(c);
},
dump() {
let { self: n } = this;
return harden(n.dumpUnfiltered().filter(r));
},
promiseReplayDone() {
let { self: n } = this;
return o.for(n).replayDoneKit.promise;
},
},
);
};
var gD = s.interface("Bijection", {
reset: s.call().returns(),
unwrapInit: s.call(s.raw(), s.any()).returns(s.raw()),
hasGuest: s.call(s.raw()).returns(s.boolean()),
hasHost: s.call(s.any()).returns(s.boolean()),
has: s.call(s.raw(), s.any()).returns(s.boolean()),
guestToHost: s.call(s.raw()).returns(s.any()),
hostToGuest: s.call(s.any()).returns(s.raw()),
}),
Uy = (e) => (or(e) ? ht(e) : e),
wA = (e) => {
let t = new Map();
return se(e, {
init: (r, o) => {
let n = Uy(r);
(!t.has(n) ||
f`${tt(e)} key already bound: ${r} -> ${t.get(n)} vs ${o}`,
t.set(n, o));
},
has: (r) => t.has(Uy(r)),
get: (r) => {
let o = Uy(r);
return (t.has(o) || f`${tt(e)} key not found: ${r}`, t.get(o));
},
});
},
Cy = (e, t = (r, o) => o) => {
let r = ni(() => wA("guestToHost")),
o = ni(() => wA("hostToGuest"));
return e.exoClass("Bijection", gD, () => ({}), {
reset() {
let { self: n } = this;
(r.resetFor(n), o.resetFor(n));
},
unwrapInit(n, a) {
harden(n);
let { self: i } = this,
c = r.for(i),
d = o.for(i),
l = t(a, n);
return (
!d.has(a) ||
f`hostToGuest key already bound: ${a} -> ${d.get(a)} vs ${l}`,
c.init(l, a),
d.init(a, l),
i.has(l, a) || f`internal: ${n} <-> ${a}`,
n !== l &&
(!c.has(n) || f`hidden guest wrapper already bound ${n}`,
c.init(n, a)),
l
);
},
hasGuest(n) {
harden(n);
let { self: a } = this;
return r.for(a).has(n);
},
hasHost(n) {
let { self: a } = this;
return o.for(a).has(n);
},
has(n, a) {
harden(n);
let { self: i } = this,
c = r.for(i),
d = o.for(i);
return c.has(n)
? (ht(c.get(n)) === ht(a) ||
f`internal: g->h ${n} -> ${a} vs ${c.get(n)}`,
d.get(a) === n || f`internal h->g: ${a} -> ${n} vs ${d.get(a)}`,
!0)
: (!d.has(a) || f`internal: unexpected h->g ${a} -> ${d.get(a)}`,
!1);
},
guestToHost(n) {
harden(n);
let { self: a } = this;
return r.for(a).get(n);
},
hostToGuest(n) {
let { self: a } = this;
return o.for(a).get(n);
},
});
};
harden(Cy);
var {
getOwnPropertyDescriptor: hD,
getOwnPropertyDescriptors: bD,
create: vD,
fromEntries: IA,
entries: TA,
prototype: SD,
} = Object,
{ ownKeys: PA } = Reflect,
xD = s.interface("FunctionWrapper", {
apply: s.call(s.array()).returns(s.any()),
}),
AD = s.interface("StateAccessor", {
get: s.call(oi).returns(s.any()),
set: s.call(oi, s.any()).returns(),
}),
kA = s.interface("Unwrapper", {
unwrap: s.call(s.remotable("guestWrapped")).returns(s.raw()),
}),
wD = (e) => {
let t = e[us](),
r = (o) =>
TA({
[o](...n) {
return e[o](...n);
},
})[0];
return IA(t.map(r));
},
Ry = (e, t = {}) => {
let { vowTools: r = Fn(e) } = t,
{ makeVowKit: o } = r,
n = e.exo("FunctionUnwrapper", kA, {
unwrap(b) {
return se("UnwrappedFunction", (...m) => b.apply(m));
},
}),
a = e.exoClass("StateUnwrapper", kA, (b) => ({ keys: b }), {
unwrap(b) {
let { state: m } = this,
{ keys: v } = m;
return harden(
vD(
SD,
IA(
v.flatMap((h) =>
TA(
bD({
get [h]() {
return b.get(h);
},
set [h](g) {
b.set(h, g);
},
}),
),
),
),
),
);
},
}),
i = (b) => {
if ((harden(b), rr(b))) return "promise";
if (e.isStorable(b)) return "storable";
if (or(b) && Ki(b)) return "far";
if (typeof b == "function") return "function";
if (typeof b == "object") {
if (b === null) throw f`internal: null is always storable`;
if (Array.isArray(b)) return "array";
let m = PA(b);
m.length >= 1 || f`empty record should be storable ${b}`;
let v = hD(b, m[0]);
return "value" in v
? "record"
: ("get" in v || f`internal: unexpected descriptor ${v}`,
"state");
} else throw f`unexpected endowment ${b}`;
};
harden(i);
let c = e.weakMapStore("unwrapMap", {
keyShape: s.remotable("wrapped"),
valueShape: s.remotable("unwrapper"),
}),
d = (b) => (cr(b) || Ki(b) ? c.has(ht(b)) : !1),
l = (b) => c.get(ht(b)),
u = (b, m) => {
let v = ht(b);
d(b) ? c.set(v, m) : c.init(v, m);
},
p = (b, m, v) => {
switch (i(v)) {
case "promise": {
let g = v,
{ vow: S, resolver: w } = o();
return (
O.when(
g,
(I) => {
w.resolve(I);
},
(I) => {
Bn(I) || w.reject(I);
},
),
S
);
}
case "storable":
return v;
case "far": {
let S = wD(v);
return b.exo(
m,
s.interface("FarWrapped", {}, { defaultGuards: "raw" }),
S,
);
}
case "function": {
let g = v,
S = b.exo(m, xD, {
apply(w) {
return g(...w);
},
});
return (u(S, n), S);
}
case "array": {
let g = v,
S = b.subZone(m);
return g.map((w, I) => p(S, `${I}`, w));
}
case "record": {
let g = v,
S = b.subZone(m);
return Ne(g, (w, I) => p(S, String(I), w));
}
case "state": {
let g = v,
S = harden(PA(g)),
w = b.exo(m, AD, {
get(E) {
return g[E];
},
set(E, K) {
g[E] = K;
},
}),
I = a(S);
return (u(w, I), w);
}
default:
throw f`unexpected endowment ${v}`;
}
},
y = (b, m) => (d(b) ? l(b).unwrap(m) : m);
return harden({ prepareEndowment: p, unwrap: y });
};
harden(Ry);
var { defineProperties: PD } = Object,
kD = harden({
flow: s.interface("Flow", {
getFlowState: s.call().returns(xA),
restart: s.call().optional(s.boolean()).returns(),
wake: s.call().returns(),
getOutcome: s.call().returns(le),
dump: s.call().returns(s.arrayOf(Bo)),
getOptFatalProblem: s.call().returns(s.opt(s.error())),
}),
admin: s.interface("FlowAdmin", {
reset: s.call().returns(),
complete: s.call().returns(),
panic: s.call(s.error()).returns(s.not(s.any())),
}),
wakeWatcher: Po,
}),
ID = s.interface("AsyncFlowAdmin", {
getFailures: s
.call()
.returns(s.mapOf(s.remotable("asyncFlow"), s.error())),
wakeAll: s.call().returns(),
getFlowForOutcomeVow: s.call(le).returns(s.opt(s.remotable("flow"))),
}),
Oy = (e, t = {}) => {
let {
vowTools: r = Fn(e),
makeLogStore: o = AA(e),
endowmentTools: { prepareEndowment: n, unwrap: a } = Ry(e, {
vowTools: r,
}),
makeBijection: i = Cy(e, a),
panicHandler: c = (K) => {
throw K;
},
} = t,
{ watch: d, makeVowKit: l } = r,
u = e.mapStore("asyncFuncFailures", {
keyShape: s.remotable("flow"),
valueShape: s.error(),
}),
p = e.setStore("asyncFuncEagerWakers", {
keyShape: s.remotable("flow"),
}),
y = vs("membraneFor", {
keyShape: s.remotable("flow"),
valueShape: s.remotable("membrane"),
}),
b = (K) => y.has(K),
m = (K) => y.get(K),
v = (K, J) => y.init(K, J),
h = (K) => y.delete(K),
g = e.mapStore("flowForOutcomeVow", {
keyShape: s.remotable("toPassableCap"),
valueShape: s.remotable("flow"),
}),
S = (K, J, P, k = {}) => {
typeof P == "function" ||
f`guestAsyncFunc must be a callable function ${P}`;
let { startEager: U = !0 } = k,
D = K.exoClassKit(
J,
kD,
(T) => {
harden(T);
let R = o(),
N = i();
return {
activationArgs: T,
log: R,
bijection: N,
outcomeKit: l(),
isDone: !1,
};
},
{
flow: {
getFlowState() {
let { state: T, facets: R } = this,
{ log: N, outcomeKit: F, isDone: H } = T,
{ flow: q } = R;
return H
? (!b(q) ||
f`Done flow must drop membrane ${q} ${m(q)}`,
!u.has(q) ||
f`Done flow must not be in failures ${q} ${u.get(q)}`,
!p.has(q) ||
f`Done flow must not be in eagerWakers ${q}`,
!g.has(F.vow) ||
f`Done flow must drop flow lookup from vow ${F.vow}`,
(N.getIndex() === 0 && N.getLength() === 0) ||
f`Done flow must empty log ${q} ${N}`,
"Done")
: u.has(q)
? "Failed"
: b(q)
? N.isReplaying()
? "Replaying"
: "Running"
: (N.getIndex() === 0 ||
f`Sleeping flow must play from log start ${q} ${N.getIndex()}`,
"Sleeping");
},
restart(T = U) {
let { state: R, facets: N } = this,
{
activationArgs: F,
log: H,
bijection: q,
outcomeKit: ne,
} = R,
{ flow: ee, admin: Q, wakeWatcher: L } = N;
(ee.getFlowState() !== "Done" ||
f`Cannot restart a done flow ${ee}`,
Q.reset(),
T ? p.add(ee) : p.has(ee) && p.delete(ee));
let Y = (ie) => {
(K.isStorable(ie) ||
f`vowish must be storable in this zone (usually, must be durable): ${ie}`,
K.isStorable(L) ||
f`wakeWatcher must be storable in this zone (usually, must be durable): ${L}`,
d(ie, L));
},
j = (ie) => Q.panic(ie),
X = Ty({
log: H,
bijection: q,
vowTools: r,
watchWake: Y,
panic: j,
});
v(ee, X);
let z = X.hostToGuest(F),
te = ee.getFlowState();
(te === "Running" ||
te === "Replaying" ||
f`Restarted flow must be Running or Replaying ${ee}`,
X.wake());
let oe = (async () => P(...z))();
if (ee.getFlowState() !== "Failed") {
let ie = q.unwrapInit(oe, ne.vow);
ie === oe ||
f`internal: promises should not be unwrapped ${ie}`;
}
O.when(
oe,
(ie) => {
q.hasGuest(oe) &&
(!H.isReplaying() ||
j(
Se(
V`guest fulfilled with ${ie} before finishing replay`,
),
),
ne.resolver.resolve(X.guestToHost(ie)),
Q.complete());
},
(ie) => {
q.hasGuest(oe) &&
(!H.isReplaying() ||
j(
Se(
V`guest rejected with ${ie} before finishing replay`,
),
),
ne.resolver.reject(X.guestToHost(ie)),
Q.complete());
},
)
.then(
() => {
if (ee.getFlowState() === "Failed")
throw ee.getOptFatalProblem();
},
(ie) => {
if (ee.getFlowState() === "Failed")
throw ee.getOptFatalProblem();
let ue = Se(
V`internal: unexpected error in guest completion handling ${ie}`,
);
try {
j(ue);
} catch {
throw ue;
}
},
)
.catch(c);
},
wake() {
let { facets: T } = this,
{ flow: R } = T,
N = R.getFlowState();
switch (N) {
case "Done":
case "Failed":
return;
case "Running":
case "Replaying": {
m(R).wake();
return;
}
case "Sleeping": {
R.restart();
return;
}
default:
throw f`unexpected flowState ${x(N)}`;
}
},
getOutcome() {
let { state: T } = this,
{ outcomeKit: R } = T;
return R.vow;
},
dump() {
let { state: T } = this,
{ log: R } = T;
return R.dump();
},
getOptFatalProblem() {
let { facets: T } = this,
{ flow: R } = T;
return u.has(R) ? u.get(R) : void 0;
},
},
admin: {
reset() {
let { state: T, facets: R } = this,
{ bijection: N, log: F } = T,
{ flow: H } = R;
(!T.isDone || f`Cannot reset a done flow`,
u.has(H) && u.delete(H),
b(H) && (m(H).stop(), h(H)),
F.reset(),
N.reset());
},
complete() {
let { state: T, facets: R } = this,
{ log: N } = T,
{ flow: F, admin: H } = R;
(H.reset(),
p.has(F) && p.delete(F),
g.delete(ht(F.getOutcome())),
(T.isDone = !0),
N.dispose(),
F.getFlowState() === "Done" ||
f`Complete flow must be Done ${F}`);
},
panic(T) {
let { state: R, facets: N } = this,
{ bijection: F, log: H } = R,
{ flow: q } = N;
if (u.has(q)) {
let ee = u.get(q);
(Ze(ee, V`doubly failed somehow with ${T}`), (T = ee));
} else u.init(q, T);
(b(q) && (m(q).stop(), h(q)),
H.reset(),
F.reset(),
q.getFlowState() === "Failed" ||
f`Panicked flow must be Failed ${q}`);
let ne = Se(
V`In a Failed state: see getFailures() or getOptFatalProblem() for more information`,
);
throw (Ze(ne, V`due to ${T}`), ne);
},
},
wakeWatcher: {
onFulfilled(T) {
let { facets: R } = this;
R.flow.wake();
},
onRejected(T) {
let { facets: R } = this;
R.flow.wake();
},
},
},
),
_ = (T) => {
let R = D(T),
{ flow: N } = R,
F = N.getOutcome();
return (g.init(ht(F), N), N.restart(), R);
};
return harden(_);
},
w = (K, J, P, k = void 0) => {
let U = S(K, J, P, k),
D = `${J}_hostFlow`,
_ = {
[D](...T) {
let { flow: R } = U(T);
return R.getOutcome();
},
}[D];
return (PD(_, { length: { value: P.length } }), harden(_));
},
I = e.exo("AdminAsyncFlow", ID, {
getFailures() {
return u.snapshot();
},
wakeAll() {
let K = [...u.keys()],
J = [...p.keys()];
for (let P of K) P.restart();
for (let P of J) P.wake();
},
getFlowForOutcomeVow(K) {
return g.get(ht(K));
},
}),
E = O.when(null, () => I.wakeAll());
return harden({
prepareAsyncFlowKit: S,
asyncFlow: w,
adminAsyncFlow: I,
allWokenP: E,
prepareEndowment: n,
});
};
harden(Oy);
var { Error: CA, TypeError: TD, WeakMap: UD } = globalThis,
{ parse: CD, stringify: RD } = JSON,
{ isSafeInteger: OD } = Number,
{ freeze: tn } = Object,
{ toStringTag: ED } = Symbol,
RA = Symbol("UNKNOWN_KEY"),
OA = (e, t) => {
let r = RD(e);
return CD(r, t);
},
DD = (e, t) => tn(t),
ND = (e) => OA(e, DD),
BD = (e, t, r) => {
let o = e?.next,
n = { id: t, next: o, prev: e, data: r };
return ((e.next = n), (o.prev = n), n);
},
Ey = (e, t, r = t.next) => {
if (e === t || e === r) return;
let { prev: o, next: n } = e;
((o.next = n),
(n.prev = o),
(e.prev = t),
(e.next = r),
(t.next = e),
(r.prev = e));
},
UA = (e, t, r) => {
if (t !== RA) {
e.data.delete(t);
return;
}
if (e.data.clear) {
e.data.clear();
return;
}
if (!r) throw CA("internal: makeMap is required with UNKNOWN_KEY");
e.data = r();
},
MD = tn({ totalQueryCount: 0, totalHitCount: 0 }),
fu = (e, t = {}) => {
if (!OD(e) || e < 0)
throw TD(
"capacity must be a non-negative safe integer number <= 2**53 - 1",
);
let r = ((h) => {
try {
return (h(), h);
} catch {
return () => new h();
}
})(t.makeMap ?? UD),
o = r().clear === void 0 ? "WeakCacheMap" : "CacheMap",
n = r(),
a = {
id: 0,
next: void 0,
prev: void 0,
data: {
has: () => {
throw CA("internal: sentinel head cell has no data");
},
},
};
((a.next = a), (a.prev = a));
let i = 0,
c = OA(MD),
d = () => ND(c),
l = (h) => {
c.totalQueryCount += 1;
let g = n.get(h);
if (g?.data.has(h)) return ((c.totalHitCount += 1), Ey(g, a), g);
},
u = (h) => l(h) !== void 0;
tn(u);
let p = (h) => l(h)?.data.get(h);
tn(p);
let y = (h, g) => {
let S = l(h);
return S
? (S.data.set(h, g), m)
: (i < e
? ((S = BD(a, i + 1, r())), (i += 1), S.data.set(h, g))
: e > 0 &&
((S = a.prev), UA(S, RA, r), S.data.set(h, g), Ey(S, a)),
S && n.set(h, S),
m);
};
tn(y);
let { delete: b } = {
delete: (h) => {
let g = n.get(h);
return g?.data.has(h)
? (Ey(g, a.prev), UA(g, h), n.delete(h), !0)
: (n.delete(h), !1);
},
};
tn(b);
let m = { has: u, get: p, set: y, delete: b, [ED]: o };
return (tn(m), tn({ cache: m, getMetrics: d }));
};
tn(fu);
var EA = "Alleged: ",
$D = "SEVERED: ",
DA = (e) => (
typeof e == "string" && e.startsWith(EA) && (e = e.slice(EA.length)),
se(`${$D}${e}`, {})
);
var Rs = class {
#e;
[Symbol.toStringTag] = "Alleged: SlotWrapper";
constructor(t, r) {
(r == null || r === "Remotable"
? (r = "Remotable")
: r.startsWith("Alleged: ") || (r = `Alleged: ${r}`),
(this.#e = t),
(this[Symbol.toStringTag] = r));
}
static getSlot(t) {
return t.#e;
}
};
Object.defineProperties(Rs.prototype, {
[ct]: { value: "remotable" },
[Symbol.toStringTag]: { value: "Alleged: SlotWrapper" },
});
Reflect.deleteProperty(Rs.prototype, "constructor");
harden(Rs);
var NA = (e, t) => harden(new Rs(e, t)),
_D = Rs.getSlot,
FD = 50,
BA = (e) => fu(FD, { makeMap: e ? WeakMap : Map }).cache,
KD = (
e,
{
serializeBodyFormat: t = "smallcaps",
errorTagging: r = "off",
...o
} = {},
{
valToSlot: n = BA(!0),
slotToVal: a = BA(!1),
cacheSeveredVal: i = !1,
} = {},
) => {
let c = harden({ serializeBodyFormat: t, errorTagging: r, ...o }),
d = At(void 0, (S, w) => S ?? DA(w), c),
l = new Map(),
u = _D,
y = At(
u,
(S, w) => {
if (S == null) return NA(S, w);
let I = l.get(S);
return (I || ((I = NA(S, w)), l.set(S, I)), I);
},
c,
),
b = async (S, w) => {
let I = !1,
{ length: E } = S,
K = Array.from({ length: E }),
J = Array.from({ length: E });
for (let [P, k] of S.entries())
if (k === null) {
let U = k;
((K[P] = U), (J[P] = U));
} else if (k !== void 0) {
let U = a?.get(k);
U !== void 0
? (n?.set(U, k), (J[P] = U))
: ((I = !0), (K[P] = w(P)));
}
if ((await null, I)) {
harden(K);
let P = y.toCapData(K),
k = await O(e).fromCapData(P);
for (let [U, D] of k.entries())
if (D != null) {
let _ = S[U];
(a?.set(_, D), n?.set(D, _), (J[U] = D));
} else if (J[U] === void 0) {
let _ = S[U];
console.warn(
"\u26A0\uFE0F Unresolved local slot in wrapped marshaller",
{ index: U, slot: _ },
);
}
}
return harden(J);
},
m = async (S) => {
if (S.length === 0) return S;
let w = !1,
{ length: I } = S,
E = Array.from({ length: I }),
K = Array.from({ length: I });
for (let [J, P] of S.entries())
if (P === null) {
let k = P;
((K[J] = k), (E[J] = k));
} else if (P !== void 0) {
let k = n?.get(P);
k !== void 0
? (k !== null && a?.set(k, P), (E[J] = k))
: ((w = !0), (K[J] = P));
}
if ((await null, w)) {
let J = await O(e).toCapData(K);
try {
let P = y.fromCapData(J);
for (let [k, U] of P.entries())
if (U != null) {
let D = u(U),
_ = S[k];
((E[k] = D),
D != null && a?.set(D, _),
(D != null || i) && n?.set(_, D));
} else if (E[k] === void 0) {
let D = S[k];
console.warn(
"\u26A0\uFE0F Unresolved local slot in wrapped marshaller",
{ index: k, cap: D },
);
}
} finally {
l.clear();
}
}
return harden(E);
},
v = (S) => {
let { slots: w } = S;
return (E) => {
let K = w[E],
J = l.get(K);
if ((J || y.fromCapData(S), (J = l.get(K)), !J))
throw f`Marshaller didn't create wrapper for slot ${x(K)} (index=${x(E)})`;
return J;
};
},
h = async (S) => {
let w = d.toCapData(S),
I = await m(w.slots);
return harden({ ...w, slots: I });
},
g = async (S) => {
let w = v(S);
await null;
try {
let I = await b(S.slots, w);
return d.fromCapData({ ...S, slots: I });
} finally {
l.clear();
}
};
return se("wrapped remote marshaller", {
toCapData: h,
fromCapData: g,
serialize: h,
unserialize: g,
});
};
var MA = KD;
var $A = (e, t) =>
Sc(
e,
"Recorder",
s.interface("Recorder", {
getStorageNode: s.call().returns(ES),
getStoragePath: s.call().returns(s.promise()),
write: s.call(s.any()).returns(s.promise()),
writeFinal: s.call(s.any()).returns(s.promise()),
}),
(o, n, a = s.any()) => ({
closed: !1,
publisher: o,
storageNode: n,
storagePath: void 0,
valueShape: a,
}),
{
getStorageNode() {
return this.state.storageNode;
},
async getStoragePath() {
let { storagePath: o } = this.state;
if ((await null, o !== void 0)) return o;
let n = await O(this.state.storageNode).getPath();
return ((this.state.storagePath = n), n);
},
async write(o) {
let {
closed: n,
publisher: a,
storageNode: i,
valueShape: c,
} = this.state;
(!n || f`cannot write to closed recorder`, Kt(o, c));
let d = await O(t).toCapData(o),
l = JSON.stringify(d);
return (await O(i).setValue(l), a.publish(o));
},
async writeFinal(o) {
let {
closed: n,
publisher: a,
storageNode: i,
valueShape: c,
} = this.state;
(!n || f`cannot write to closed recorder`, Kt(o, c));
let d = await O(t).toCapData(o),
l = JSON.stringify(d);
return (
await O(i).setValue(l),
(this.state.closed = !0),
a.finish(o)
);
},
},
);
harden($A);
var JD =
({ makeRecorder: e, makeDurablePublishKit: t }) =>
(o, n) => {
let { subscriber: a, publisher: i } = t(),
c = e(i, o, n);
return harden({ subscriber: a, recorder: c });
},
_A =
({ makeRecorder: e, makeDurablePublishKit: t }) =>
(o, n) => {
let { publisher: a, subscriber: i } = t(),
c = O.when(o, (d) => e(a, d, n));
return { subscriber: i, recorderP: c };
};
harden(_A);
var FA = (e, t) => {
let r = Pl(e, "Durable Publish Kit"),
o = $A(e, t),
n = JD({ makeRecorder: o, makeDurablePublishKit: r }),
a = _A({ makeRecorder: o, makeDurablePublishKit: r });
return {
makeDurablePublishKit: r,
makeRecorder: o,
makeRecorderKit: n,
makeERecorderKit: a,
};
},
VD = { recorder: s.remotable(), subscriber: s.remotable() };
harden(VD);
var si = (e) => `${e.namespace}:${e.reference}`;
var HD = "pfm",
ai = {
Chain: "chain",
ChainAssets: "chainAssets",
ChainConnection: "chainConnection",
};
harden(ai);
var jY = ai.Chain,
GY = ai.ChainConnection,
QY = ai.ChainAssets,
yu = "_",
KA = (e) => e.replaceAll(yu, `${yu}${yu}`),
Os = (e, t) => {
let r = KA(e),
o = KA(t);
return [r, o].sort().join(yu);
},
HA = (e) => {
let { transferChannel: t } = e;
return harden({
id: e.counterparty.connection_id,
client_id: e.counterparty.client_id,
counterparty: { client_id: e.client_id, connection_id: e.id },
state: e.state,
transferChannel: {
...t,
channelId: t.counterPartyChannelId,
counterPartyChannelId: t.channelId,
portId: t.counterPartyPortId,
counterPartyPortId: t.portId,
},
});
},
JA = (e, t, r) => {
let o = Os(e, t);
return e < t ? [o, r] : [o, HA(r)];
},
Jc = (e, t, r) => (e < t ? r : HA(r)),
VA = s.or(
s.string(),
s.splitRecord({ chainId: s.string() }, void 0, s.any()),
),
WD = harden({ retries: 3, timeout: "10m" }),
Vc = s.splitRecord(
{
sourcePort: s.string(),
sourceChannel: jl,
token: Bc,
receiver: s.string(),
},
{ forwardInfo: ly },
{},
),
LD = s.interface("ChainHub", {
registerChain: s.call(s.string(), Oo).returns(),
updateChain: s.call(s.string(), Oo).returns(),
getChainInfo: s.call(s.string()).returns(le),
getChainInfoByChainId: s.call(s.string()).returns(Oo),
registerConnection: s.call(s.string(), s.string(), Ql).returns(),
updateConnection: s.call(s.string(), s.string(), Ql).returns(),
getConnectionInfo: s.call(VA, VA).returns(le),
getChainsAndConnection: s.call(s.string(), s.string()).returns(le),
registerAsset: s.call(s.string(), Zo).returns(),
updateAsset: s.call(s.string(), Zo).returns(),
getAsset: s
.call(s.string(), s.string())
.returns(s.or(Zo, s.undefined())),
getDenom: s.call(ot).returns(s.or(s.string(), s.undefined())),
coerceCosmosAddress: s.call(Ya).returns(je),
resolveAccountId: s.call(s.string()).returns(s.string()),
makeTransferRoute: s
.call(Ya, bt, s.string())
.optional(uy)
.returns(s.or(s.undefined(), Vc)),
isEmpty: s.call().returns(s.boolean()),
}),
WA = (e, t, r, { chainInfoValueShape: o = Oo } = {}) => {
let n = e.mapStore("chainInfos", {
keyShape: s.string(),
valueShape: o,
}),
a = e.mapStore("connectionInfos", {
keyShape: s.string(),
valueShape: Ql,
}),
i = e.mapStore("denom", { keyShape: s.string(), valueShape: Zo }),
c = e.mapStore("brandDenom", {
keyShape: ot,
valueShape: s.string(),
}),
d = e.mapStore("bech32PrefixToChainName", {
keyShape: s.string(),
valueShape: s.string(),
}),
l = e.mapStore("chainIdToChainName", {
keyShape: s.string(),
valueShape: s.string(),
}),
u = (h, g) => `${g}:${h}`,
p = (h) => {
let g = hx(h);
if (!d.has(g))
throw Se(`Chain info not found for bech32Prefix ${x(g)}`);
let S = d.get(g),
{ chainId: w } = n.get(S);
return w;
},
y = r.retryable(e, "lookupChainInfo", async (h) => {
await null;
try {
let g = await O(t).lookup(ai.Chain, h);
return (
n.has(h) ||
(n.init(h, g),
l.init(si(g), h),
g.bech32Prefix && d.init(g.bech32Prefix, h)),
g
);
} catch (g) {
throw (
console.error("lookupChainInfo", h, "error", g),
Se(`chain not found:${h}`)
);
}
}),
b = r.retryable(e, "lookupConnectionInfo", async (h, g) => {
await null;
let S = Os(h, g);
try {
let w = await O(t).lookup(ai.ChainConnection, S);
return (a.has(S) || a.init(S, w), Jc(h, g, w));
} catch (w) {
throw (
console.error("lookupConnectionInfo", h, g, "error", w),
Se(`connection not found: ${h}<->${g}`)
);
}
}),
m = r.retryable(e, "lookupChainsAndConnection", async (h, g) => {
let [S, w] = await r.asPromise(
r.allVows([v.getChainInfo(h), v.getChainInfo(g)]),
),
I =
S.namespace === "cosmos" && w.namespace === "cosmos"
? await r.asPromise(v.getConnectionInfo(S, w))
: void 0;
return [S, w, I];
}),
v = e.exo("ChainHub", LD, {
registerChain(h, g) {
(n.init(h, g),
l.init(si(g), h),
g.namespace === "cosmos" &&
g.bech32Prefix &&
d.init(g.bech32Prefix, h));
},
updateChain(h, g) {
if (!n.has(h)) throw Se(`Chain ${x(h)} not registered`);
let S = n.get(h);
(l.has(si(S)) && l.delete(si(S)),
S.bech32Prefix && d.delete(S.bech32Prefix),
n.set(h, g),
l.init(si(g), h),
g.bech32Prefix && d.init(g.bech32Prefix, h));
},
getChainInfo(h) {
return (
h.includes(":") &&
f`${h} must be a bare chain name. Maybe try getChainInfoByChainId()`,
n.has(h) ? r.asVow(() => n.get(h)) : y(h)
);
},
getChainInfoByChainId(h) {
l.has(h) || f`Chain name not found for ${x(h)}`;
let g = l.get(h);
return (
n.has(g) || f`Chain Info not found for ${x(h)}`,
n.get(g)
);
},
registerConnection(h, g, S) {
let [w, I] = JA(h, g, S);
a.init(w, I);
},
updateConnection(h, g, S) {
let w = Os(h, g);
if (!a.has(w))
throw Se(`Connection ${x(h)}<->${x(g)} not registered`);
let [I, E] = JA(h, g, S);
a.set(w, E);
},
getConnectionInfo(h, g) {
let S = typeof h == "string" ? h : h.chainId,
w = typeof g == "string" ? g : g.chainId,
I = Os(S, w);
return a.has(I) ? r.asVow(() => Jc(S, w, a.get(I))) : b(S, w);
},
getChainsAndConnection(h, g) {
return m(h, g);
},
registerAsset(h, g) {
let { chainName: S, baseName: w } = g;
(n.has(S) || f`must register chain ${x(S)} first`,
n.has(w) || f`must register chain ${x(w)} first`);
let I = u(h, g.chainName);
(i.has(I) && f`already registered ${x(h)} on ${x(S)}`,
i.init(I, g),
g.brand &&
(S === "agoric" ||
f`brands only registerable for agoric-held assets`,
c.init(g.brand, h)));
},
updateAsset(h, g) {
let { baseName: S, brand: w, chainName: I } = g,
E = u(h, I);
if (!i.has(E))
throw Se(`Asset ${x(h)} on ${x(I)} not registered`);
if (!n.has(I)) throw Se(`Chain ${x(I)} not registered`);
if (!n.has(S)) throw Se(`Chain ${x(S)} not registered`);
if (w && I !== "agoric")
throw Se("Brands only registerable for agoric-held assets");
let K = i.get(E);
(K.brand && c.delete(K.brand), i.set(E, g), w && c.init(w, h));
},
getAsset(h, g) {
let S = u(h, g);
if (i.has(S)) return i.get(S);
},
getDenom(h) {
if (c.has(h)) return c.get(h);
},
resolveAccountId(h) {
return h.split(":").length === 3 ? h : `cosmos:${p(h)}:${h}`;
},
coerceCosmosAddress(h) {
if (typeof h != "string") return h;
let g = h.split(":");
if (g.length === 3)
return (
assert.equal(g[0], "cosmos"),
harden({ chainId: g[1], encoding: "bech32", value: g[2] })
);
assert.equal(g.length, 1);
let S = h,
w = p(S);
return harden({ chainId: w, value: S, encoding: "bech32" });
},
makeTransferRoute(h, g, S, w) {
n.has(S) || f`chain info not found for holding chain: ${x(S)}`;
let I = v.getAsset(g.denom, S);
I ||
f`no denom detail for: ${x(g.denom)} on ${x(S)}. ensure it is registered in chainHub.`;
let { baseName: E, chainName: K } = I;
(K === S ||
f`cannot transfer asset ${x(g.denom)}. held on ${x(K)} not ${x(S)}.`,
n.has(E) || f`chain info not found for issuing chain: ${x(E)}`);
let J = n.get(E);
if (J.namespace !== "cosmos")
throw f`Only cosmos supported; got ${x(J.namespace)}`;
let { chainId: P, pfmEnabled: k } = J,
U = n.get(S);
if (U.namespace !== "cosmos")
throw f`Only cosmos supported; got ${x(U.namespace)}`;
let { chainId: D } = U,
_ = v.coerceCosmosAddress(h);
if (P === _.chainId || E === S) {
let ee = Os(D, _.chainId);
a.has(ee) ||
f`no connection info found for ${D}<->${_.chainId}`;
let { transferChannel: Q } = Jc(D, _.chainId, a.get(ee));
return harden({
sourcePort: Q.portId,
sourceChannel: Q.channelId,
token: { amount: String(g.value), denom: g.denom },
receiver: _.value,
});
}
k || f`pfm not enabled on issuing chain: ${x(E)}`;
let T = Os(D, P);
a.has(T) || f`no connection info found for ${D}<->${P}`;
let R = Os(P, _.chainId);
a.has(R) || f`no connection info found for ${P}<->${_.chainId}`;
let N = Jc(D, P, a.get(T)),
F = Jc(P, _.chainId, a.get(R)),
{ intermediateRecipient: H, ...q } = w ?? {},
ne = harden({
forward: {
receiver: _.value,
port: F.transferChannel.portId,
channel: F.transferChannel.channelId,
...WD,
...q,
},
});
return harden({
sourcePort: N.transferChannel.portId,
sourceChannel: N.transferChannel.channelId,
token: { amount: String(g.value), denom: g.denom },
receiver: H?.value || HD,
forwardInfo: ne,
});
},
isEmpty() {
return (
n.getSize() === 0 && a.getSize() === 0 && i.getSize() === 0
);
},
});
return v;
};
var gu = (e, t) => {
if (typeof t == "string") return t;
let r = e.getDenom(t);
if (!r) throw Se(`No denom for brand ${t}`);
return r;
},
LA = (e, t) => {
if ("denom" in t) return t;
let r = gu(e, t.brand);
return harden({ denom: r, value: t.value });
},
Es = (e, t) => {
let r = "denom" in t ? t.denom : gu(e, t.brand);
return harden({ denom: r, amount: String(t.value) });
};
var qD = ((e) => (
(e[(e.SIGNED_MSG_TYPE_UNKNOWN = 0)] = "SIGNED_MSG_TYPE_UNKNOWN"),
(e[(e.SIGNED_MSG_TYPE_PREVOTE = 1)] = "SIGNED_MSG_TYPE_PREVOTE"),
(e[(e.SIGNED_MSG_TYPE_PRECOMMIT = 2)] = "SIGNED_MSG_TYPE_PRECOMMIT"),
(e[(e.SIGNED_MSG_TYPE_PROPOSAL = 32)] = "SIGNED_MSG_TYPE_PROPOSAL"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(qD || {});
function qA() {
return { msgType: "", data: new Uint8Array() };
}
var Er = {
typeUrl: "/cosmos.base.abci.v1beta1.MsgData",
aminoType: "cosmos-sdk/MsgData",
is(e) {
return (
e &&
(e.$typeUrl === Er.typeUrl ||
(typeof e.msgType == "string" &&
(e.data instanceof Uint8Array || typeof e.data == "string")))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Er.typeUrl ||
(typeof e.msg_type == "string" &&
(e.data instanceof Uint8Array || typeof e.data == "string")))
);
},
encode(e, t = re.create()) {
return (
e.msgType !== "" && t.uint32(10).string(e.msgType),
e.data.length !== 0 && t.uint32(18).bytes(e.data),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = qA();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.msgType = r.string();
break;
case 2:
n.data = r.bytes();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
msgType: B(e.msgType) ? String(e.msgType) : "",
data: B(e.data) ? ke(e.data) : new Uint8Array(),
};
},
toJSON(e) {
let t = {};
return (
e.msgType !== void 0 && (t.msgType = e.msgType),
e.data !== void 0 &&
(t.data = Ee(e.data !== void 0 ? e.data : new Uint8Array())),
t
);
},
fromPartial(e) {
let t = qA();
return (
(t.msgType = e.msgType ?? ""),
(t.data = e.data ?? new Uint8Array()),
t
);
},
fromProtoMsg(e) {
return Er.decode(e.value);
},
toProto(e) {
return Er.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.base.abci.v1beta1.MsgData",
value: Er.encode(e).finish(),
};
},
};
function jA() {
return { data: [], msgResponses: [] };
}
var Ds = {
typeUrl: "/cosmos.base.abci.v1beta1.TxMsgData",
aminoType: "cosmos-sdk/TxMsgData",
is(e) {
return (
e &&
(e.$typeUrl === Ds.typeUrl ||
(Array.isArray(e.data) &&
(!e.data.length || Er.is(e.data[0])) &&
Array.isArray(e.msgResponses) &&
(!e.msgResponses.length || fe.is(e.msgResponses[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ds.typeUrl ||
(Array.isArray(e.data) &&
(!e.data.length || Er.isSDK(e.data[0])) &&
Array.isArray(e.msg_responses) &&
(!e.msg_responses.length || fe.isSDK(e.msg_responses[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.data) Er.encode(r, t.uint32(10).fork()).ldelim();
for (let r of e.msgResponses)
fe.encode(r, t.uint32(18).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = jA();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.data.push(Er.decode(r, r.uint32()));
break;
case 2:
n.msgResponses.push(fe.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
data: Array.isArray(e?.data) ? e.data.map((t) => Er.fromJSON(t)) : [],
msgResponses: Array.isArray(e?.msgResponses)
? e.msgResponses.map((t) => fe.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.data
? (t.data = e.data.map((r) => (r ? Er.toJSON(r) : void 0)))
: (t.data = []),
e.msgResponses
? (t.msgResponses = e.msgResponses.map((r) =>
r ? fe.toJSON(r) : void 0,
))
: (t.msgResponses = []),
t
);
},
fromPartial(e) {
let t = jA();
return (
(t.data = e.data?.map((r) => Er.fromPartial(r)) || []),
(t.msgResponses =
e.msgResponses?.map((r) => fe.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return Ds.decode(e.value);
},
toProto(e) {
return Ds.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.base.abci.v1beta1.TxMsgData",
value: Ds.encode(e).finish(),
};
},
};
var GD = pe(Ds),
hu = 10n * 60n,
GA = (e, t) => {
try {
let { msgResponses: r } = GD.decode(ke(e));
return t.map(
(n, a) => (
(n.typeUrl && r[a].typeUrl === n.typeUrl) ||
assert.Fail`mismatched response type: expected ${n.typeUrl}, got ${r[a].typeUrl}`,
n.fromProtoMsg(r[a])
),
);
} catch (r) {
throw Se(`bad response: ${e}`, void 0, { cause: r });
}
};
var Wn = (e) => ({ denom: e.denom, value: BigInt(e.amount) }),
bu = (e) => ({ denom: e.denom, value: BigInt(e.amount.split(".")[0]) }),
Dy = (e, t) => ({
encoding: "bech32",
value: e.validatorAddress,
chainId: t,
}),
Ny = ({ chainId: e }, t) => ({
delegator: {
chainId: e,
encoding: "bech32",
value: t.delegation.delegatorAddress,
},
validator: Dy(t.delegation, e),
amount: Wn(t.balance),
});
var { Vow$: By } = dt,
ii = (e) => s.or(By(e), s.promise()),
ci = ({ watch: e }) => {
let t = {
helper: {
pickVowProp(r, o) {
return e(r, this.facets.pickDataWatcher, o);
},
pickVowIndex(r, o) {
return e(r, this.facets.pickDataWatcher, o);
},
overrideVow(r, o) {
return e(r, this.facets.overrideVowWatcher, o);
},
voidVow(r) {
return e(r, this.facets.overrideVowWatcher);
},
},
helperShapes: {
pickVowIndex: s
.call(By(s.array()), s.number())
.returns(ii(s.any())),
pickVowProp: s
.call(By(s.record()), s.or(s.string(), s.number()))
.returns(ii(s.any())),
voidVow: s.call(ii(s.any())).returns(ii(s.undefined())),
overrideVow: s
.call(ii(s.any()))
.optional(s.any())
.returns(ii(s.any())),
},
watchers: {
pickDataWatcher: {
onFulfilled(r, o) {
return harden(r[o]);
},
},
overrideVowWatcher: {
onFulfilled(r, o) {
return o;
},
},
},
watcherShapes: {
pickDataWatcher: s.interface("pickArrayDataWatcher", {
onFulfilled: s
.call(s.or(s.array(), s.record()), s.or(s.number(), s.string()))
.returns(s.any()),
}),
overrideVowWatcher: s.interface("overrideVowWatcher", {
onFulfilled: s.call(s.any()).optional(s.any()).returns(s.any()),
}),
},
makeTombstonedFacets: (r, o) =>
Object.fromEntries(
r.map((n) => [
n,
Object.fromEntries(
o.map((a) => [
a,
() => {
throw Error(
`${n} is retired. Retry your request to switch to a supported code path.`,
);
},
]),
),
]),
),
makeTombstonedFacetShapes: (r, o) =>
Object.fromEntries(
r.map((n) => [
n,
s.interface(
n,
Object.fromEntries(
o.map((a) => [a, s.call().rest(s.any()).returns()]),
),
),
]),
),
makeTombstonedWatchers: (r) =>
t.makeTombstonedFacets(r, ["onFulfilled"]),
makeTombstonedWatcherShapes: (r) =>
t.makeTombstonedFacetShapes(r, ["onFulfilled"]),
};
return t;
};
var QD = s.splitRecord(
{ subscriber: wc, storagePath: s.or(s.promise(), s.string()) },
{ description: s.string() },
),
My = s.recordOf(s.string(), QD);
var { Vow$: vu } = dt,
$y = s.splitRecord({ start: s.number(), end: s.number() });
harden($y);
var Su = {
getAddress: s.call().returns(je),
getBalance: s.call(s.or(ot, s.string())).returns(vu(bt)),
getBalances: s.call().returns(vu(s.arrayOf(bt))),
send: s.call(Ya, Jt).optional(s.record()).returns(le),
sendAll: s.call(je, s.arrayOf(Jt)).optional(s.record()).returns(le),
transfer: s.call(Ya, Jt).optional(Xo).returns(le),
transferSteps: s.call(Jt, s.any()).returns(le),
asContinuingOffer: s
.call()
.returns(
vu({
publicSubscribers: My,
invitationMakers: s.any(),
holder: s.remotable(),
}),
),
getPublicTopics: s.call().returns(vu(My)),
makeProgressTracker: s.call().returns(s.remotable("ProgressTracker")),
},
zD = (e, t, r) =>
harden([
{
op: "transfer",
src: [
"ibc",
["chain", e],
["port", r.portId],
["channel", r.channelId],
],
dst: [
"ibc",
["chain", t],
["port", r.counterPartyPortId],
["channel", r.counterPartyChannelId],
],
seq: { status: "pending" },
incomplete: !0,
},
]),
QA = (e, t) => {
let r = e.seq;
return (
Object(r)?.status === "pending" ||
f`expected entry.seq ${r} to be pending`,
t != null || f`expected sequence ${t} to be non-nullish`,
{ ...e, seq: t }
);
},
YD = (e, t) => {
e.length === 1 || f`expected single traffic entry to finish`;
let [{ incomplete: r, ...o }] = e;
return (
r || f`expected incomplete traffic entry`,
o.op === "transfer" ||
f`expected transfer traffic entry, got ${o.op}`,
o.src[0] === "ibc" ||
f`expected ibc source in transfer traffic entry`,
o.dst[0] === "ibc" || f`expected ibc dest in transfer traffic entry`,
harden([QA(o, t)])
);
},
ZD = (e) =>
harden([
{
op: "ICA",
src: ["ibc"],
dst: ["ibc", ["chain", e]],
seq: { status: "pending" },
incomplete: !0,
},
]),
XD = (e, t, r, o, n) => {
e.length === 1 || f`expected single traffic entry to finish`;
let [{ incomplete: a, ...i }] = e;
(a || f`expected incomplete traffic entry`,
i.op === "ICA" || f`expected ICA traffic entry`,
i.src.length === 1 ||
f`expected source length 1 in ICA traffic entry`,
i.src[0] === "ibc" || f`expected ibc source in ICA traffic entry`);
let c = [
...i.src,
["chain", t],
["port", r.portID],
["channel", r.channelID],
];
(i.dst.length === 2 || f`expected dest length 2 in ICA traffic entry`,
i.dst[0] === "ibc" || f`expected ibc dest in ICA traffic entry`);
let d = [...i.dst, ["port", o.portID], ["channel", o.channelID]];
return [QA({ ...i, src: c, dst: d }, n)];
},
Mo = {
IbcTransfer: { start: zD, finish: YD },
IbcICA: { start: ZD, finish: XD },
};
harden(Mo);
var di = (e, t) => {
let r = e ?? [],
o = r.length,
n = o + t.length;
return harden({ traffic: [...r, ...t], slice: { start: o, end: n } });
};
harden(di);
var li = (e, t, r) => {
let o = e ?? [],
n = t ?? { start: 0, end: o.length },
a = harden(o.slice(n.start, n.end));
a.length > 0 || f`no traffic entries to finish`;
let i = harden(r(a));
i.length === a.length ||
f`traffic entry transform must not change length; expected ${a.length}, got ${i.length}`;
let c = o.slice(0, n.start),
d = o.slice(n.end);
return harden([...c, ...i, ...d]);
};
harden(li);
var zA = s.remotable("TimerBrand"),
YA = s.nat(),
ZA = s.nat(),
Hc = { timerBrand: zA, absValue: YA };
harden(Hc);
var Wc = { timerBrand: zA, relValue: ZA };
harden(Wc);
var xu = s.or(Hc, YA),
cX = s.or(Wc, ZA),
dX = s.remotable("TimerService");
var _y = (e, t) =>
e === void 0
? t === void 0
? void 0
: t
: (t === void 0 ||
e === t ||
f`TimerBrands must match: ${x(e)} vs ${x(t)}`,
e),
Au = (e, t) => {
let r = typeof e == "bigint" ? void 0 : e.timerBrand,
o = typeof t == "bigint" ? void 0 : t.timerBrand;
return _y(r, o);
},
ew = (e, t, r) => {
Re(r);
let o = Au(e, t);
return o ? harden({ timerBrand: o, absValue: r }) : r;
},
Ln = (e, t, r) => {
Re(r);
let o = Au(e, t);
return o ? harden({ timerBrand: o, relValue: r }) : r;
},
$o = (e) =>
typeof e == "bigint" ? Re(e) : (Kt(e, Hc, "timestamp"), Re(e.absValue)),
Ct = (e) =>
typeof e == "bigint" ? Re(e) : (Kt(e, Wc, "relative"), Re(e.relValue)),
eN = (e, t) => harden({ absValue: e, timerBrand: t }),
tN = (e, t) => harden({ relValue: e, timerBrand: t }),
rN = (e, t) => {
if (
(t || f`must have a brand`,
typeof e == "number" && (e = Re(e)),
typeof e == "bigint")
)
return eN(e, t);
{
let { timerBrand: r } = e;
return (Kt(e, Hc, "timestamp"), _y(r, t), e);
}
},
oN = (e, t) => {
if (
(t || f`must have a brand`,
typeof e == "number" && (e = Re(e)),
typeof e == "bigint")
)
return tN(e, t);
{
let { timerBrand: r } = e;
return (Kt(e, Wc, "relativeTime"), _y(r, t), e);
}
},
nN = (e, t) => ew(e, t, $o(e) + Ct(t)),
sN = (e, t) => Ln(e, t, Ct(e) + Ct(t)),
aN = (e, t) => Ln(e, t, $o(e) - $o(t)),
iN = (e, t) => {
let r = $o(e),
o = $o(t);
return Ln(e, t, r > o ? r - o : 0n);
},
cN = (e, t) => ew(e, t, $o(e) - Ct(t)),
dN = (e, t) => Ln(e, t, Ct(e) - Ct(t)),
lN = (e) => Ct(e) === 0n,
uN = (e, t) => Ln(e, t, Ct(e) * t),
pN = (e, t) => Ln(e, t, Ct(e) / t),
mN = (e, t) => (Au(e, t), Ct(e) / Ct(t)),
fN = (e, t) => Ln(e, t, $o(e) % Ct(t)),
yN = (e, t) => Ln(e, t, Ct(e) % Ct(t)),
XA = (e, t, r, o) => (
Au(e, t),
r < o ? -1 : r === o ? 0 : (assert(r > o), 1)
),
Fy = harden({
absValue: $o,
relValue: Ct,
coerceTimestampRecord: rN,
coerceRelativeTimeRecord: oN,
addAbsRel: nN,
addRelRel: sN,
subtractAbsAbs: aN,
clampedSubtractAbsAbs: iN,
subtractAbsRel: cN,
subtractRelRel: dN,
isRelZero: lN,
multiplyRelNat: uN,
divideRelNat: pN,
divideRelRel: mN,
modAbsRel: fN,
modRelRel: yN,
compareAbs: (e, t) => XA(e, t, $o(e), $o(t)),
compareRel: (e, t) => XA(e, t, Ct(e), Ct(t)),
});
var gN = 60n;
var hN = 1000000000n;
function wu(e) {
let t = harden({
async getTimeoutTimestampNS(r = gN * 5n) {
let o = await O(e).getCurrentTimestamp(),
n = Fy.coerceRelativeTimeRecord(r, o.timerBrand);
return Fy.addAbsRel(o, n).absValue * hN;
},
vowOrValueFromOpts(r) {
return r && "timeoutTimestamp" in r
? r.timeoutTimestamp
: r && "timeoutHeight" in r
? 0n
: t.getTimeoutTimestampNS(
r && "timeoutRelativeSeconds" in r
? r.timeoutRelativeSeconds
: void 0,
);
},
});
return t;
}
function tw() {
return {
from: "",
amount: "",
destinationDomain: 0,
mintRecipient: new Uint8Array(),
burnToken: "",
};
}
var Ns = {
typeUrl: "/circle.cctp.v1.MsgDepositForBurn",
annotations: { "gogoproto.nullable": { amount: !1 } },
aminoType: "cctp/DepositForBurn",
is(e) {
return (
e &&
(e.$typeUrl === Ns.typeUrl ||
(typeof e.from == "string" &&
typeof e.amount == "string" &&
typeof e.destinationDomain == "number" &&
(e.mintRecipient instanceof Uint8Array ||
typeof e.mintRecipient == "string") &&
typeof e.burnToken == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ns.typeUrl ||
(typeof e.from == "string" &&
typeof e.amount == "string" &&
typeof e.destination_domain == "number" &&
(e.mint_recipient instanceof Uint8Array ||
typeof e.mint_recipient == "string") &&
typeof e.burn_token == "string"))
);
},
encode(e, t = re.create()) {
return (
e.from !== "" && t.uint32(10).string(e.from),
e.amount !== "" && t.uint32(18).string(e.amount),
e.destinationDomain !== 0 && t.uint32(24).uint32(e.destinationDomain),
e.mintRecipient.length !== 0 && t.uint32(34).bytes(e.mintRecipient),
e.burnToken !== "" && t.uint32(42).string(e.burnToken),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = tw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.from = r.string();
break;
case 2:
n.amount = r.string();
break;
case 3:
n.destinationDomain = r.uint32();
break;
case 4:
n.mintRecipient = r.bytes();
break;
case 5:
n.burnToken = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
from: B(e.from) ? String(e.from) : "",
amount: B(e.amount) ? String(e.amount) : "",
destinationDomain: B(e.destinationDomain)
? Number(e.destinationDomain)
: 0,
mintRecipient: B(e.mintRecipient)
? ke(e.mintRecipient)
: new Uint8Array(),
burnToken: B(e.burnToken) ? String(e.burnToken) : "",
};
},
toJSON(e) {
let t = {};
return (
e.from !== void 0 && (t.from = e.from),
e.amount !== void 0 && (t.amount = e.amount),
e.destinationDomain !== void 0 &&
(t.destinationDomain = Math.round(e.destinationDomain)),
e.mintRecipient !== void 0 &&
(t.mintRecipient = Ee(
e.mintRecipient !== void 0 ? e.mintRecipient : new Uint8Array(),
)),
e.burnToken !== void 0 && (t.burnToken = e.burnToken),
t
);
},
fromPartial(e) {
let t = tw();
return (
(t.from = e.from ?? ""),
(t.amount = e.amount ?? ""),
(t.destinationDomain = e.destinationDomain ?? 0),
(t.mintRecipient = e.mintRecipient ?? new Uint8Array()),
(t.burnToken = e.burnToken ?? ""),
t
);
},
fromProtoMsg(e) {
return Ns.decode(e.value);
},
toProto(e) {
return Ns.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/circle.cctp.v1.MsgDepositForBurn",
value: Ns.encode(e).finish(),
};
},
};
function rw() {
return { nonce: BigInt(0) };
}
var Bs = {
typeUrl: "/circle.cctp.v1.MsgDepositForBurnResponse",
is(e) {
return e && (e.$typeUrl === Bs.typeUrl || typeof e.nonce == "bigint");
},
isSDK(e) {
return e && (e.$typeUrl === Bs.typeUrl || typeof e.nonce == "bigint");
},
encode(e, t = re.create()) {
return (e.nonce !== BigInt(0) && t.uint32(8).uint64(e.nonce), t);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = rw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.nonce = r.uint64();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return { nonce: B(e.nonce) ? BigInt(e.nonce.toString()) : BigInt(0) };
},
toJSON(e) {
let t = {};
return (
e.nonce !== void 0 && (t.nonce = (e.nonce || BigInt(0)).toString()),
t
);
},
fromPartial(e) {
let t = rw();
return (
(t.nonce =
e.nonce !== void 0 && e.nonce !== null
? BigInt(e.nonce.toString())
: BigInt(0)),
t
);
},
fromProtoMsg(e) {
return Bs.decode(e.value);
},
toProto(e) {
return Bs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/circle.cctp.v1.MsgDepositForBurnResponse",
value: Bs.encode(e).finish(),
};
},
};
function ow() {
return {
from: "",
amount: "",
destinationDomain: 0,
mintRecipient: new Uint8Array(),
burnToken: "",
destinationCaller: new Uint8Array(),
};
}
var Ms = {
typeUrl: "/circle.cctp.v1.MsgDepositForBurnWithCaller",
annotations: { "gogoproto.nullable": { amount: !1 } },
aminoType: "cctp/DepositForBurnWithCaller",
is(e) {
return (
e &&
(e.$typeUrl === Ms.typeUrl ||
(typeof e.from == "string" &&
typeof e.amount == "string" &&
typeof e.destinationDomain == "number" &&
(e.mintRecipient instanceof Uint8Array ||
typeof e.mintRecipient == "string") &&
typeof e.burnToken == "string" &&
(e.destinationCaller instanceof Uint8Array ||
typeof e.destinationCaller == "string")))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ms.typeUrl ||
(typeof e.from == "string" &&
typeof e.amount == "string" &&
typeof e.destination_domain == "number" &&
(e.mint_recipient instanceof Uint8Array ||
typeof e.mint_recipient == "string") &&
typeof e.burn_token == "string" &&
(e.destination_caller instanceof Uint8Array ||
typeof e.destination_caller == "string")))
);
},
encode(e, t = re.create()) {
return (
e.from !== "" && t.uint32(10).string(e.from),
e.amount !== "" && t.uint32(18).string(e.amount),
e.destinationDomain !== 0 && t.uint32(24).uint32(e.destinationDomain),
e.mintRecipient.length !== 0 && t.uint32(34).bytes(e.mintRecipient),
e.burnToken !== "" && t.uint32(42).string(e.burnToken),
e.destinationCaller.length !== 0 &&
t.uint32(50).bytes(e.destinationCaller),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = ow();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.from = r.string();
break;
case 2:
n.amount = r.string();
break;
case 3:
n.destinationDomain = r.uint32();
break;
case 4:
n.mintRecipient = r.bytes();
break;
case 5:
n.burnToken = r.string();
break;
case 6:
n.destinationCaller = r.bytes();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
from: B(e.from) ? String(e.from) : "",
amount: B(e.amount) ? String(e.amount) : "",
destinationDomain: B(e.destinationDomain)
? Number(e.destinationDomain)
: 0,
mintRecipient: B(e.mintRecipient)
? ke(e.mintRecipient)
: new Uint8Array(),
burnToken: B(e.burnToken) ? String(e.burnToken) : "",
destinationCaller: B(e.destinationCaller)
? ke(e.destinationCaller)
: new Uint8Array(),
};
},
toJSON(e) {
let t = {};
return (
e.from !== void 0 && (t.from = e.from),
e.amount !== void 0 && (t.amount = e.amount),
e.destinationDomain !== void 0 &&
(t.destinationDomain = Math.round(e.destinationDomain)),
e.mintRecipient !== void 0 &&
(t.mintRecipient = Ee(
e.mintRecipient !== void 0 ? e.mintRecipient : new Uint8Array(),
)),
e.burnToken !== void 0 && (t.burnToken = e.burnToken),
e.destinationCaller !== void 0 &&
(t.destinationCaller = Ee(
e.destinationCaller !== void 0
? e.destinationCaller
: new Uint8Array(),
)),
t
);
},
fromPartial(e) {
let t = ow();
return (
(t.from = e.from ?? ""),
(t.amount = e.amount ?? ""),
(t.destinationDomain = e.destinationDomain ?? 0),
(t.mintRecipient = e.mintRecipient ?? new Uint8Array()),
(t.burnToken = e.burnToken ?? ""),
(t.destinationCaller = e.destinationCaller ?? new Uint8Array()),
t
);
},
fromProtoMsg(e) {
return Ms.decode(e.value);
},
toProto(e) {
return Ms.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/circle.cctp.v1.MsgDepositForBurnWithCaller",
value: Ms.encode(e).finish(),
};
},
};
function nw() {
return { nonce: BigInt(0) };
}
var $s = {
typeUrl: "/circle.cctp.v1.MsgDepositForBurnWithCallerResponse",
is(e) {
return e && (e.$typeUrl === $s.typeUrl || typeof e.nonce == "bigint");
},
isSDK(e) {
return e && (e.$typeUrl === $s.typeUrl || typeof e.nonce == "bigint");
},
encode(e, t = re.create()) {
return (e.nonce !== BigInt(0) && t.uint32(8).uint64(e.nonce), t);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = nw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.nonce = r.uint64();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return { nonce: B(e.nonce) ? BigInt(e.nonce.toString()) : BigInt(0) };
},
toJSON(e) {
let t = {};
return (
e.nonce !== void 0 && (t.nonce = (e.nonce || BigInt(0)).toString()),
t
);
},
fromPartial(e) {
let t = nw();
return (
(t.nonce =
e.nonce !== void 0 && e.nonce !== null
? BigInt(e.nonce.toString())
: BigInt(0)),
t
);
},
fromProtoMsg(e) {
return $s.decode(e.value);
},
toProto(e) {
return $s.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/circle.cctp.v1.MsgDepositForBurnWithCallerResponse",
value: $s.encode(e).finish(),
};
},
};
function sw() {
return {
key: new Uint8Array(),
offset: BigInt(0),
limit: BigInt(0),
countTotal: !1,
reverse: !1,
};
}
var Ge = {
typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
aminoType: "cosmos-sdk/PageRequest",
is(e) {
return (
e &&
(e.$typeUrl === Ge.typeUrl ||
((e.key instanceof Uint8Array || typeof e.key == "string") &&
typeof e.offset == "bigint" &&
typeof e.limit == "bigint" &&
typeof e.countTotal == "boolean" &&
typeof e.reverse == "boolean"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ge.typeUrl ||
((e.key instanceof Uint8Array || typeof e.key == "string") &&
typeof e.offset == "bigint" &&
typeof e.limit == "bigint" &&
typeof e.count_total == "boolean" &&
typeof e.reverse == "boolean"))
);
},
encode(e, t = re.create()) {
return (
e.key.length !== 0 && t.uint32(10).bytes(e.key),
e.offset !== BigInt(0) && t.uint32(16).uint64(e.offset),
e.limit !== BigInt(0) && t.uint32(24).uint64(e.limit),
e.countTotal === !0 && t.uint32(32).bool(e.countTotal),
e.reverse === !0 && t.uint32(40).bool(e.reverse),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = sw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.key = r.bytes();
break;
case 2:
n.offset = r.uint64();
break;
case 3:
n.limit = r.uint64();
break;
case 4:
n.countTotal = r.bool();
break;
case 5:
n.reverse = r.bool();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
key: B(e.key) ? ke(e.key) : new Uint8Array(),
offset: B(e.offset) ? BigInt(e.offset.toString()) : BigInt(0),
limit: B(e.limit) ? BigInt(e.limit.toString()) : BigInt(0),
countTotal: B(e.countTotal) ? !!e.countTotal : !1,
reverse: B(e.reverse) ? !!e.reverse : !1,
};
},
toJSON(e) {
let t = {};
return (
e.key !== void 0 &&
(t.key = Ee(e.key !== void 0 ? e.key : new Uint8Array())),
e.offset !== void 0 &&
(t.offset = (e.offset || BigInt(0)).toString()),
e.limit !== void 0 && (t.limit = (e.limit || BigInt(0)).toString()),
e.countTotal !== void 0 && (t.countTotal = e.countTotal),
e.reverse !== void 0 && (t.reverse = e.reverse),
t
);
},
fromPartial(e) {
let t = sw();
return (
(t.key = e.key ?? new Uint8Array()),
(t.offset =
e.offset !== void 0 && e.offset !== null
? BigInt(e.offset.toString())
: BigInt(0)),
(t.limit =
e.limit !== void 0 && e.limit !== null
? BigInt(e.limit.toString())
: BigInt(0)),
(t.countTotal = e.countTotal ?? !1),
(t.reverse = e.reverse ?? !1),
t
);
},
fromProtoMsg(e) {
return Ge.decode(e.value);
},
toProto(e) {
return Ge.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
value: Ge.encode(e).finish(),
};
},
};
function aw() {
return { nextKey: new Uint8Array(), total: BigInt(0) };
}
var Qe = {
typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
aminoType: "cosmos-sdk/PageResponse",
is(e) {
return (
e &&
(e.$typeUrl === Qe.typeUrl ||
((e.nextKey instanceof Uint8Array ||
typeof e.nextKey == "string") &&
typeof e.total == "bigint"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Qe.typeUrl ||
((e.next_key instanceof Uint8Array ||
typeof e.next_key == "string") &&
typeof e.total == "bigint"))
);
},
encode(e, t = re.create()) {
return (
e.nextKey.length !== 0 && t.uint32(10).bytes(e.nextKey),
e.total !== BigInt(0) && t.uint32(16).uint64(e.total),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = aw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.nextKey = r.bytes();
break;
case 2:
n.total = r.uint64();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
nextKey: B(e.nextKey) ? ke(e.nextKey) : new Uint8Array(),
total: B(e.total) ? BigInt(e.total.toString()) : BigInt(0),
};
},
toJSON(e) {
let t = {};
return (
e.nextKey !== void 0 &&
(t.nextKey = Ee(
e.nextKey !== void 0 ? e.nextKey : new Uint8Array(),
)),
e.total !== void 0 && (t.total = (e.total || BigInt(0)).toString()),
t
);
},
fromPartial(e) {
let t = aw();
return (
(t.nextKey = e.nextKey ?? new Uint8Array()),
(t.total =
e.total !== void 0 && e.total !== null
? BigInt(e.total.toString())
: BigInt(0)),
t
);
},
fromProtoMsg(e) {
return Qe.decode(e.value);
},
toProto(e) {
return Qe.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
value: Qe.encode(e).finish(),
};
},
};
function iw() {
return { address: "", denom: "" };
}
var rn = {
typeUrl: "/cosmos.bank.v1beta1.QueryBalanceRequest",
aminoType: "cosmos-sdk/QueryBalanceRequest",
is(e) {
return (
e &&
(e.$typeUrl === rn.typeUrl ||
(typeof e.address == "string" && typeof e.denom == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === rn.typeUrl ||
(typeof e.address == "string" && typeof e.denom == "string"))
);
},
encode(e, t = re.create()) {
return (
e.address !== "" && t.uint32(10).string(e.address),
e.denom !== "" && t.uint32(18).string(e.denom),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = iw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.address = r.string();
break;
case 2:
n.denom = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
address: B(e.address) ? String(e.address) : "",
denom: B(e.denom) ? String(e.denom) : "",
};
},
toJSON(e) {
let t = {};
return (
e.address !== void 0 && (t.address = e.address),
e.denom !== void 0 && (t.denom = e.denom),
t
);
},
fromPartial(e) {
let t = iw();
return ((t.address = e.address ?? ""), (t.denom = e.denom ?? ""), t);
},
fromProtoMsg(e) {
return rn.decode(e.value);
},
toProto(e) {
return rn.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.bank.v1beta1.QueryBalanceRequest",
value: rn.encode(e).finish(),
};
},
};
function cw() {
return { balance: void 0 };
}
var _s = {
typeUrl: "/cosmos.bank.v1beta1.QueryBalanceResponse",
aminoType: "cosmos-sdk/QueryBalanceResponse",
is(e) {
return e && e.$typeUrl === _s.typeUrl;
},
isSDK(e) {
return e && e.$typeUrl === _s.typeUrl;
},
encode(e, t = re.create()) {
return (
e.balance !== void 0 &&
G.encode(e.balance, t.uint32(10).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = cw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.balance = G.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return { balance: B(e.balance) ? G.fromJSON(e.balance) : void 0 };
},
toJSON(e) {
let t = {};
return (
e.balance !== void 0 &&
(t.balance = e.balance ? G.toJSON(e.balance) : void 0),
t
);
},
fromPartial(e) {
let t = cw();
return (
(t.balance =
e.balance !== void 0 && e.balance !== null
? G.fromPartial(e.balance)
: void 0),
t
);
},
fromProtoMsg(e) {
return _s.decode(e.value);
},
toProto(e) {
return _s.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.bank.v1beta1.QueryBalanceResponse",
value: _s.encode(e).finish(),
};
},
};
function dw() {
return { address: "", pagination: void 0, resolveDenom: !1 };
}
var on = {
typeUrl: "/cosmos.bank.v1beta1.QueryAllBalancesRequest",
aminoType: "cosmos-sdk/QueryAllBalancesRequest",
is(e) {
return (
e &&
(e.$typeUrl === on.typeUrl ||
(typeof e.address == "string" &&
typeof e.resolveDenom == "boolean"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === on.typeUrl ||
(typeof e.address == "string" &&
typeof e.resolve_denom == "boolean"))
);
},
encode(e, t = re.create()) {
return (
e.address !== "" && t.uint32(10).string(e.address),
e.pagination !== void 0 &&
Ge.encode(e.pagination, t.uint32(18).fork()).ldelim(),
e.resolveDenom === !0 && t.uint32(24).bool(e.resolveDenom),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = dw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.address = r.string();
break;
case 2:
n.pagination = Ge.decode(r, r.uint32());
break;
case 3:
n.resolveDenom = r.bool();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
address: B(e.address) ? String(e.address) : "",
pagination: B(e.pagination) ? Ge.fromJSON(e.pagination) : void 0,
resolveDenom: B(e.resolveDenom) ? !!e.resolveDenom : !1,
};
},
toJSON(e) {
let t = {};
return (
e.address !== void 0 && (t.address = e.address),
e.pagination !== void 0 &&
(t.pagination = e.pagination ? Ge.toJSON(e.pagination) : void 0),
e.resolveDenom !== void 0 && (t.resolveDenom = e.resolveDenom),
t
);
},
fromPartial(e) {
let t = dw();
return (
(t.address = e.address ?? ""),
(t.pagination =
e.pagination !== void 0 && e.pagination !== null
? Ge.fromPartial(e.pagination)
: void 0),
(t.resolveDenom = e.resolveDenom ?? !1),
t
);
},
fromProtoMsg(e) {
return on.decode(e.value);
},
toProto(e) {
return on.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.bank.v1beta1.QueryAllBalancesRequest",
value: on.encode(e).finish(),
};
},
};
function lw() {
return { balances: [], pagination: void 0 };
}
var Fs = {
typeUrl: "/cosmos.bank.v1beta1.QueryAllBalancesResponse",
aminoType: "cosmos-sdk/QueryAllBalancesResponse",
is(e) {
return (
e &&
(e.$typeUrl === Fs.typeUrl ||
(Array.isArray(e.balances) &&
(!e.balances.length || G.is(e.balances[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Fs.typeUrl ||
(Array.isArray(e.balances) &&
(!e.balances.length || G.isSDK(e.balances[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.balances) G.encode(r, t.uint32(10).fork()).ldelim();
return (
e.pagination !== void 0 &&
Qe.encode(e.pagination, t.uint32(18).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = lw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.balances.push(G.decode(r, r.uint32()));
break;
case 2:
n.pagination = Qe.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
balances: Array.isArray(e?.balances)
? e.balances.map((t) => G.fromJSON(t))
: [],
pagination: B(e.pagination) ? Qe.fromJSON(e.pagination) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.balances
? (t.balances = e.balances.map((r) => (r ? G.toJSON(r) : void 0)))
: (t.balances = []),
e.pagination !== void 0 &&
(t.pagination = e.pagination ? Qe.toJSON(e.pagination) : void 0),
t
);
},
fromPartial(e) {
let t = lw();
return (
(t.balances = e.balances?.map((r) => G.fromPartial(r)) || []),
(t.pagination =
e.pagination !== void 0 && e.pagination !== null
? Qe.fromPartial(e.pagination)
: void 0),
t
);
},
fromProtoMsg(e) {
return Fs.decode(e.value);
},
toProto(e) {
return Fs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.bank.v1beta1.QueryAllBalancesResponse",
value: Fs.encode(e).finish(),
};
},
};
function uw() {
return { fromAddress: "", toAddress: "", amount: [] };
}
var nn = {
typeUrl: "/cosmos.bank.v1beta1.MsgSend",
aminoType: "cosmos-sdk/MsgSend",
is(e) {
return (
e &&
(e.$typeUrl === nn.typeUrl ||
(typeof e.fromAddress == "string" &&
typeof e.toAddress == "string" &&
Array.isArray(e.amount) &&
(!e.amount.length || G.is(e.amount[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === nn.typeUrl ||
(typeof e.from_address == "string" &&
typeof e.to_address == "string" &&
Array.isArray(e.amount) &&
(!e.amount.length || G.isSDK(e.amount[0]))))
);
},
encode(e, t = re.create()) {
(e.fromAddress !== "" && t.uint32(10).string(e.fromAddress),
e.toAddress !== "" && t.uint32(18).string(e.toAddress));
for (let r of e.amount) G.encode(r, t.uint32(26).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = uw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.fromAddress = r.string();
break;
case 2:
n.toAddress = r.string();
break;
case 3:
n.amount.push(G.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
fromAddress: B(e.fromAddress) ? String(e.fromAddress) : "",
toAddress: B(e.toAddress) ? String(e.toAddress) : "",
amount: Array.isArray(e?.amount)
? e.amount.map((t) => G.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.fromAddress !== void 0 && (t.fromAddress = e.fromAddress),
e.toAddress !== void 0 && (t.toAddress = e.toAddress),
e.amount
? (t.amount = e.amount.map((r) => (r ? G.toJSON(r) : void 0)))
: (t.amount = []),
t
);
},
fromPartial(e) {
let t = uw();
return (
(t.fromAddress = e.fromAddress ?? ""),
(t.toAddress = e.toAddress ?? ""),
(t.amount = e.amount?.map((r) => G.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return nn.decode(e.value);
},
toProto(e) {
return nn.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.bank.v1beta1.MsgSend",
value: nn.encode(e).finish(),
};
},
};
function pw() {
return {};
}
var Ks = {
typeUrl: "/cosmos.bank.v1beta1.MsgSendResponse",
aminoType: "cosmos-sdk/MsgSendResponse",
is(e) {
return e && e.$typeUrl === Ks.typeUrl;
},
isSDK(e) {
return e && e.$typeUrl === Ks.typeUrl;
},
encode(e, t = re.create()) {
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = pw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {};
},
toJSON(e) {
return {};
},
fromPartial(e) {
return pw();
},
fromProtoMsg(e) {
return Ks.decode(e.value);
},
toProto(e) {
return Ks.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.bank.v1beta1.MsgSendResponse",
value: Ks.encode(e).finish(),
};
},
};
function mw() {
return { validatorAddress: "", reward: [] };
}
var dr = {
typeUrl: "/cosmos.distribution.v1beta1.DelegationDelegatorReward",
aminoType: "cosmos-sdk/DelegationDelegatorReward",
is(e) {
return (
e &&
(e.$typeUrl === dr.typeUrl ||
(typeof e.validatorAddress == "string" &&
Array.isArray(e.reward) &&
(!e.reward.length || Ye.is(e.reward[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === dr.typeUrl ||
(typeof e.validator_address == "string" &&
Array.isArray(e.reward) &&
(!e.reward.length || Ye.isSDK(e.reward[0]))))
);
},
encode(e, t = re.create()) {
e.validatorAddress !== "" && t.uint32(10).string(e.validatorAddress);
for (let r of e.reward) Ye.encode(r, t.uint32(18).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = mw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.validatorAddress = r.string();
break;
case 2:
n.reward.push(Ye.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
validatorAddress: B(e.validatorAddress)
? String(e.validatorAddress)
: "",
reward: Array.isArray(e?.reward)
? e.reward.map((t) => Ye.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.validatorAddress !== void 0 &&
(t.validatorAddress = e.validatorAddress),
e.reward
? (t.reward = e.reward.map((r) => (r ? Ye.toJSON(r) : void 0)))
: (t.reward = []),
t
);
},
fromPartial(e) {
let t = mw();
return (
(t.validatorAddress = e.validatorAddress ?? ""),
(t.reward = e.reward?.map((r) => Ye.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return dr.decode(e.value);
},
toProto(e) {
return dr.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.distribution.v1beta1.DelegationDelegatorReward",
value: dr.encode(e).finish(),
};
},
};
function fw() {
return { delegatorAddress: "", validatorAddress: "" };
}
var Js = {
typeUrl: "/cosmos.distribution.v1beta1.QueryDelegationRewardsRequest",
aminoType: "cosmos-sdk/QueryDelegationRewardsRequest",
is(e) {
return (
e &&
(e.$typeUrl === Js.typeUrl ||
(typeof e.delegatorAddress == "string" &&
typeof e.validatorAddress == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Js.typeUrl ||
(typeof e.delegator_address == "string" &&
typeof e.validator_address == "string"))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
e.validatorAddress !== "" && t.uint32(18).string(e.validatorAddress),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = fw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
case 2:
n.validatorAddress = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
validatorAddress: B(e.validatorAddress)
? String(e.validatorAddress)
: "",
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
e.validatorAddress !== void 0 &&
(t.validatorAddress = e.validatorAddress),
t
);
},
fromPartial(e) {
let t = fw();
return (
(t.delegatorAddress = e.delegatorAddress ?? ""),
(t.validatorAddress = e.validatorAddress ?? ""),
t
);
},
fromProtoMsg(e) {
return Js.decode(e.value);
},
toProto(e) {
return Js.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.distribution.v1beta1.QueryDelegationRewardsRequest",
value: Js.encode(e).finish(),
};
},
};
function yw() {
return { rewards: [] };
}
var Vs = {
typeUrl: "/cosmos.distribution.v1beta1.QueryDelegationRewardsResponse",
aminoType: "cosmos-sdk/QueryDelegationRewardsResponse",
is(e) {
return (
e &&
(e.$typeUrl === Vs.typeUrl ||
(Array.isArray(e.rewards) &&
(!e.rewards.length || Ye.is(e.rewards[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Vs.typeUrl ||
(Array.isArray(e.rewards) &&
(!e.rewards.length || Ye.isSDK(e.rewards[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.rewards) Ye.encode(r, t.uint32(10).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = yw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.rewards.push(Ye.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
rewards: Array.isArray(e?.rewards)
? e.rewards.map((t) => Ye.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.rewards
? (t.rewards = e.rewards.map((r) => (r ? Ye.toJSON(r) : void 0)))
: (t.rewards = []),
t
);
},
fromPartial(e) {
let t = yw();
return (
(t.rewards = e.rewards?.map((r) => Ye.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return Vs.decode(e.value);
},
toProto(e) {
return Vs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl:
"/cosmos.distribution.v1beta1.QueryDelegationRewardsResponse",
value: Vs.encode(e).finish(),
};
},
};
function gw() {
return { delegatorAddress: "" };
}
var Hs = {
typeUrl:
"/cosmos.distribution.v1beta1.QueryDelegationTotalRewardsRequest",
aminoType: "cosmos-sdk/QueryDelegationTotalRewardsRequest",
is(e) {
return (
e &&
(e.$typeUrl === Hs.typeUrl || typeof e.delegatorAddress == "string")
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Hs.typeUrl || typeof e.delegator_address == "string")
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = gw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
t
);
},
fromPartial(e) {
let t = gw();
return ((t.delegatorAddress = e.delegatorAddress ?? ""), t);
},
fromProtoMsg(e) {
return Hs.decode(e.value);
},
toProto(e) {
return Hs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl:
"/cosmos.distribution.v1beta1.QueryDelegationTotalRewardsRequest",
value: Hs.encode(e).finish(),
};
},
};
function hw() {
return { rewards: [], total: [] };
}
var Ws = {
typeUrl:
"/cosmos.distribution.v1beta1.QueryDelegationTotalRewardsResponse",
aminoType: "cosmos-sdk/QueryDelegationTotalRewardsResponse",
is(e) {
return (
e &&
(e.$typeUrl === Ws.typeUrl ||
(Array.isArray(e.rewards) &&
(!e.rewards.length || dr.is(e.rewards[0])) &&
Array.isArray(e.total) &&
(!e.total.length || Ye.is(e.total[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ws.typeUrl ||
(Array.isArray(e.rewards) &&
(!e.rewards.length || dr.isSDK(e.rewards[0])) &&
Array.isArray(e.total) &&
(!e.total.length || Ye.isSDK(e.total[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.rewards) dr.encode(r, t.uint32(10).fork()).ldelim();
for (let r of e.total) Ye.encode(r, t.uint32(18).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = hw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.rewards.push(dr.decode(r, r.uint32()));
break;
case 2:
n.total.push(Ye.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
rewards: Array.isArray(e?.rewards)
? e.rewards.map((t) => dr.fromJSON(t))
: [],
total: Array.isArray(e?.total)
? e.total.map((t) => Ye.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.rewards
? (t.rewards = e.rewards.map((r) => (r ? dr.toJSON(r) : void 0)))
: (t.rewards = []),
e.total
? (t.total = e.total.map((r) => (r ? Ye.toJSON(r) : void 0)))
: (t.total = []),
t
);
},
fromPartial(e) {
let t = hw();
return (
(t.rewards = e.rewards?.map((r) => dr.fromPartial(r)) || []),
(t.total = e.total?.map((r) => Ye.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return Ws.decode(e.value);
},
toProto(e) {
return Ws.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl:
"/cosmos.distribution.v1beta1.QueryDelegationTotalRewardsResponse",
value: Ws.encode(e).finish(),
};
},
};
function bw() {
return { delegatorAddress: "", validatorAddress: "" };
}
var Ls = {
typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
aminoType: "cosmos-sdk/MsgWithdrawDelegationReward",
is(e) {
return (
e &&
(e.$typeUrl === Ls.typeUrl ||
(typeof e.delegatorAddress == "string" &&
typeof e.validatorAddress == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ls.typeUrl ||
(typeof e.delegator_address == "string" &&
typeof e.validator_address == "string"))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
e.validatorAddress !== "" && t.uint32(18).string(e.validatorAddress),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = bw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
case 2:
n.validatorAddress = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
validatorAddress: B(e.validatorAddress)
? String(e.validatorAddress)
: "",
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
e.validatorAddress !== void 0 &&
(t.validatorAddress = e.validatorAddress),
t
);
},
fromPartial(e) {
let t = bw();
return (
(t.delegatorAddress = e.delegatorAddress ?? ""),
(t.validatorAddress = e.validatorAddress ?? ""),
t
);
},
fromProtoMsg(e) {
return Ls.decode(e.value);
},
toProto(e) {
return Ls.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
value: Ls.encode(e).finish(),
};
},
};
function vw() {
return { amount: [] };
}
var qs = {
typeUrl:
"/cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse",
aminoType: "cosmos-sdk/MsgWithdrawDelegatorRewardResponse",
is(e) {
return (
e &&
(e.$typeUrl === qs.typeUrl ||
(Array.isArray(e.amount) &&
(!e.amount.length || G.is(e.amount[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === qs.typeUrl ||
(Array.isArray(e.amount) &&
(!e.amount.length || G.isSDK(e.amount[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.amount) G.encode(r, t.uint32(10).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = vw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.amount.push(G.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
amount: Array.isArray(e?.amount)
? e.amount.map((t) => G.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.amount
? (t.amount = e.amount.map((r) => (r ? G.toJSON(r) : void 0)))
: (t.amount = []),
t
);
},
fromPartial(e) {
let t = vw();
return ((t.amount = e.amount?.map((r) => G.fromPartial(r)) || []), t);
},
fromProtoMsg(e) {
return qs.decode(e.value);
},
toProto(e) {
return qs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl:
"/cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse",
value: qs.encode(e).finish(),
};
},
};
var ui = class e {
static registry = {};
static aminoProtoMapping = {};
static existingTypeUrls = [];
static registerExistingTypeUrl(t) {
return e.existingTypeUrls.includes(t)
? !1
: (e.existingTypeUrls.push(t), !0);
}
static registerAminoProtoMapping(t, r) {
e.aminoProtoMapping[t] = r;
}
static register(t, r) {
e.registry[t] = r;
}
static getDecoder(t) {
return e.registry[t];
}
static getDecoderByInstance(t) {
if (t == null) return null;
let r = t;
if (r.$typeUrl) return e.getDecoder(r.$typeUrl);
for (let o in e.registry)
if (Object.prototype.hasOwnProperty.call(e.registry, o)) {
let n = e.registry[o];
if (
n.is(t) ||
(n.isSDK && n.isSDK(t)) ||
(n.isAmino && n.isAmino(t))
)
return n;
}
return null;
}
static getDecoderByAminoType(t) {
if (t == null) return null;
let r = e.aminoProtoMapping[t];
return r ? e.getDecoder(r) : null;
}
static wrapAny(t) {
if (fe.is(t)) return t;
let r = _o(t);
return { typeUrl: r.typeUrl, value: r.encode(t).finish() };
}
static unwrapAny(t) {
let r;
if (fe.is(t)) r = t;
else {
let n = t instanceof $ ? t : new $(t);
r = fe.decode(n, n.uint32());
}
let o = e.getDecoder(r.typeUrl);
return o ? o.decode(r.value) : r;
}
static fromJSON(t) {
return _o(t).fromJSON(t);
}
static toJSON(t) {
return _o(t).toJSON(t);
}
static fromPartial(t) {
let r = _o(t);
return r ? r.fromPartial(t) : t;
}
static fromSDK(t) {
return _o(t).fromSDK(t);
}
static fromSDKJSON(t) {
return _o(t).fromSDKJSON(t);
}
static toSDK(t) {
return _o(t).toSDK(t);
}
static fromAmino(t) {
return _o(t).fromAmino(t);
}
static fromAminoMsg(t) {
let r = e.getDecoderByAminoType(t.type);
if (!r)
throw new Error(`There's no decoder for the amino type ${t.type}`);
return r.fromAminoMsg(t);
}
static toAmino(t) {
let r, o;
return (
fe.is(t)
? ((r = e.unwrapAny(t)),
(o = e.getDecoder(t.typeUrl)),
o || (o = fe))
: ((r = t), (o = _o(t))),
o.toAmino(r)
);
}
static toAminoMsg(t) {
let r, o;
return (
fe.is(t)
? ((r = e.unwrapAny(t)),
(o = e.getDecoder(t.typeUrl)),
o || (o = fe))
: ((r = t), (o = _o(t))),
o.toAminoMsg(r)
);
}
};
function _o(e) {
let t = ui.getDecoderByInstance(e);
if (!t)
throw new Error(
`There's no decoder for the instance ${JSON.stringify(e)}`,
);
return t;
}
ui.register(fe.typeUrl, fe);
var xN = ((e) => (
(e[(e.BOND_STATUS_UNSPECIFIED = 0)] = "BOND_STATUS_UNSPECIFIED"),
(e[(e.BOND_STATUS_UNBONDED = 1)] = "BOND_STATUS_UNBONDED"),
(e[(e.BOND_STATUS_UNBONDING = 2)] = "BOND_STATUS_UNBONDING"),
(e[(e.BOND_STATUS_BONDED = 3)] = "BOND_STATUS_BONDED"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(xN || {});
var AN = ((e) => (
(e[(e.INFRACTION_UNSPECIFIED = 0)] = "INFRACTION_UNSPECIFIED"),
(e[(e.INFRACTION_DOUBLE_SIGN = 1)] = "INFRACTION_DOUBLE_SIGN"),
(e[(e.INFRACTION_DOWNTIME = 2)] = "INFRACTION_DOWNTIME"),
(e[(e.UNRECOGNIZED = -1)] = "UNRECOGNIZED"),
e
))(AN || {});
function Sw() {
return { delegatorAddress: "", validatorAddress: "", shares: "" };
}
var Xt = {
typeUrl: "/cosmos.staking.v1beta1.Delegation",
annotations: {
"gogoproto.nullable": { shares: !1 },
typeUrlFromField: { shares: "cosmos.Dec" },
},
aminoType: "cosmos-sdk/Delegation",
is(e) {
return (
e &&
(e.$typeUrl === Xt.typeUrl ||
(typeof e.delegatorAddress == "string" &&
typeof e.validatorAddress == "string" &&
typeof e.shares == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Xt.typeUrl ||
(typeof e.delegator_address == "string" &&
typeof e.validator_address == "string" &&
typeof e.shares == "string"))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
e.validatorAddress !== "" && t.uint32(18).string(e.validatorAddress),
e.shares !== "" &&
t.uint32(26).string(Cr.fromUserInput(e.shares, 18).atomics),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Sw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
case 2:
n.validatorAddress = r.string();
break;
case 3:
n.shares = Cr.fromAtomics(r.string(), 18).toString();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
validatorAddress: B(e.validatorAddress)
? String(e.validatorAddress)
: "",
shares: B(e.shares) ? String(e.shares) : "",
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
e.validatorAddress !== void 0 &&
(t.validatorAddress = e.validatorAddress),
e.shares !== void 0 && (t.shares = e.shares),
t
);
},
fromPartial(e) {
let t = Sw();
return (
(t.delegatorAddress = e.delegatorAddress ?? ""),
(t.validatorAddress = e.validatorAddress ?? ""),
(t.shares = e.shares ?? ""),
t
);
},
fromProtoMsg(e) {
return Xt.decode(e.value);
},
toProto(e) {
return Xt.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.Delegation",
value: Xt.encode(e).finish(),
};
},
};
function xw() {
return { delegatorAddress: "", validatorAddress: "", entries: [] };
}
var at = {
typeUrl: "/cosmos.staking.v1beta1.UnbondingDelegation",
aminoType: "cosmos-sdk/UnbondingDelegation",
is(e) {
return (
e &&
(e.$typeUrl === at.typeUrl ||
(typeof e.delegatorAddress == "string" &&
typeof e.validatorAddress == "string" &&
Array.isArray(e.entries) &&
(!e.entries.length || Dr.is(e.entries[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === at.typeUrl ||
(typeof e.delegator_address == "string" &&
typeof e.validator_address == "string" &&
Array.isArray(e.entries) &&
(!e.entries.length || Dr.isSDK(e.entries[0]))))
);
},
encode(e, t = re.create()) {
(e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
e.validatorAddress !== "" && t.uint32(18).string(e.validatorAddress));
for (let r of e.entries) Dr.encode(r, t.uint32(26).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = xw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
case 2:
n.validatorAddress = r.string();
break;
case 3:
n.entries.push(Dr.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
validatorAddress: B(e.validatorAddress)
? String(e.validatorAddress)
: "",
entries: Array.isArray(e?.entries)
? e.entries.map((t) => Dr.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
e.validatorAddress !== void 0 &&
(t.validatorAddress = e.validatorAddress),
e.entries
? (t.entries = e.entries.map((r) => (r ? Dr.toJSON(r) : void 0)))
: (t.entries = []),
t
);
},
fromPartial(e) {
let t = xw();
return (
(t.delegatorAddress = e.delegatorAddress ?? ""),
(t.validatorAddress = e.validatorAddress ?? ""),
(t.entries = e.entries?.map((r) => Dr.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return at.decode(e.value);
},
toProto(e) {
return at.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.UnbondingDelegation",
value: at.encode(e).finish(),
};
},
};
function Aw() {
return {
creationHeight: BigInt(0),
completionTime: we.fromPartial({}),
initialBalance: "",
balance: "",
unbondingId: BigInt(0),
unbondingOnHoldRefCount: BigInt(0),
};
}
var Dr = {
typeUrl: "/cosmos.staking.v1beta1.UnbondingDelegationEntry",
annotations: {
"amino.dont_omitempty": { completionTime: !0 },
"gogoproto.nullable": {
balance: !1,
completionTime: !1,
initialBalance: !1,
},
typeUrlFromField: {
balance: "cosmos.Int",
completionTime: () => we,
initialBalance: "cosmos.Int",
},
},
aminoType: "cosmos-sdk/UnbondingDelegationEntry",
is(e) {
return (
e &&
(e.$typeUrl === Dr.typeUrl ||
(typeof e.creationHeight == "bigint" &&
we.is(e.completionTime) &&
typeof e.initialBalance == "string" &&
typeof e.balance == "string" &&
typeof e.unbondingId == "bigint" &&
typeof e.unbondingOnHoldRefCount == "bigint"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Dr.typeUrl ||
(typeof e.creation_height == "bigint" &&
we.isSDK(e.completion_time) &&
typeof e.initial_balance == "string" &&
typeof e.balance == "string" &&
typeof e.unbonding_id == "bigint" &&
typeof e.unbonding_on_hold_ref_count == "bigint"))
);
},
encode(e, t = re.create()) {
return (
e.creationHeight !== BigInt(0) && t.uint32(8).int64(e.creationHeight),
e.completionTime !== void 0 &&
we.encode(e.completionTime, t.uint32(18).fork()).ldelim(),
e.initialBalance !== "" && t.uint32(26).string(e.initialBalance),
e.balance !== "" && t.uint32(34).string(e.balance),
e.unbondingId !== BigInt(0) && t.uint32(40).uint64(e.unbondingId),
e.unbondingOnHoldRefCount !== BigInt(0) &&
t.uint32(48).int64(e.unbondingOnHoldRefCount),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Aw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.creationHeight = r.int64();
break;
case 2:
n.completionTime = we.decode(r, r.uint32());
break;
case 3:
n.initialBalance = r.string();
break;
case 4:
n.balance = r.string();
break;
case 5:
n.unbondingId = r.uint64();
break;
case 6:
n.unbondingOnHoldRefCount = r.int64();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
creationHeight: B(e.creationHeight)
? BigInt(e.creationHeight.toString())
: BigInt(0),
completionTime: B(e.completionTime) ? Ur(e.completionTime) : void 0,
initialBalance: B(e.initialBalance) ? String(e.initialBalance) : "",
balance: B(e.balance) ? String(e.balance) : "",
unbondingId: B(e.unbondingId)
? BigInt(e.unbondingId.toString())
: BigInt(0),
unbondingOnHoldRefCount: B(e.unbondingOnHoldRefCount)
? BigInt(e.unbondingOnHoldRefCount.toString())
: BigInt(0),
};
},
toJSON(e) {
let t = {};
return (
e.creationHeight !== void 0 &&
(t.creationHeight = (e.creationHeight || BigInt(0)).toString()),
e.completionTime !== void 0 &&
(t.completionTime = Tr(e.completionTime).toISOString()),
e.initialBalance !== void 0 && (t.initialBalance = e.initialBalance),
e.balance !== void 0 && (t.balance = e.balance),
e.unbondingId !== void 0 &&
(t.unbondingId = (e.unbondingId || BigInt(0)).toString()),
e.unbondingOnHoldRefCount !== void 0 &&
(t.unbondingOnHoldRefCount = (
e.unbondingOnHoldRefCount || BigInt(0)
).toString()),
t
);
},
fromPartial(e) {
let t = Aw();
return (
(t.creationHeight =
e.creationHeight !== void 0 && e.creationHeight !== null
? BigInt(e.creationHeight.toString())
: BigInt(0)),
(t.completionTime =
e.completionTime !== void 0 && e.completionTime !== null
? we.fromPartial(e.completionTime)
: void 0),
(t.initialBalance = e.initialBalance ?? ""),
(t.balance = e.balance ?? ""),
(t.unbondingId =
e.unbondingId !== void 0 && e.unbondingId !== null
? BigInt(e.unbondingId.toString())
: BigInt(0)),
(t.unbondingOnHoldRefCount =
e.unbondingOnHoldRefCount !== void 0 &&
e.unbondingOnHoldRefCount !== null
? BigInt(e.unbondingOnHoldRefCount.toString())
: BigInt(0)),
t
);
},
fromProtoMsg(e) {
return Dr.decode(e.value);
},
toProto(e) {
return Dr.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.UnbondingDelegationEntry",
value: Dr.encode(e).finish(),
};
},
};
function ww() {
return {
creationHeight: BigInt(0),
completionTime: we.fromPartial({}),
initialBalance: "",
sharesDst: "",
unbondingId: BigInt(0),
unbondingOnHoldRefCount: BigInt(0),
};
}
var lt = {
typeUrl: "/cosmos.staking.v1beta1.RedelegationEntry",
annotations: {
"amino.dont_omitempty": { completionTime: !0 },
"gogoproto.nullable": {
completionTime: !1,
initialBalance: !1,
sharesDst: !1,
},
typeUrlFromField: {
completionTime: () => we,
initialBalance: "cosmos.Int",
sharesDst: "cosmos.Dec",
},
},
aminoType: "cosmos-sdk/RedelegationEntry",
is(e) {
return (
e &&
(e.$typeUrl === lt.typeUrl ||
(typeof e.creationHeight == "bigint" &&
we.is(e.completionTime) &&
typeof e.initialBalance == "string" &&
typeof e.sharesDst == "string" &&
typeof e.unbondingId == "bigint" &&
typeof e.unbondingOnHoldRefCount == "bigint"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === lt.typeUrl ||
(typeof e.creation_height == "bigint" &&
we.isSDK(e.completion_time) &&
typeof e.initial_balance == "string" &&
typeof e.shares_dst == "string" &&
typeof e.unbonding_id == "bigint" &&
typeof e.unbonding_on_hold_ref_count == "bigint"))
);
},
encode(e, t = re.create()) {
return (
e.creationHeight !== BigInt(0) && t.uint32(8).int64(e.creationHeight),
e.completionTime !== void 0 &&
we.encode(e.completionTime, t.uint32(18).fork()).ldelim(),
e.initialBalance !== "" && t.uint32(26).string(e.initialBalance),
e.sharesDst !== "" &&
t.uint32(34).string(Cr.fromUserInput(e.sharesDst, 18).atomics),
e.unbondingId !== BigInt(0) && t.uint32(40).uint64(e.unbondingId),
e.unbondingOnHoldRefCount !== BigInt(0) &&
t.uint32(48).int64(e.unbondingOnHoldRefCount),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = ww();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.creationHeight = r.int64();
break;
case 2:
n.completionTime = we.decode(r, r.uint32());
break;
case 3:
n.initialBalance = r.string();
break;
case 4:
n.sharesDst = Cr.fromAtomics(r.string(), 18).toString();
break;
case 5:
n.unbondingId = r.uint64();
break;
case 6:
n.unbondingOnHoldRefCount = r.int64();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
creationHeight: B(e.creationHeight)
? BigInt(e.creationHeight.toString())
: BigInt(0),
completionTime: B(e.completionTime) ? Ur(e.completionTime) : void 0,
initialBalance: B(e.initialBalance) ? String(e.initialBalance) : "",
sharesDst: B(e.sharesDst) ? String(e.sharesDst) : "",
unbondingId: B(e.unbondingId)
? BigInt(e.unbondingId.toString())
: BigInt(0),
unbondingOnHoldRefCount: B(e.unbondingOnHoldRefCount)
? BigInt(e.unbondingOnHoldRefCount.toString())
: BigInt(0),
};
},
toJSON(e) {
let t = {};
return (
e.creationHeight !== void 0 &&
(t.creationHeight = (e.creationHeight || BigInt(0)).toString()),
e.completionTime !== void 0 &&
(t.completionTime = Tr(e.completionTime).toISOString()),
e.initialBalance !== void 0 && (t.initialBalance = e.initialBalance),
e.sharesDst !== void 0 && (t.sharesDst = e.sharesDst),
e.unbondingId !== void 0 &&
(t.unbondingId = (e.unbondingId || BigInt(0)).toString()),
e.unbondingOnHoldRefCount !== void 0 &&
(t.unbondingOnHoldRefCount = (
e.unbondingOnHoldRefCount || BigInt(0)
).toString()),
t
);
},
fromPartial(e) {
let t = ww();
return (
(t.creationHeight =
e.creationHeight !== void 0 && e.creationHeight !== null
? BigInt(e.creationHeight.toString())
: BigInt(0)),
(t.completionTime =
e.completionTime !== void 0 && e.completionTime !== null
? we.fromPartial(e.completionTime)
: void 0),
(t.initialBalance = e.initialBalance ?? ""),
(t.sharesDst = e.sharesDst ?? ""),
(t.unbondingId =
e.unbondingId !== void 0 && e.unbondingId !== null
? BigInt(e.unbondingId.toString())
: BigInt(0)),
(t.unbondingOnHoldRefCount =
e.unbondingOnHoldRefCount !== void 0 &&
e.unbondingOnHoldRefCount !== null
? BigInt(e.unbondingOnHoldRefCount.toString())
: BigInt(0)),
t
);
},
fromProtoMsg(e) {
return lt.decode(e.value);
},
toProto(e) {
return lt.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.RedelegationEntry",
value: lt.encode(e).finish(),
};
},
};
function Pw() {
return {
delegatorAddress: "",
validatorSrcAddress: "",
validatorDstAddress: "",
entries: [],
};
}
var er = {
typeUrl: "/cosmos.staking.v1beta1.Redelegation",
aminoType: "cosmos-sdk/Redelegation",
is(e) {
return (
e &&
(e.$typeUrl === er.typeUrl ||
(typeof e.delegatorAddress == "string" &&
typeof e.validatorSrcAddress == "string" &&
typeof e.validatorDstAddress == "string" &&
Array.isArray(e.entries) &&
(!e.entries.length || lt.is(e.entries[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === er.typeUrl ||
(typeof e.delegator_address == "string" &&
typeof e.validator_src_address == "string" &&
typeof e.validator_dst_address == "string" &&
Array.isArray(e.entries) &&
(!e.entries.length || lt.isSDK(e.entries[0]))))
);
},
encode(e, t = re.create()) {
(e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
e.validatorSrcAddress !== "" &&
t.uint32(18).string(e.validatorSrcAddress),
e.validatorDstAddress !== "" &&
t.uint32(26).string(e.validatorDstAddress));
for (let r of e.entries) lt.encode(r, t.uint32(34).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Pw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
case 2:
n.validatorSrcAddress = r.string();
break;
case 3:
n.validatorDstAddress = r.string();
break;
case 4:
n.entries.push(lt.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
validatorSrcAddress: B(e.validatorSrcAddress)
? String(e.validatorSrcAddress)
: "",
validatorDstAddress: B(e.validatorDstAddress)
? String(e.validatorDstAddress)
: "",
entries: Array.isArray(e?.entries)
? e.entries.map((t) => lt.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
e.validatorSrcAddress !== void 0 &&
(t.validatorSrcAddress = e.validatorSrcAddress),
e.validatorDstAddress !== void 0 &&
(t.validatorDstAddress = e.validatorDstAddress),
e.entries
? (t.entries = e.entries.map((r) => (r ? lt.toJSON(r) : void 0)))
: (t.entries = []),
t
);
},
fromPartial(e) {
let t = Pw();
return (
(t.delegatorAddress = e.delegatorAddress ?? ""),
(t.validatorSrcAddress = e.validatorSrcAddress ?? ""),
(t.validatorDstAddress = e.validatorDstAddress ?? ""),
(t.entries = e.entries?.map((r) => lt.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return er.decode(e.value);
},
toProto(e) {
return er.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.Redelegation",
value: er.encode(e).finish(),
};
},
};
function kw() {
return { delegation: Xt.fromPartial({}), balance: G.fromPartial({}) };
}
var Tt = {
typeUrl: "/cosmos.staking.v1beta1.DelegationResponse",
annotations: {
"amino.dont_omitempty": { balance: !0, delegation: !0 },
"gogoproto.nullable": { balance: !1, delegation: !1 },
typeUrlFromField: { balance: () => G, delegation: () => Xt },
},
aminoType: "cosmos-sdk/DelegationResponse",
is(e) {
return (
e &&
(e.$typeUrl === Tt.typeUrl ||
(Xt.is(e.delegation) && G.is(e.balance)))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Tt.typeUrl ||
(Xt.isSDK(e.delegation) && G.isSDK(e.balance)))
);
},
encode(e, t = re.create()) {
return (
e.delegation !== void 0 &&
Xt.encode(e.delegation, t.uint32(10).fork()).ldelim(),
e.balance !== void 0 &&
G.encode(e.balance, t.uint32(18).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = kw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegation = Xt.decode(r, r.uint32());
break;
case 2:
n.balance = G.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegation: B(e.delegation) ? Xt.fromJSON(e.delegation) : void 0,
balance: B(e.balance) ? G.fromJSON(e.balance) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegation !== void 0 &&
(t.delegation = e.delegation ? Xt.toJSON(e.delegation) : void 0),
e.balance !== void 0 &&
(t.balance = e.balance ? G.toJSON(e.balance) : void 0),
t
);
},
fromPartial(e) {
let t = kw();
return (
(t.delegation =
e.delegation !== void 0 && e.delegation !== null
? Xt.fromPartial(e.delegation)
: void 0),
(t.balance =
e.balance !== void 0 && e.balance !== null
? G.fromPartial(e.balance)
: void 0),
t
);
},
fromProtoMsg(e) {
return Tt.decode(e.value);
},
toProto(e) {
return Tt.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.DelegationResponse",
value: Tt.encode(e).finish(),
};
},
};
function Iw() {
return { redelegationEntry: lt.fromPartial({}), balance: "" };
}
var Nr = {
typeUrl: "/cosmos.staking.v1beta1.RedelegationEntryResponse",
annotations: {
"amino.dont_omitempty": { redelegationEntry: !0 },
"gogoproto.nullable": { balance: !1, redelegationEntry: !1 },
typeUrlFromField: {
balance: "cosmos.Int",
redelegationEntry: () => lt,
},
},
aminoType: "cosmos-sdk/RedelegationEntryResponse",
is(e) {
return (
e &&
(e.$typeUrl === Nr.typeUrl ||
(lt.is(e.redelegationEntry) && typeof e.balance == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Nr.typeUrl ||
(lt.isSDK(e.redelegation_entry) && typeof e.balance == "string"))
);
},
encode(e, t = re.create()) {
return (
e.redelegationEntry !== void 0 &&
lt.encode(e.redelegationEntry, t.uint32(10).fork()).ldelim(),
e.balance !== "" && t.uint32(34).string(e.balance),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Iw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.redelegationEntry = lt.decode(r, r.uint32());
break;
case 4:
n.balance = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
redelegationEntry: B(e.redelegationEntry)
? lt.fromJSON(e.redelegationEntry)
: void 0,
balance: B(e.balance) ? String(e.balance) : "",
};
},
toJSON(e) {
let t = {};
return (
e.redelegationEntry !== void 0 &&
(t.redelegationEntry = e.redelegationEntry
? lt.toJSON(e.redelegationEntry)
: void 0),
e.balance !== void 0 && (t.balance = e.balance),
t
);
},
fromPartial(e) {
let t = Iw();
return (
(t.redelegationEntry =
e.redelegationEntry !== void 0 && e.redelegationEntry !== null
? lt.fromPartial(e.redelegationEntry)
: void 0),
(t.balance = e.balance ?? ""),
t
);
},
fromProtoMsg(e) {
return Nr.decode(e.value);
},
toProto(e) {
return Nr.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.RedelegationEntryResponse",
value: Nr.encode(e).finish(),
};
},
};
function Tw() {
return { redelegation: er.fromPartial({}), entries: [] };
}
var lr = {
typeUrl: "/cosmos.staking.v1beta1.RedelegationResponse",
annotations: {
"amino.dont_omitempty": { redelegation: !0 },
"gogoproto.nullable": { redelegation: !1 },
typeUrlFromField: { redelegation: () => er },
},
aminoType: "cosmos-sdk/RedelegationResponse",
is(e) {
return (
e &&
(e.$typeUrl === lr.typeUrl ||
(er.is(e.redelegation) &&
Array.isArray(e.entries) &&
(!e.entries.length || Nr.is(e.entries[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === lr.typeUrl ||
(er.isSDK(e.redelegation) &&
Array.isArray(e.entries) &&
(!e.entries.length || Nr.isSDK(e.entries[0]))))
);
},
encode(e, t = re.create()) {
e.redelegation !== void 0 &&
er.encode(e.redelegation, t.uint32(10).fork()).ldelim();
for (let r of e.entries) Nr.encode(r, t.uint32(18).fork()).ldelim();
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Tw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.redelegation = er.decode(r, r.uint32());
break;
case 2:
n.entries.push(Nr.decode(r, r.uint32()));
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
redelegation: B(e.redelegation)
? er.fromJSON(e.redelegation)
: void 0,
entries: Array.isArray(e?.entries)
? e.entries.map((t) => Nr.fromJSON(t))
: [],
};
},
toJSON(e) {
let t = {};
return (
e.redelegation !== void 0 &&
(t.redelegation = e.redelegation
? er.toJSON(e.redelegation)
: void 0),
e.entries
? (t.entries = e.entries.map((r) => (r ? Nr.toJSON(r) : void 0)))
: (t.entries = []),
t
);
},
fromPartial(e) {
let t = Tw();
return (
(t.redelegation =
e.redelegation !== void 0 && e.redelegation !== null
? er.fromPartial(e.redelegation)
: void 0),
(t.entries = e.entries?.map((r) => Nr.fromPartial(r)) || []),
t
);
},
fromProtoMsg(e) {
return lr.decode(e.value);
},
toProto(e) {
return lr.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.RedelegationResponse",
value: lr.encode(e).finish(),
};
},
};
function Uw() {
return { delegatorAddr: "", validatorAddr: "" };
}
var js = {
typeUrl: "/cosmos.staking.v1beta1.QueryDelegationRequest",
aminoType: "cosmos-sdk/QueryDelegationRequest",
is(e) {
return (
e &&
(e.$typeUrl === js.typeUrl ||
(typeof e.delegatorAddr == "string" &&
typeof e.validatorAddr == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === js.typeUrl ||
(typeof e.delegator_addr == "string" &&
typeof e.validator_addr == "string"))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddr !== "" && t.uint32(10).string(e.delegatorAddr),
e.validatorAddr !== "" && t.uint32(18).string(e.validatorAddr),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Uw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddr = r.string();
break;
case 2:
n.validatorAddr = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddr: B(e.delegatorAddr) ? String(e.delegatorAddr) : "",
validatorAddr: B(e.validatorAddr) ? String(e.validatorAddr) : "",
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddr !== void 0 && (t.delegatorAddr = e.delegatorAddr),
e.validatorAddr !== void 0 && (t.validatorAddr = e.validatorAddr),
t
);
},
fromPartial(e) {
let t = Uw();
return (
(t.delegatorAddr = e.delegatorAddr ?? ""),
(t.validatorAddr = e.validatorAddr ?? ""),
t
);
},
fromProtoMsg(e) {
return js.decode(e.value);
},
toProto(e) {
return js.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.QueryDelegationRequest",
value: js.encode(e).finish(),
};
},
};
function Cw() {
return { delegationResponse: void 0 };
}
var Gs = {
typeUrl: "/cosmos.staking.v1beta1.QueryDelegationResponse",
aminoType: "cosmos-sdk/QueryDelegationResponse",
is(e) {
return e && e.$typeUrl === Gs.typeUrl;
},
isSDK(e) {
return e && e.$typeUrl === Gs.typeUrl;
},
encode(e, t = re.create()) {
return (
e.delegationResponse !== void 0 &&
Tt.encode(e.delegationResponse, t.uint32(10).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Cw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegationResponse = Tt.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegationResponse: B(e.delegationResponse)
? Tt.fromJSON(e.delegationResponse)
: void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegationResponse !== void 0 &&
(t.delegationResponse = e.delegationResponse
? Tt.toJSON(e.delegationResponse)
: void 0),
t
);
},
fromPartial(e) {
let t = Cw();
return (
(t.delegationResponse =
e.delegationResponse !== void 0 && e.delegationResponse !== null
? Tt.fromPartial(e.delegationResponse)
: void 0),
t
);
},
fromProtoMsg(e) {
return Gs.decode(e.value);
},
toProto(e) {
return Gs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.QueryDelegationResponse",
value: Gs.encode(e).finish(),
};
},
};
function Rw() {
return { delegatorAddr: "", validatorAddr: "" };
}
var Qs = {
typeUrl: "/cosmos.staking.v1beta1.QueryUnbondingDelegationRequest",
aminoType: "cosmos-sdk/QueryUnbondingDelegationRequest",
is(e) {
return (
e &&
(e.$typeUrl === Qs.typeUrl ||
(typeof e.delegatorAddr == "string" &&
typeof e.validatorAddr == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Qs.typeUrl ||
(typeof e.delegator_addr == "string" &&
typeof e.validator_addr == "string"))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddr !== "" && t.uint32(10).string(e.delegatorAddr),
e.validatorAddr !== "" && t.uint32(18).string(e.validatorAddr),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Rw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddr = r.string();
break;
case 2:
n.validatorAddr = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddr: B(e.delegatorAddr) ? String(e.delegatorAddr) : "",
validatorAddr: B(e.validatorAddr) ? String(e.validatorAddr) : "",
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddr !== void 0 && (t.delegatorAddr = e.delegatorAddr),
e.validatorAddr !== void 0 && (t.validatorAddr = e.validatorAddr),
t
);
},
fromPartial(e) {
let t = Rw();
return (
(t.delegatorAddr = e.delegatorAddr ?? ""),
(t.validatorAddr = e.validatorAddr ?? ""),
t
);
},
fromProtoMsg(e) {
return Qs.decode(e.value);
},
toProto(e) {
return Qs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.QueryUnbondingDelegationRequest",
value: Qs.encode(e).finish(),
};
},
};
function Ow() {
return { unbond: at.fromPartial({}) };
}
var zs = {
typeUrl: "/cosmos.staking.v1beta1.QueryUnbondingDelegationResponse",
annotations: {
"amino.dont_omitempty": { unbond: !0 },
"gogoproto.nullable": { unbond: !1 },
typeUrlFromField: { unbond: () => at },
},
aminoType: "cosmos-sdk/QueryUnbondingDelegationResponse",
is(e) {
return e && (e.$typeUrl === zs.typeUrl || at.is(e.unbond));
},
isSDK(e) {
return e && (e.$typeUrl === zs.typeUrl || at.isSDK(e.unbond));
},
encode(e, t = re.create()) {
return (
e.unbond !== void 0 &&
at.encode(e.unbond, t.uint32(10).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Ow();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.unbond = at.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return { unbond: B(e.unbond) ? at.fromJSON(e.unbond) : void 0 };
},
toJSON(e) {
let t = {};
return (
e.unbond !== void 0 &&
(t.unbond = e.unbond ? at.toJSON(e.unbond) : void 0),
t
);
},
fromPartial(e) {
let t = Ow();
return (
(t.unbond =
e.unbond !== void 0 && e.unbond !== null
? at.fromPartial(e.unbond)
: void 0),
t
);
},
fromProtoMsg(e) {
return zs.decode(e.value);
},
toProto(e) {
return zs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.QueryUnbondingDelegationResponse",
value: zs.encode(e).finish(),
};
},
};
function Ew() {
return { delegatorAddr: "", pagination: void 0 };
}
var Ys = {
typeUrl: "/cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest",
aminoType: "cosmos-sdk/QueryDelegatorDelegationsRequest",
is(e) {
return (
e && (e.$typeUrl === Ys.typeUrl || typeof e.delegatorAddr == "string")
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ys.typeUrl || typeof e.delegator_addr == "string")
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddr !== "" && t.uint32(10).string(e.delegatorAddr),
e.pagination !== void 0 &&
Ge.encode(e.pagination, t.uint32(18).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Ew();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddr = r.string();
break;
case 2:
n.pagination = Ge.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddr: B(e.delegatorAddr) ? String(e.delegatorAddr) : "",
pagination: B(e.pagination) ? Ge.fromJSON(e.pagination) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddr !== void 0 && (t.delegatorAddr = e.delegatorAddr),
e.pagination !== void 0 &&
(t.pagination = e.pagination ? Ge.toJSON(e.pagination) : void 0),
t
);
},
fromPartial(e) {
let t = Ew();
return (
(t.delegatorAddr = e.delegatorAddr ?? ""),
(t.pagination =
e.pagination !== void 0 && e.pagination !== null
? Ge.fromPartial(e.pagination)
: void 0),
t
);
},
fromProtoMsg(e) {
return Ys.decode(e.value);
},
toProto(e) {
return Ys.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest",
value: Ys.encode(e).finish(),
};
},
};
function Dw() {
return { delegationResponses: [], pagination: void 0 };
}
var Zs = {
typeUrl: "/cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse",
aminoType: "cosmos-sdk/QueryDelegatorDelegationsResponse",
is(e) {
return (
e &&
(e.$typeUrl === Zs.typeUrl ||
(Array.isArray(e.delegationResponses) &&
(!e.delegationResponses.length ||
Tt.is(e.delegationResponses[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Zs.typeUrl ||
(Array.isArray(e.delegation_responses) &&
(!e.delegation_responses.length ||
Tt.isSDK(e.delegation_responses[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.delegationResponses)
Tt.encode(r, t.uint32(10).fork()).ldelim();
return (
e.pagination !== void 0 &&
Qe.encode(e.pagination, t.uint32(18).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Dw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegationResponses.push(Tt.decode(r, r.uint32()));
break;
case 2:
n.pagination = Qe.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegationResponses: Array.isArray(e?.delegationResponses)
? e.delegationResponses.map((t) => Tt.fromJSON(t))
: [],
pagination: B(e.pagination) ? Qe.fromJSON(e.pagination) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegationResponses
? (t.delegationResponses = e.delegationResponses.map((r) =>
r ? Tt.toJSON(r) : void 0,
))
: (t.delegationResponses = []),
e.pagination !== void 0 &&
(t.pagination = e.pagination ? Qe.toJSON(e.pagination) : void 0),
t
);
},
fromPartial(e) {
let t = Dw();
return (
(t.delegationResponses =
e.delegationResponses?.map((r) => Tt.fromPartial(r)) || []),
(t.pagination =
e.pagination !== void 0 && e.pagination !== null
? Qe.fromPartial(e.pagination)
: void 0),
t
);
},
fromProtoMsg(e) {
return Zs.decode(e.value);
},
toProto(e) {
return Zs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse",
value: Zs.encode(e).finish(),
};
},
};
function Nw() {
return { delegatorAddr: "", pagination: void 0 };
}
var Xs = {
typeUrl:
"/cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest",
aminoType: "cosmos-sdk/QueryDelegatorUnbondingDelegationsRequest",
is(e) {
return (
e && (e.$typeUrl === Xs.typeUrl || typeof e.delegatorAddr == "string")
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Xs.typeUrl || typeof e.delegator_addr == "string")
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddr !== "" && t.uint32(10).string(e.delegatorAddr),
e.pagination !== void 0 &&
Ge.encode(e.pagination, t.uint32(18).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Nw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddr = r.string();
break;
case 2:
n.pagination = Ge.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddr: B(e.delegatorAddr) ? String(e.delegatorAddr) : "",
pagination: B(e.pagination) ? Ge.fromJSON(e.pagination) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddr !== void 0 && (t.delegatorAddr = e.delegatorAddr),
e.pagination !== void 0 &&
(t.pagination = e.pagination ? Ge.toJSON(e.pagination) : void 0),
t
);
},
fromPartial(e) {
let t = Nw();
return (
(t.delegatorAddr = e.delegatorAddr ?? ""),
(t.pagination =
e.pagination !== void 0 && e.pagination !== null
? Ge.fromPartial(e.pagination)
: void 0),
t
);
},
fromProtoMsg(e) {
return Xs.decode(e.value);
},
toProto(e) {
return Xs.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl:
"/cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest",
value: Xs.encode(e).finish(),
};
},
};
function Bw() {
return { unbondingResponses: [], pagination: void 0 };
}
var ea = {
typeUrl:
"/cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse",
aminoType: "cosmos-sdk/QueryDelegatorUnbondingDelegationsResponse",
is(e) {
return (
e &&
(e.$typeUrl === ea.typeUrl ||
(Array.isArray(e.unbondingResponses) &&
(!e.unbondingResponses.length || at.is(e.unbondingResponses[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === ea.typeUrl ||
(Array.isArray(e.unbonding_responses) &&
(!e.unbonding_responses.length ||
at.isSDK(e.unbonding_responses[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.unbondingResponses)
at.encode(r, t.uint32(10).fork()).ldelim();
return (
e.pagination !== void 0 &&
Qe.encode(e.pagination, t.uint32(18).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Bw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.unbondingResponses.push(at.decode(r, r.uint32()));
break;
case 2:
n.pagination = Qe.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
unbondingResponses: Array.isArray(e?.unbondingResponses)
? e.unbondingResponses.map((t) => at.fromJSON(t))
: [],
pagination: B(e.pagination) ? Qe.fromJSON(e.pagination) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.unbondingResponses
? (t.unbondingResponses = e.unbondingResponses.map((r) =>
r ? at.toJSON(r) : void 0,
))
: (t.unbondingResponses = []),
e.pagination !== void 0 &&
(t.pagination = e.pagination ? Qe.toJSON(e.pagination) : void 0),
t
);
},
fromPartial(e) {
let t = Bw();
return (
(t.unbondingResponses =
e.unbondingResponses?.map((r) => at.fromPartial(r)) || []),
(t.pagination =
e.pagination !== void 0 && e.pagination !== null
? Qe.fromPartial(e.pagination)
: void 0),
t
);
},
fromProtoMsg(e) {
return ea.decode(e.value);
},
toProto(e) {
return ea.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl:
"/cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse",
value: ea.encode(e).finish(),
};
},
};
function Mw() {
return {
delegatorAddr: "",
srcValidatorAddr: "",
dstValidatorAddr: "",
pagination: void 0,
};
}
var ta = {
typeUrl: "/cosmos.staking.v1beta1.QueryRedelegationsRequest",
aminoType: "cosmos-sdk/QueryRedelegationsRequest",
is(e) {
return (
e &&
(e.$typeUrl === ta.typeUrl ||
(typeof e.delegatorAddr == "string" &&
typeof e.srcValidatorAddr == "string" &&
typeof e.dstValidatorAddr == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === ta.typeUrl ||
(typeof e.delegator_addr == "string" &&
typeof e.src_validator_addr == "string" &&
typeof e.dst_validator_addr == "string"))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddr !== "" && t.uint32(10).string(e.delegatorAddr),
e.srcValidatorAddr !== "" && t.uint32(18).string(e.srcValidatorAddr),
e.dstValidatorAddr !== "" && t.uint32(26).string(e.dstValidatorAddr),
e.pagination !== void 0 &&
Ge.encode(e.pagination, t.uint32(34).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Mw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddr = r.string();
break;
case 2:
n.srcValidatorAddr = r.string();
break;
case 3:
n.dstValidatorAddr = r.string();
break;
case 4:
n.pagination = Ge.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddr: B(e.delegatorAddr) ? String(e.delegatorAddr) : "",
srcValidatorAddr: B(e.srcValidatorAddr)
? String(e.srcValidatorAddr)
: "",
dstValidatorAddr: B(e.dstValidatorAddr)
? String(e.dstValidatorAddr)
: "",
pagination: B(e.pagination) ? Ge.fromJSON(e.pagination) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddr !== void 0 && (t.delegatorAddr = e.delegatorAddr),
e.srcValidatorAddr !== void 0 &&
(t.srcValidatorAddr = e.srcValidatorAddr),
e.dstValidatorAddr !== void 0 &&
(t.dstValidatorAddr = e.dstValidatorAddr),
e.pagination !== void 0 &&
(t.pagination = e.pagination ? Ge.toJSON(e.pagination) : void 0),
t
);
},
fromPartial(e) {
let t = Mw();
return (
(t.delegatorAddr = e.delegatorAddr ?? ""),
(t.srcValidatorAddr = e.srcValidatorAddr ?? ""),
(t.dstValidatorAddr = e.dstValidatorAddr ?? ""),
(t.pagination =
e.pagination !== void 0 && e.pagination !== null
? Ge.fromPartial(e.pagination)
: void 0),
t
);
},
fromProtoMsg(e) {
return ta.decode(e.value);
},
toProto(e) {
return ta.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.QueryRedelegationsRequest",
value: ta.encode(e).finish(),
};
},
};
function $w() {
return { redelegationResponses: [], pagination: void 0 };
}
var ra = {
typeUrl: "/cosmos.staking.v1beta1.QueryRedelegationsResponse",
aminoType: "cosmos-sdk/QueryRedelegationsResponse",
is(e) {
return (
e &&
(e.$typeUrl === ra.typeUrl ||
(Array.isArray(e.redelegationResponses) &&
(!e.redelegationResponses.length ||
lr.is(e.redelegationResponses[0]))))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === ra.typeUrl ||
(Array.isArray(e.redelegation_responses) &&
(!e.redelegation_responses.length ||
lr.isSDK(e.redelegation_responses[0]))))
);
},
encode(e, t = re.create()) {
for (let r of e.redelegationResponses)
lr.encode(r, t.uint32(10).fork()).ldelim();
return (
e.pagination !== void 0 &&
Qe.encode(e.pagination, t.uint32(18).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = $w();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.redelegationResponses.push(lr.decode(r, r.uint32()));
break;
case 2:
n.pagination = Qe.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
redelegationResponses: Array.isArray(e?.redelegationResponses)
? e.redelegationResponses.map((t) => lr.fromJSON(t))
: [],
pagination: B(e.pagination) ? Qe.fromJSON(e.pagination) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.redelegationResponses
? (t.redelegationResponses = e.redelegationResponses.map((r) =>
r ? lr.toJSON(r) : void 0,
))
: (t.redelegationResponses = []),
e.pagination !== void 0 &&
(t.pagination = e.pagination ? Qe.toJSON(e.pagination) : void 0),
t
);
},
fromPartial(e) {
let t = $w();
return (
(t.redelegationResponses =
e.redelegationResponses?.map((r) => lr.fromPartial(r)) || []),
(t.pagination =
e.pagination !== void 0 && e.pagination !== null
? Qe.fromPartial(e.pagination)
: void 0),
t
);
},
fromProtoMsg(e) {
return ra.decode(e.value);
},
toProto(e) {
return ra.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.QueryRedelegationsResponse",
value: ra.encode(e).finish(),
};
},
};
function _w() {
return {
delegatorAddress: "",
validatorAddress: "",
amount: G.fromPartial({}),
};
}
var sn = {
typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
annotations: {
"amino.dont_omitempty": { amount: !0 },
"gogoproto.nullable": { amount: !1 },
typeUrlFromField: { amount: () => G },
},
aminoType: "cosmos-sdk/MsgDelegate",
is(e) {
return (
e &&
(e.$typeUrl === sn.typeUrl ||
(typeof e.delegatorAddress == "string" &&
typeof e.validatorAddress == "string" &&
G.is(e.amount)))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === sn.typeUrl ||
(typeof e.delegator_address == "string" &&
typeof e.validator_address == "string" &&
G.isSDK(e.amount)))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
e.validatorAddress !== "" && t.uint32(18).string(e.validatorAddress),
e.amount !== void 0 &&
G.encode(e.amount, t.uint32(26).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = _w();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
case 2:
n.validatorAddress = r.string();
break;
case 3:
n.amount = G.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
validatorAddress: B(e.validatorAddress)
? String(e.validatorAddress)
: "",
amount: B(e.amount) ? G.fromJSON(e.amount) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
e.validatorAddress !== void 0 &&
(t.validatorAddress = e.validatorAddress),
e.amount !== void 0 &&
(t.amount = e.amount ? G.toJSON(e.amount) : void 0),
t
);
},
fromPartial(e) {
let t = _w();
return (
(t.delegatorAddress = e.delegatorAddress ?? ""),
(t.validatorAddress = e.validatorAddress ?? ""),
(t.amount =
e.amount !== void 0 && e.amount !== null
? G.fromPartial(e.amount)
: void 0),
t
);
},
fromProtoMsg(e) {
return sn.decode(e.value);
},
toProto(e) {
return sn.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
value: sn.encode(e).finish(),
};
},
};
function Fw() {
return {};
}
var oa = {
typeUrl: "/cosmos.staking.v1beta1.MsgDelegateResponse",
aminoType: "cosmos-sdk/MsgDelegateResponse",
is(e) {
return e && e.$typeUrl === oa.typeUrl;
},
isSDK(e) {
return e && e.$typeUrl === oa.typeUrl;
},
encode(e, t = re.create()) {
return t;
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Fw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {};
},
toJSON(e) {
return {};
},
fromPartial(e) {
return Fw();
},
fromProtoMsg(e) {
return oa.decode(e.value);
},
toProto(e) {
return oa.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.MsgDelegateResponse",
value: oa.encode(e).finish(),
};
},
};
function Kw() {
return {
delegatorAddress: "",
validatorSrcAddress: "",
validatorDstAddress: "",
amount: G.fromPartial({}),
};
}
var na = {
typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
annotations: {
"amino.dont_omitempty": { amount: !0 },
"gogoproto.nullable": { amount: !1 },
typeUrlFromField: { amount: () => G },
},
aminoType: "cosmos-sdk/MsgBeginRedelegate",
is(e) {
return (
e &&
(e.$typeUrl === na.typeUrl ||
(typeof e.delegatorAddress == "string" &&
typeof e.validatorSrcAddress == "string" &&
typeof e.validatorDstAddress == "string" &&
G.is(e.amount)))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === na.typeUrl ||
(typeof e.delegator_address == "string" &&
typeof e.validator_src_address == "string" &&
typeof e.validator_dst_address == "string" &&
G.isSDK(e.amount)))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
e.validatorSrcAddress !== "" &&
t.uint32(18).string(e.validatorSrcAddress),
e.validatorDstAddress !== "" &&
t.uint32(26).string(e.validatorDstAddress),
e.amount !== void 0 &&
G.encode(e.amount, t.uint32(34).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Kw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
case 2:
n.validatorSrcAddress = r.string();
break;
case 3:
n.validatorDstAddress = r.string();
break;
case 4:
n.amount = G.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
validatorSrcAddress: B(e.validatorSrcAddress)
? String(e.validatorSrcAddress)
: "",
validatorDstAddress: B(e.validatorDstAddress)
? String(e.validatorDstAddress)
: "",
amount: B(e.amount) ? G.fromJSON(e.amount) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
e.validatorSrcAddress !== void 0 &&
(t.validatorSrcAddress = e.validatorSrcAddress),
e.validatorDstAddress !== void 0 &&
(t.validatorDstAddress = e.validatorDstAddress),
e.amount !== void 0 &&
(t.amount = e.amount ? G.toJSON(e.amount) : void 0),
t
);
},
fromPartial(e) {
let t = Kw();
return (
(t.delegatorAddress = e.delegatorAddress ?? ""),
(t.validatorSrcAddress = e.validatorSrcAddress ?? ""),
(t.validatorDstAddress = e.validatorDstAddress ?? ""),
(t.amount =
e.amount !== void 0 && e.amount !== null
? G.fromPartial(e.amount)
: void 0),
t
);
},
fromProtoMsg(e) {
return na.decode(e.value);
},
toProto(e) {
return na.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
value: na.encode(e).finish(),
};
},
};
function Jw() {
return { completionTime: we.fromPartial({}) };
}
var sa = {
typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegateResponse",
annotations: {
"amino.dont_omitempty": { completionTime: !0 },
"gogoproto.nullable": { completionTime: !1 },
typeUrlFromField: { completionTime: () => we },
},
aminoType: "cosmos-sdk/MsgBeginRedelegateResponse",
is(e) {
return e && (e.$typeUrl === sa.typeUrl || we.is(e.completionTime));
},
isSDK(e) {
return e && (e.$typeUrl === sa.typeUrl || we.isSDK(e.completion_time));
},
encode(e, t = re.create()) {
return (
e.completionTime !== void 0 &&
we.encode(e.completionTime, t.uint32(10).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Jw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.completionTime = we.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
completionTime: B(e.completionTime) ? Ur(e.completionTime) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.completionTime !== void 0 &&
(t.completionTime = Tr(e.completionTime).toISOString()),
t
);
},
fromPartial(e) {
let t = Jw();
return (
(t.completionTime =
e.completionTime !== void 0 && e.completionTime !== null
? we.fromPartial(e.completionTime)
: void 0),
t
);
},
fromProtoMsg(e) {
return sa.decode(e.value);
},
toProto(e) {
return sa.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegateResponse",
value: sa.encode(e).finish(),
};
},
};
function Vw() {
return {
delegatorAddress: "",
validatorAddress: "",
amount: G.fromPartial({}),
};
}
var an = {
typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
annotations: {
"amino.dont_omitempty": { amount: !0 },
"gogoproto.nullable": { amount: !1 },
typeUrlFromField: { amount: () => G },
},
aminoType: "cosmos-sdk/MsgUndelegate",
is(e) {
return (
e &&
(e.$typeUrl === an.typeUrl ||
(typeof e.delegatorAddress == "string" &&
typeof e.validatorAddress == "string" &&
G.is(e.amount)))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === an.typeUrl ||
(typeof e.delegator_address == "string" &&
typeof e.validator_address == "string" &&
G.isSDK(e.amount)))
);
},
encode(e, t = re.create()) {
return (
e.delegatorAddress !== "" && t.uint32(10).string(e.delegatorAddress),
e.validatorAddress !== "" && t.uint32(18).string(e.validatorAddress),
e.amount !== void 0 &&
G.encode(e.amount, t.uint32(26).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Vw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.delegatorAddress = r.string();
break;
case 2:
n.validatorAddress = r.string();
break;
case 3:
n.amount = G.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
delegatorAddress: B(e.delegatorAddress)
? String(e.delegatorAddress)
: "",
validatorAddress: B(e.validatorAddress)
? String(e.validatorAddress)
: "",
amount: B(e.amount) ? G.fromJSON(e.amount) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.delegatorAddress !== void 0 &&
(t.delegatorAddress = e.delegatorAddress),
e.validatorAddress !== void 0 &&
(t.validatorAddress = e.validatorAddress),
e.amount !== void 0 &&
(t.amount = e.amount ? G.toJSON(e.amount) : void 0),
t
);
},
fromPartial(e) {
let t = Vw();
return (
(t.delegatorAddress = e.delegatorAddress ?? ""),
(t.validatorAddress = e.validatorAddress ?? ""),
(t.amount =
e.amount !== void 0 && e.amount !== null
? G.fromPartial(e.amount)
: void 0),
t
);
},
fromProtoMsg(e) {
return an.decode(e.value);
},
toProto(e) {
return an.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
value: an.encode(e).finish(),
};
},
};
function Hw() {
return { completionTime: we.fromPartial({}), amount: G.fromPartial({}) };
}
var aa = {
typeUrl: "/cosmos.staking.v1beta1.MsgUndelegateResponse",
annotations: {
"amino.dont_omitempty": { amount: !0, completionTime: !0 },
"gogoproto.nullable": { amount: !1, completionTime: !1 },
typeUrlFromField: { amount: () => G, completionTime: () => we },
},
aminoType: "cosmos-sdk/MsgUndelegateResponse",
is(e) {
return (
e &&
(e.$typeUrl === aa.typeUrl ||
(we.is(e.completionTime) && G.is(e.amount)))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === aa.typeUrl ||
(we.isSDK(e.completion_time) && G.isSDK(e.amount)))
);
},
encode(e, t = re.create()) {
return (
e.completionTime !== void 0 &&
we.encode(e.completionTime, t.uint32(10).fork()).ldelim(),
e.amount !== void 0 &&
G.encode(e.amount, t.uint32(18).fork()).ldelim(),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Hw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.completionTime = we.decode(r, r.uint32());
break;
case 2:
n.amount = G.decode(r, r.uint32());
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
completionTime: B(e.completionTime) ? Ur(e.completionTime) : void 0,
amount: B(e.amount) ? G.fromJSON(e.amount) : void 0,
};
},
toJSON(e) {
let t = {};
return (
e.completionTime !== void 0 &&
(t.completionTime = Tr(e.completionTime).toISOString()),
e.amount !== void 0 &&
(t.amount = e.amount ? G.toJSON(e.amount) : void 0),
t
);
},
fromPartial(e) {
let t = Hw();
return (
(t.completionTime =
e.completionTime !== void 0 && e.completionTime !== null
? we.fromPartial(e.completionTime)
: void 0),
(t.amount =
e.amount !== void 0 && e.amount !== null
? G.fromPartial(e.amount)
: void 0),
t
);
},
fromProtoMsg(e) {
return aa.decode(e.value);
},
toProto(e) {
return aa.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/cosmos.staking.v1beta1.MsgUndelegateResponse",
value: aa.encode(e).finish(),
};
},
};
function Ww() {
return { revisionNumber: BigInt(0), revisionHeight: BigInt(0) };
}
var Ht = {
typeUrl: "/ibc.core.client.v1.Height",
aminoType: "cosmos-sdk/Height",
is(e) {
return (
e &&
(e.$typeUrl === Ht.typeUrl ||
(typeof e.revisionNumber == "bigint" &&
typeof e.revisionHeight == "bigint"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === Ht.typeUrl ||
(typeof e.revision_number == "bigint" &&
typeof e.revision_height == "bigint"))
);
},
encode(e, t = re.create()) {
return (
e.revisionNumber !== BigInt(0) &&
t.uint32(8).uint64(e.revisionNumber),
e.revisionHeight !== BigInt(0) &&
t.uint32(16).uint64(e.revisionHeight),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Ww();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.revisionNumber = r.uint64();
break;
case 2:
n.revisionHeight = r.uint64();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
revisionNumber: B(e.revisionNumber)
? BigInt(e.revisionNumber.toString())
: BigInt(0),
revisionHeight: B(e.revisionHeight)
? BigInt(e.revisionHeight.toString())
: BigInt(0),
};
},
toJSON(e) {
let t = {};
return (
e.revisionNumber !== void 0 &&
(t.revisionNumber = (e.revisionNumber || BigInt(0)).toString()),
e.revisionHeight !== void 0 &&
(t.revisionHeight = (e.revisionHeight || BigInt(0)).toString()),
t
);
},
fromPartial(e) {
let t = Ww();
return (
(t.revisionNumber =
e.revisionNumber !== void 0 && e.revisionNumber !== null
? BigInt(e.revisionNumber.toString())
: BigInt(0)),
(t.revisionHeight =
e.revisionHeight !== void 0 && e.revisionHeight !== null
? BigInt(e.revisionHeight.toString())
: BigInt(0)),
t
);
},
fromProtoMsg(e) {
return Ht.decode(e.value);
},
toProto(e) {
return Ht.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/ibc.core.client.v1.Height",
value: Ht.encode(e).finish(),
};
},
};
function Lw() {
return {
sourcePort: "",
sourceChannel: "",
token: G.fromPartial({}),
sender: "",
receiver: "",
timeoutHeight: Ht.fromPartial({}),
timeoutTimestamp: BigInt(0),
memo: "",
encoding: "",
};
}
var cn = {
typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
annotations: {
"amino.dont_omitempty": { timeoutHeight: !0, token: !0 },
"gogoproto.nullable": { timeoutHeight: !1, token: !1 },
typeUrlFromField: { timeoutHeight: () => Ht, token: () => G },
},
aminoType: "cosmos-sdk/MsgTransfer",
is(e) {
return (
e &&
(e.$typeUrl === cn.typeUrl ||
(typeof e.sourcePort == "string" &&
typeof e.sourceChannel == "string" &&
G.is(e.token) &&
typeof e.sender == "string" &&
typeof e.receiver == "string" &&
Ht.is(e.timeoutHeight) &&
typeof e.timeoutTimestamp == "bigint" &&
typeof e.memo == "string" &&
typeof e.encoding == "string"))
);
},
isSDK(e) {
return (
e &&
(e.$typeUrl === cn.typeUrl ||
(typeof e.source_port == "string" &&
typeof e.source_channel == "string" &&
G.isSDK(e.token) &&
typeof e.sender == "string" &&
typeof e.receiver == "string" &&
Ht.isSDK(e.timeout_height) &&
typeof e.timeout_timestamp == "bigint" &&
typeof e.memo == "string" &&
typeof e.encoding == "string"))
);
},
encode(e, t = re.create()) {
return (
e.sourcePort !== "" && t.uint32(10).string(e.sourcePort),
e.sourceChannel !== "" && t.uint32(18).string(e.sourceChannel),
e.token !== void 0 && G.encode(e.token, t.uint32(26).fork()).ldelim(),
e.sender !== "" && t.uint32(34).string(e.sender),
e.receiver !== "" && t.uint32(42).string(e.receiver),
e.timeoutHeight !== void 0 &&
Ht.encode(e.timeoutHeight, t.uint32(50).fork()).ldelim(),
e.timeoutTimestamp !== BigInt(0) &&
t.uint32(56).uint64(e.timeoutTimestamp),
e.memo !== "" && t.uint32(66).string(e.memo),
e.encoding !== "" && t.uint32(74).string(e.encoding),
t
);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = Lw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.sourcePort = r.string();
break;
case 2:
n.sourceChannel = r.string();
break;
case 3:
n.token = G.decode(r, r.uint32());
break;
case 4:
n.sender = r.string();
break;
case 5:
n.receiver = r.string();
break;
case 6:
n.timeoutHeight = Ht.decode(r, r.uint32());
break;
case 7:
n.timeoutTimestamp = r.uint64();
break;
case 8:
n.memo = r.string();
break;
case 9:
n.encoding = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
sourcePort: B(e.sourcePort) ? String(e.sourcePort) : "",
sourceChannel: B(e.sourceChannel) ? String(e.sourceChannel) : "",
token: B(e.token) ? G.fromJSON(e.token) : void 0,
sender: B(e.sender) ? String(e.sender) : "",
receiver: B(e.receiver) ? String(e.receiver) : "",
timeoutHeight: B(e.timeoutHeight)
? Ht.fromJSON(e.timeoutHeight)
: void 0,
timeoutTimestamp: B(e.timeoutTimestamp)
? BigInt(e.timeoutTimestamp.toString())
: BigInt(0),
memo: B(e.memo) ? String(e.memo) : "",
encoding: B(e.encoding) ? String(e.encoding) : "",
};
},
toJSON(e) {
let t = {};
return (
e.sourcePort !== void 0 && (t.sourcePort = e.sourcePort),
e.sourceChannel !== void 0 && (t.sourceChannel = e.sourceChannel),
e.token !== void 0 &&
(t.token = e.token ? G.toJSON(e.token) : void 0),
e.sender !== void 0 && (t.sender = e.sender),
e.receiver !== void 0 && (t.receiver = e.receiver),
e.timeoutHeight !== void 0 &&
(t.timeoutHeight = e.timeoutHeight
? Ht.toJSON(e.timeoutHeight)
: void 0),
e.timeoutTimestamp !== void 0 &&
(t.timeoutTimestamp = (e.timeoutTimestamp || BigInt(0)).toString()),
e.memo !== void 0 && (t.memo = e.memo),
e.encoding !== void 0 && (t.encoding = e.encoding),
t
);
},
fromPartial(e) {
let t = Lw();
return (
(t.sourcePort = e.sourcePort ?? ""),
(t.sourceChannel = e.sourceChannel ?? ""),
(t.token =
e.token !== void 0 && e.token !== null
? G.fromPartial(e.token)
: void 0),
(t.sender = e.sender ?? ""),
(t.receiver = e.receiver ?? ""),
(t.timeoutHeight =
e.timeoutHeight !== void 0 && e.timeoutHeight !== null
? Ht.fromPartial(e.timeoutHeight)
: void 0),
(t.timeoutTimestamp =
e.timeoutTimestamp !== void 0 && e.timeoutTimestamp !== null
? BigInt(e.timeoutTimestamp.toString())
: BigInt(0)),
(t.memo = e.memo ?? ""),
(t.encoding = e.encoding ?? ""),
t
);
},
fromProtoMsg(e) {
return cn.decode(e.value);
},
toProto(e) {
return cn.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
value: cn.encode(e).finish(),
};
},
};
function qw() {
return { sequence: BigInt(0) };
}
var ia = {
typeUrl: "/ibc.applications.transfer.v1.MsgTransferResponse",
aminoType: "cosmos-sdk/MsgTransferResponse",
is(e) {
return (
e && (e.$typeUrl === ia.typeUrl || typeof e.sequence == "bigint")
);
},
isSDK(e) {
return (
e && (e.$typeUrl === ia.typeUrl || typeof e.sequence == "bigint")
);
},
encode(e, t = re.create()) {
return (e.sequence !== BigInt(0) && t.uint32(8).uint64(e.sequence), t);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = qw();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.sequence = r.uint64();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return {
sequence: B(e.sequence) ? BigInt(e.sequence.toString()) : BigInt(0),
};
},
toJSON(e) {
let t = {};
return (
e.sequence !== void 0 &&
(t.sequence = (e.sequence || BigInt(0)).toString()),
t
);
},
fromPartial(e) {
let t = qw();
return (
(t.sequence =
e.sequence !== void 0 && e.sequence !== null
? BigInt(e.sequence.toString())
: BigInt(0)),
t
);
},
fromProtoMsg(e) {
return ia.decode(e.value);
},
toProto(e) {
return ia.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/ibc.applications.transfer.v1.MsgTransferResponse",
value: ia.encode(e).finish(),
};
},
};
var Ky = pe(Ns),
PN = pe(Bs);
var Jy = pe(Ms),
kN = pe($s);
var Pu = pe(nn),
IN = pe(Ks);
var Vy = pe(Ls);
var TN = pe(qs),
Hy = pe(on),
Wy = pe(Fs);
var Ly = pe(rn),
qy = pe(_s);
var jy = pe(Js);
var Gy = pe(Vs),
Qy = pe(Hs),
zy = pe(Ws);
var Yy = pe(js),
Zy = pe(Gs);
var Xy = pe(Ys),
eg = pe(Zs);
var tg = pe(Xs),
rg = pe(ea);
var og = pe(ta),
ng = pe(ra);
var sg = pe(Qs),
ag = pe(zs);
var ig = pe(na),
UN = pe(sa);
var cg = pe(sn),
CN = pe(oa);
var dg = pe(an),
RN = pe(aa);
var lg = pe(cn),
ON = pe(ia);
var jw = pe(fe),
EN = { toJSON: (e) => jw.toJSON(e) },
dn = Object.freeze({ ...jw, ...EN });
var Gw = {
[Ky.typeUrl]: PN,
[Jy.typeUrl]: kN,
[dg.typeUrl]: RN,
[ig.typeUrl]: UN,
[cg.typeUrl]: CN,
[Vy.typeUrl]: TN,
[Pu.typeUrl]: IN,
[lg.typeUrl]: ON,
[Ly.typeUrl]: qy,
[Hy.typeUrl]: Wy,
[Yy.typeUrl]: Zy,
[Xy.typeUrl]: eg,
[tg.typeUrl]: rg,
[og.typeUrl]: ng,
[sg.typeUrl]: ag,
[jy.typeUrl]: Gy,
[Qy.typeUrl]: zy,
};
var Qw = ["redelegationQueryWatcher", "transferWatcher"],
rt = Ae("CosmosOrchAccount"),
{ Vow$: un } = dt,
pi = (e) => s.or(un(e), s.promise()),
ln = (e, t) => {
try {
let r = ke(t.key || t.value);
return e.decode(r);
} catch (r) {
throw Se(`Failed to parse ${e.typeUrl} from result ${x(t)}`, void 0, {
cause: r,
});
}
},
DN = {
delegate: s.call(je, Jt).optional(Gr).returns(le),
redelegate: s.call(je, je, Jt).optional(Gr).returns(le),
undelegate: s.call(s.arrayOf(ay)).optional(Gr).returns(le),
withdrawReward: s
.call(je)
.optional(Gr)
.returns(un(s.arrayOf(bt))),
withdrawRewards: s
.call()
.optional(Gr)
.returns(un(s.arrayOf(bt))),
},
NN = {
getDelegation: s.call(je).optional(Jn).returns(le),
getDelegations: s.call().optional(Jn).returns(le),
getUnbondingDelegation: s.call(je).optional(Jn).returns(le),
getUnbondingDelegations: s.call().optional(Jn).returns(le),
getRedelegations: s.call().optional(Jn).returns(le),
getReward: s.call(je).optional(Jn).returns(le),
getRewards: s.call().optional(Jn).returns(le),
},
BN = {
depositForBurn: s
.call(s.string(), Jt)
.optional(s.string(), Gr)
.returns(le),
},
MN = {
deactivate: s.call().returns(le),
reactivate: s.call().returns(le),
executeEncodedTx: s
.call(s.arrayOf(ks))
.optional(zl)
.returns(pi(s.string())),
executeTxProto3: s
.call(s.arrayOf(ks))
.optional(Gr)
.returns(pi(s.array())),
executeTxProto3Undecoded: s
.call(s.arrayOf(ks))
.optional(Gr)
.returns(pi(s.string())),
},
$N = s.interface("IcaAccountHolder", {
...BN,
...Su,
...DN,
...NN,
...MN,
}),
zw = { account: ["Staking Account holder status", s.any()] },
Yw = s.interface("invitationMakers", {
Delegate: s.call(je, Jt).returns(s.promise()),
Redelegate: s.call(je, je, Jt).returns(s.promise()),
WithdrawReward: s.call(je).returns(s.promise()),
Undelegate: s.call(s.arrayOf(ay)).returns(s.promise()),
DeactivateAccount: s.call().returns(s.promise()),
ReactivateAccount: s.call().returns(s.promise()),
TransferAccount: s.call().returns(s.promise()),
Send: s.call().returns(s.promise()),
SendAll: s.call().returns(s.promise()),
Transfer: s.call().returns(s.promise()),
});
harden(Yw);
var _N = (
e,
{
chainHub: t,
makeProgressTracker: r,
makeRecorderKit: o,
timerService: n,
vowTools: a,
zcf: i,
},
) => {
e.makeOnce("icaAccountToDetails", () => null);
let { watch: c, asVow: d, when: l, allVows: u } = a,
p = ci({ watch: c }),
y = wu(n);
return e.exoClassKit(
"Cosmos Orchestration Account Holder",
{
attachTxMetaWatcher: s.interface("attachTxMetaWatcher", {
onFulfilled: s
.call(
s.arrayOf(s.any()),
pi(s.splitRecord({ result: pi(s.any()), meta: s.record() })),
s.string(),
)
.returns(pi(s.any())),
}),
transferWithMetaWatcher: s.interface("transferWithMetaWatcher", {
onFulfilled: s
.call([s.record(), s.nat()])
.optional({
destination: je,
opts: s.or(s.undefined(), Xo),
token: { denom: s.string(), amount: s.string() },
})
.returns(un({ result: un(s.any()), meta: s.record() })),
}),
parseTransferWatcher: s.interface("parseTransferWatcher", {
onFulfilled: s
.call([s.string(), s.record()], s.record())
.returns(un(s.record())),
}),
undelegateWatcher: s.interface("undelegateWatcher", {
onFulfilled: s
.call(s.string())
.optional(s.arrayOf(s.undefined()))
.returns(un(s.promise())),
}),
withdrawRewardWatcher: s.interface("withdrawRewardWatcher", {
onFulfilled: s
.call(s.string())
.optional(s.arrayOf(s.undefined()))
.returns(s.arrayOf(bt)),
}),
...p.makeTombstonedWatcherShapes(Qw),
...p.watcherShapes,
helper: s.interface("helper", {
...p.helperShapes,
owned: s.call().returns(s.remotable()),
getUpdater: s.call().returns(s.remotable()),
amountToCoin: s.call(Jt).returns(s.record()),
}),
updateTxProgressWatcher: s.interface("updateTxProgressWatcher", {
onFulfilled: s
.call(
s.arrayOf(s.any()),
s.splitRecord(
{
progressTracker: s.remotable("ProgressTracker"),
protocol: s.string(),
},
{ trafficeSlice: $y },
),
)
.returns(),
}),
returnVoidWatcher: s.interface("returnVoidWatcher", {
onFulfilled: s.call().rest(s.any()).returns(s.undefined()),
}),
decodeResponsesWatcher: s.interface("decodeResponsesWatcher", {
onFulfilled: s
.call(s.string(), s.arrayOf(s.string()))
.returns(s.arrayOf(s.any())),
}),
balanceQueryWatcher: s.interface("balanceQueryWatcher", {
onFulfilled: s
.call(s.arrayOf(s.record()))
.optional(s.arrayOf(s.undefined()))
.returns(s.or(s.record(), s.undefined())),
}),
allBalancesQueryWatcher: s.interface("allBalancesQueryWatcher", {
onFulfilled: s
.call(s.arrayOf(s.record()))
.returns(s.arrayOf(s.record())),
}),
decodedUndelegateWatcher: s.interface("decodedUndelegateWatcher", {
onFulfilled: s.call(s.arrayOf(s.any())).returns(un(s.promise())),
}),
decodedWithdrawRewardWatcher: s.interface(
"decodedWithdrawRewardWatcher",
{
onFulfilled: s
.call(s.splitRecord({ amount: s.arrayOf(Bc) }))
.optional(s.arrayOf(s.undefined()))
.returns(s.arrayOf(bt)),
},
),
beginTransferWatcher: s.interface("beginTransferWatcher", {
onFulfilled: s
.call([s.any(), s.opt(s.nat())])
.optional({
destination: je,
opts: s.opt(Xo),
token: { denom: s.string(), amount: s.string() },
})
.returns(un(s.any())),
}),
fillSequenceWatcher: s.interface("fillSequenceWatcher", {
onFulfilled: s
.call([s.splitRecord({ sequence: s.bigint() })], s.record())
.returns(),
}),
delegationQueryWatcher: s.interface("delegationQueryWatcher", {
onFulfilled: s.call(s.arrayOf(s.record())).returns(s.record()),
}),
delegationsQueryWatcher: s.interface("delegationsQueryWatcher", {
onFulfilled: s
.call(s.arrayOf(s.record()))
.returns(s.arrayOf(s.record())),
}),
unbondingDelegationQueryWatcher: s.interface(
"unbondingDelegationQueryWatcher",
{
onFulfilled: s.call(s.arrayOf(s.record())).returns(s.record()),
},
),
unbondingDelegationsQueryWatcher: s.interface(
"unbondingDelegationsQueryWatcher",
{
onFulfilled: s
.call(s.arrayOf(s.record()))
.returns(s.arrayOf(s.record())),
},
),
redelegationsQueryWatcher: s.interface(
"redelegationsQueryWatcher",
{
onFulfilled: s
.call(s.arrayOf(s.record()))
.returns(s.arrayOf(s.record())),
},
),
rewardQueryWatcher: s.interface("rewardQueryWatcher", {
onFulfilled: s
.call(s.arrayOf(s.record()))
.returns(s.arrayOf(s.record())),
}),
rewardsQueryWatcher: s.interface("rewardsQueryWatcher", {
onFulfilled: s.call(s.arrayOf(s.record())).returns(s.record()),
}),
holder: $N,
invitationMakers: Yw,
},
({ chainAddress: m, localAddress: v, remoteAddress: h }, g) => {
rt("cosmos orch acct init", {
chainAddress: m,
localAddress: v,
remoteAddress: h,
});
let { storageNode: S } = g,
w = S ? o(S, zw.account[1]) : void 0;
w && O(w.recorder).write({ localAddress: v, remoteAddress: h });
let { account: I, icqConnection: E, timer: K } = g;
return {
account: I,
chainAddress: m,
icqConnection: E,
localAddress: v,
remoteAddress: h,
timer: K,
topicKit: w,
};
},
{
attachTxMetaWatcher: {
onFulfilled(m, { result: v, meta: h }, g) {
return { result: v, meta: h };
},
},
parseTransferWatcher: {
onFulfilled() {
return { result: c(null), meta: {} };
},
},
transferWithMetaWatcher: {
onFulfilled(m, v) {
let h = this.facets.beginTransferWatcher.onFulfilled(m, v);
return harden({ result: h, meta: {} });
},
},
undelegateWatcher: {
onFulfilled(m) {
let v = this.facets.decodeResponsesWatcher.onFulfilled(m, [
"/cosmos.staking.v1beta1.MsgUndelegate",
]);
return this.facets.decodedUndelegateWatcher.onFulfilled(v);
},
},
withdrawRewardWatcher: {
onFulfilled(m) {
let [v] = this.facets.decodeResponsesWatcher.onFulfilled(m, [
"/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
]);
return this.facets.decodedWithdrawRewardWatcher.onFulfilled(v);
},
},
...p.makeTombstonedWatchers(Qw),
...p.watchers,
helper: {
...p.helper,
owned() {
let { account: m } = this.state;
if (!m) throw f`Using account holder after transfer`;
return m;
},
getUpdater() {
if (!this.state.topicKit) throw f`no topicKit`;
return this.state.topicKit.recorder;
},
amountToCoin(m) {
return (
!("brand" in m) ||
f`'amountToCoin' not working for ${x(m.brand)} until #10449; use 'DenomAmount' for now`,
Es(t, m)
);
},
},
updateTxProgressWatcher: {
onFulfilled(
[m, v, h],
{ progressTracker: g, trafficSlice: S, protocol: w },
) {
let I = Cc(v),
E = Cc(h),
K = { status: "unknown" },
J = g.getCurrentProgressReport(),
P = li(J.traffic, S, (U) =>
Mo.IbcICA.finish(
U,
`${m.namespace}:${m.reference}`,
I,
E,
K,
),
),
k = harden({ ...J, traffic: P });
g.update(k);
},
},
balanceQueryWatcher: {
onFulfilled([m]) {
let { balance: v } = ln(qy, m);
if (!v) throw f`Result lacked balance key: ${m}`;
return harden(Wn(v));
},
},
delegationQueryWatcher: {
onFulfilled([m]) {
let { delegationResponse: v } = ln(Zy, m);
if (!v) throw f`Result lacked delegationResponse key: ${m}`;
let { chainAddress: h } = this.state;
return harden(Ny(h, v));
},
},
delegationsQueryWatcher: {
onFulfilled([m]) {
let { delegationResponses: v } = ln(eg, m);
if (!v) throw f`Result lacked delegationResponses key: ${m}`;
let { chainAddress: h } = this.state;
return harden(v.map((g) => Ny(h, g)));
},
},
unbondingDelegationQueryWatcher: {
onFulfilled([m]) {
let { unbond: v } = ln(ag, m);
if (!v) throw f`Result lacked unbond key: ${m}`;
return harden(v);
},
},
unbondingDelegationsQueryWatcher: {
onFulfilled([m]) {
let { unbondingResponses: v } = ln(rg, m);
if (!v) throw f`Result lacked unbondingResponses key: ${m}`;
return harden(v);
},
},
redelegationsQueryWatcher: {
onFulfilled([m]) {
let { redelegationResponses: v } = ln(ng, m);
if (!v) throw f`Result lacked redelegationsResponses key: ${m}`;
return harden(v);
},
},
rewardQueryWatcher: {
onFulfilled([m]) {
let { rewards: v } = ln(Gy, m);
if (!v) throw f`Result lacked rewards key: ${m}`;
return harden(v.map(bu));
},
},
rewardsQueryWatcher: {
onFulfilled([m]) {
let { rewards: v, total: h } = ln(zy, m);
if (!v || !h) throw f`Result lacked rewards or total key: ${m}`;
let { chainAddress: g } = this.state;
return harden({
rewards: v.map((S) => ({
validator: Dy(S, g.chainId),
reward: S.reward.map(bu),
})),
total: h.map(bu),
});
},
},
allBalancesQueryWatcher: {
onFulfilled([m]) {
let { balances: v } = ln(Wy, m);
if (!v) throw f`Result lacked balances key: ${x(m)}`;
return harden(v.map((h) => Wn(h)));
},
},
decodedUndelegateWatcher: {
onFulfilled(m) {
rt("undelegate responses", m);
let v = m.reduce((h, g) => {
let S = g?.completionTime?.seconds ?? 0n;
return S > h ? S : h;
}, 0n);
return (
v || f`No completion time in responses ${m}`,
c(O(this.state.timer).wakeAt(v + hu))
);
},
},
returnVoidWatcher: {
onFulfilled(...m) {
rt("Voiding result", m);
},
},
decodedWithdrawRewardWatcher: {
onFulfilled(m) {
rt("withdrawReward response", m);
let { amount: v } = m;
return harden(v.map(Wn));
},
},
decodeResponsesWatcher: {
onFulfilled(m, v) {
let h = v.map(
(S) =>
Gw[S] || {
fromProtoMsg(w) {
return w;
},
},
),
g = GA(m, h);
return harden(g);
},
},
beginTransferWatcher: {
onFulfilled(
[{ transferChannel: m }, v],
{ opts: h = {}, token: g, destination: S },
) {
let { chainAddress: w } = this.state,
{ holder: I } = this.facets,
{ timeoutHeight: E, timeoutTimestamp: K, memo: J, ...P } = h,
k = I.executeTxProto3(
[
dn.toJSON(
lg.toProtoMsg({
sourcePort: m.portId,
sourceChannel: m.channelId,
token: g,
sender: w.value,
receiver: S.value,
timeoutHeight: E,
timeoutTimestamp: v,
memo: J,
}),
),
],
P,
),
{ progressTracker: U } = P;
if (U) {
let D = U.getCurrentProgressReport(),
{ traffic: _, slice: T } = di(
D.traffic,
Mo.IbcTransfer.start(
`cosmos:${w.chainId}`,
`cosmos:${S.chainId}`,
m,
),
),
R = harden({ ...D, traffic: _ });
(U.update(R),
c(k, this.facets.fillSequenceWatcher, {
progressTracker: U,
trafficSlice: T,
}));
}
return this.facets.helper.overrideVow(k, "FOLLOW_TRAFFIC");
},
},
fillSequenceWatcher: {
onFulfilled(
[{ sequence: m }],
{ progressTracker: v, trafficSlice: h },
) {
let g = v.getCurrentProgressReport();
rt("fillSequenceWatcher", {
sequence: m,
priorReport: g,
trafficSlice: h,
});
let S = li(g.traffic, h, (I) => Mo.IbcTransfer.finish(I, m)),
w = harden({ ...g, traffic: S });
v.update(w);
},
},
invitationMakers: {
Delegate(m, v) {
return (
rt("Delegate", m, v),
i.makeInvitation(
(h) => (h.exit(), c(this.facets.holder.delegate(m, v))),
"Delegate",
)
);
},
Redelegate(m, v, h) {
return (
rt("Redelegate", m, v, h),
i.makeInvitation(
(g) => (
g.exit(),
c(this.facets.holder.redelegate(m, v, h))
),
"Redelegate",
)
);
},
WithdrawReward(m) {
return (
rt("WithdrawReward", m),
i.makeInvitation(
(v) => (v.exit(), c(this.facets.holder.withdrawReward(m))),
"WithdrawReward",
)
);
},
Undelegate(m) {
return (
rt("Undelegate", m),
i.makeInvitation(
(v) => (v.exit(), c(this.facets.holder.undelegate(m))),
"Undelegate",
)
);
},
DeactivateAccount() {
return i.makeInvitation(
(m) => (m.exit(), c(this.facets.holder.deactivate())),
"DeactivateAccount",
);
},
ReactivateAccount() {
return i.makeInvitation(
(m) => (m.exit(), c(this.facets.holder.reactivate())),
"ReactivateAccount",
);
},
Send() {
let m = (v, { toAccount: h, amount: g, opts: S }) => (
v.exit(),
c(this.facets.holder.send(h, g, S))
);
return i.makeInvitation(m, "Send");
},
SendAll() {
let m = (v, { toAccount: h, amounts: g, opts: S }) => (
v.exit(),
c(this.facets.holder.sendAll(h, g, S))
);
return i.makeInvitation(m, "SendAll");
},
TransferAccount() {
throw Error("not yet implemented");
},
Transfer() {
let m = (v, { amount: h, destination: g, opts: S }) => (
v.exit(),
c(this.facets.holder.transfer(g, h, S))
);
return i.makeInvitation(m, "Transfer");
},
},
holder: {
makeProgressTracker() {
return r();
},
asContinuingOffer() {
return d(async () => {
await null;
let { holder: m, invitationMakers: v } = this.facets,
h = v;
return harden({
publicSubscribers: await l(m.getPublicTopics()),
invitationMakers: h,
});
});
},
getPublicTopics() {
return d(async () => {
await null;
let { topicKit: m } = this.state;
if (!m) throw f`No topicKit; storageNode not provided`;
return harden({
account: {
description: zw.account[0],
subscriber: m.subscriber,
storagePath: await m.recorder.getStoragePath(),
},
});
});
},
getAddress() {
return this.state.chainAddress;
},
delegate(m, v, h) {
return d(() => {
rt("delegate", m, v);
let { helper: g, holder: S } = this.facets,
{ chainAddress: w } = this.state,
I = g.amountToCoin(v),
E = S.executeTxProto3(
[
dn.toJSON(
cg.toProtoMsg({
delegatorAddress: w.value,
validatorAddress: m.value,
amount: I,
}),
),
],
h,
);
return g.pickVowIndex(E, 0);
});
},
redelegate(m, v, h, g) {
return d(() => {
rt("redelegate", m, v, h);
let { helper: S, holder: w } = this.facets,
{ chainAddress: I } = this.state,
E = w.executeTxProto3(
[
dn.toJSON(
ig.toProtoMsg({
delegatorAddress: I.value,
validatorSrcAddress: m.value,
validatorDstAddress: v.value,
amount: S.amountToCoin(h),
}),
),
],
g,
);
return S.pickVowIndex(E, 0);
});
},
withdrawReward(m, v) {
return d(() => {
rt("withdrawReward", m);
let { helper: h, holder: g } = this.facets,
{ chainAddress: S } = this.state,
w = Vy.toProtoMsg({
delegatorAddress: S.value,
validatorAddress: m.value,
}),
I = g.executeTxProto3([dn.toJSON(w)], v),
E = h.pickVowIndex(I, 0);
return c(E, this.facets.decodedWithdrawRewardWatcher);
});
},
getBalance(m, v) {
return d(() => {
let { chainAddress: h, icqConnection: g } = this.state;
if (!g)
throw f`Queries not available for chain ${x(h.chainId)}`;
let S = O(g).query([
Eo(
Ly.toProtoMsg({ address: h.value, denom: gu(t, m) }),
v?.queryOpts,
),
]);
return c(S, this.facets.balanceQueryWatcher);
});
},
getBalances(m) {
return d(() => {
let { chainAddress: v, icqConnection: h } = this.state;
if (!h)
throw f`Queries not available for chain ${x(v.chainId)}`;
let g = O(h).query([
Eo(Hy.toProtoMsg({ address: v.value }), m?.queryOpts),
]);
return c(g, this.facets.allBalancesQueryWatcher);
});
},
send(m, v, h) {
return d(() => {
rt("send", m, v, h);
let g = t.coerceCosmosAddress(m),
{ chainAddress: S } = this.state;
g.chainId === S.chainId ||
f`bank/send cannot send to a different chain ${x(g.chainId)}`;
let { helper: w, holder: I } = this.facets,
E = I.executeTxProto3(
[
dn.toJSON(
Pu.toProtoMsg({
fromAddress: S.value,
toAddress: g.value,
amount: [w.amountToCoin(v)],
}),
),
],
h,
);
return w.pickVowIndex(E, 0);
});
},
sendAll(m, v, h) {
return d(() => {
rt("sendAll", m, v);
let { helper: g, holder: S } = this.facets,
{ chainAddress: w } = this.state,
I = S.executeTxProto3(
[
dn.toJSON(
Pu.toProtoMsg({
fromAddress: w.value,
toAddress: m.value,
amount: v.map((E) => g.amountToCoin(E)),
}),
),
],
h,
);
return g.pickVowIndex(I, 0);
});
},
transfer(m, v, h) {
return (
rt("transfer", m, v, h),
d(() => {
let g = t.coerceCosmosAddress(m),
{ helper: S } = this.facets,
w = S.amountToCoin(v),
I = c(t.getConnectionInfo(this.state.chainAddress, g));
return c(
u([I, y.vowOrValueFromOpts(h)]),
this.facets.beginTransferWatcher,
{ opts: h, token: w, destination: g },
);
})
);
},
transferSteps(m, v) {
return (
console.log("transferSteps got", m, v),
d(() => f`not yet implemented`)
);
},
withdrawRewards() {
return d(() => f`Not Implemented. Try using withdrawReward.`);
},
undelegate(m, v) {
return d(() => {
rt("undelegate", m);
let { holder: h } = this.facets,
{ chainAddress: g } = this.state;
m.every((I) =>
I.delegator ? I.delegator.value === g.value : !0,
) || f`Some delegation record is for another delegator`;
let S = h.executeTxProto3(
m.map(({ validator: I, amount: E }) =>
dn.toJSON(
dg.toProtoMsg({
delegatorAddress: g.value,
validatorAddress: I.value,
amount: Es(t, E),
}),
),
),
v,
),
w = c(S, this.facets.decodedUndelegateWatcher);
return c(w, this.facets.returnVoidWatcher);
});
},
deactivate() {
return d(() => c(O(this.facets.helper.owned()).deactivate()));
},
reactivate() {
return d(() => c(O(this.facets.helper.owned()).reactivate()));
},
getDelegation(m, v) {
return d(() => {
rt("getDelegation", m);
let { chainAddress: h, icqConnection: g } = this.state;
if (!g)
throw f`Queries not available for chain ${x(h.chainId)}`;
let S = O(g).query([
Eo(
Yy.toProtoMsg({
delegatorAddr: h.value,
validatorAddr: m.value,
}),
v?.queryOpts,
),
]);
return c(S, this.facets.delegationQueryWatcher);
});
},
getDelegations(m) {
return d(() => {
rt("getDelegations");
let { chainAddress: v, icqConnection: h } = this.state;
if (!h)
throw f`Queries not available for chain ${x(v.chainId)}`;
let g = O(h).query([
Eo(Xy.toProtoMsg({ delegatorAddr: v.value }), m?.queryOpts),
]);
return c(g, this.facets.delegationsQueryWatcher);
});
},
getUnbondingDelegation(m, v) {
return d(() => {
rt("getUnbondingDelegation", m);
let { chainAddress: h, icqConnection: g } = this.state;
if (!g)
throw f`Queries not available for chain ${x(h.chainId)}`;
let S = O(g).query([
Eo(
sg.toProtoMsg({
delegatorAddr: h.value,
validatorAddr: m.value,
}),
v?.queryOpts,
),
]);
return c(S, this.facets.unbondingDelegationQueryWatcher);
});
},
getUnbondingDelegations(m) {
return d(() => {
rt("getUnbondingDelegations");
let { chainAddress: v, icqConnection: h } = this.state;
if (!h)
throw f`Queries not available for chain ${x(v.chainId)}`;
let g = O(h).query([
Eo(tg.toProtoMsg({ delegatorAddr: v.value }), m?.queryOpts),
]);
return c(g, this.facets.unbondingDelegationsQueryWatcher);
});
},
getRedelegations(m) {
return d(() => {
rt("getRedelegations");
let { chainAddress: v, icqConnection: h } = this.state;
if (!h)
throw f`Queries not available for chain ${x(v.chainId)}`;
let g = O(h).query([
Eo(
og.toProtoMsg({
delegatorAddr: v.value,
dstValidatorAddr: "",
srcValidatorAddr: "",
}),
m?.queryOpts,
),
]);
return c(g, this.facets.redelegationsQueryWatcher);
});
},
getReward(m, v) {
return d(() => {
rt("getReward", m);
let { chainAddress: h, icqConnection: g } = this.state;
if (!g)
throw f`Queries not available for chain ${x(h.chainId)}`;
let S = O(g).query([
Eo(
jy.toProtoMsg({
delegatorAddress: h.value,
validatorAddress: m.value,
}),
v?.queryOpts,
),
]);
return c(S, this.facets.rewardQueryWatcher);
});
},
getRewards(m) {
return d(() => {
rt("getRewards");
let { chainAddress: v, icqConnection: h } = this.state;
if (!h)
throw f`Queries not available for chain ${x(v.chainId)}`;
let g = O(h).query([
Eo(
Qy.toProtoMsg({ delegatorAddress: v.value }),
m?.queryOpts,
),
]);
return c(g, this.facets.rewardsQueryWatcher);
});
},
executeEncodedTx(m, v = {}) {
return d(() => {
let { progressTracker: h } = v,
{ helper: g } = this.facets,
S = g.owned();
if (h) {
let { chainAddress: w } = this.state,
I = t.getChainInfo("agoric"),
E = O(S).getLocalAddress(),
K = `cosmos:${w.chainId}`,
J = O(S).getRemoteAddress(),
P = h.getCurrentProgressReport(),
{ traffic: k, slice: U } = di(
P.traffic,
Mo.IbcICA.start(K),
),
D = { ...P, traffic: k };
(h.update(harden(D)),
c(u([I, E, J]), this.facets.updateTxProgressWatcher, {
progressTracker: h,
protocol: "ibc",
trafficSlice: U,
}));
}
return O(S).executeEncodedTx(m, v);
});
},
executeTxProto3Undecoded(m, v = {}) {
let { holder: h } = this.facets,
{ txOpts: g, ...S } = v;
return h.executeEncodedTx(m, { ...S, ...g });
},
executeTxProto3(m, v = {}) {
let { holder: h } = this.facets,
g = m.map((w) => w.typeUrl);
return c(
h.executeTxProto3Undecoded(m, v),
this.facets.decodeResponsesWatcher,
g,
);
},
depositForBurn(m, v, h, g = {}) {
return (
rt("depositForBurn", { destination: m, amount: v }),
d(() => {
let { helper: S, holder: w } = this.facets,
{ chainAddress: I } = this.state,
E = jr(m),
K = `${E.namespace}:${E.reference}`,
{ cctpDestinationDomain: J } = t.getChainInfoByChainId(K);
if (typeof J != "number")
throw f`${x(K)} does not have "cctpDestinationDomain" set in ChainInfo`;
let P = {
amount: S.amountToCoin(v)?.amount,
from: I.value,
destinationDomain: J,
mintRecipient: Wf(m),
burnToken: "uusdc",
},
k = h
? (jr(h).namespace === E.namespace ||
f`caller ${x(h)} must be in same namespace as destination ${x(m)}`,
Wf(h))
: void 0,
U = w.executeTxProto3(
[
dn.toJSON(
k
? Jy.toProtoMsg({ ...P, destinationCaller: k })
: Ky.toProtoMsg(P),
),
],
g,
);
return S.pickVowIndex(U, 0);
})
);
},
},
},
);
},
Zw = (
e,
{
chainHub: t,
makeProgressTracker: r,
makeRecorderKit: o,
timerService: n,
vowTools: a,
zcf: i,
},
) => {
let c = _N(e, {
chainHub: t,
makeProgressTracker: r,
makeRecorderKit: o,
timerService: n,
vowTools: a,
zcf: i,
});
return (...d) => c(...d).holder;
};
var Xw = (
e,
{
makeLocalOrchestrationAccountKit: t,
agoricNames: r,
localchain: o,
storageNode: n,
vowTools: { allVows: a, watch: i, asVow: c },
},
) =>
e.exoClassKit(
"LocalChainFacade",
{
public: s.interface("LocalChainFacade", {
..._c,
query: s.call(s.arrayOf($c)).returns(le),
getVBankAssetInfo: s.call().optional(s.boolean()).returns(le),
}),
vbankAssetValuesWatcher: s.interface("vbankAssetValuesWatcher", {
onFulfilled: s
.call(s.arrayOf(s.record()))
.optional(s.arrayOf(s.undefined()))
.returns(le),
}),
makeAccountWatcher: s.interface("makeAccountWatcher", {
onFulfilled: s
.call([s.remotable("LCA Account"), s.string()])
.optional(s.arrayOf(s.undefined()))
.returns(le),
}),
makeChildNodeWatcher: s.interface("makeChildNodeWatcher", {
onFulfilled: s
.call(s.or(s.remotable(), s.undefined()))
.optional({ account: s.remotable(), address: s.string() })
.returns(s.remotable()),
}),
},
(d) => ({ localChainInfo: d, vbankAssets: void 0 }),
{
public: {
getChainInfo() {
return i(this.state.localChainInfo);
},
makeAccount() {
let d = O(o).makeAccount();
return i(
a([d, Kn(d).getAddress()]),
this.facets.makeAccountWatcher,
);
},
query(d) {
return i(O(o).queryMany(d));
},
getVBankAssetInfo() {
return c(() => {
let { vbankAssets: d } = this.state;
if (d) return d;
let l = O(r).lookup("vbankAsset"),
u = O(l).values(),
{ vbankAssetValuesWatcher: p } = this.facets;
return i(u, p);
});
},
},
vbankAssetValuesWatcher: {
onFulfilled(d) {
let { state: l } = this;
return c(() => ((l.vbankAssets = d), d));
},
},
makeAccountWatcher: {
onFulfilled([d, l]) {
let u = n ? O(n).makeChildNode(l) : void 0;
return i(u, this.facets.makeChildNodeWatcher, {
account: d,
address: l,
});
},
},
makeChildNodeWatcher: {
onFulfilled(d, { account: l, address: u }) {
let { localChainInfo: p } = this.state,
{ holder: y } = t({
account: l,
address: harden({
value: u,
encoding: "bech32",
chainId: p.chainId,
}),
storageNode: d,
});
return y;
},
},
},
);
harden(Xw);
var ug = (e, t) => {
let r = Xw(e, t);
return Pr(r, "public");
};
harden(ug);
function e1() {
return { trace: "" };
}
var ca = {
typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashRequest",
aminoType: "cosmos-sdk/QueryDenomHashRequest",
is(e) {
return e && (e.$typeUrl === ca.typeUrl || typeof e.trace == "string");
},
isSDK(e) {
return e && (e.$typeUrl === ca.typeUrl || typeof e.trace == "string");
},
encode(e, t = re.create()) {
return (e.trace !== "" && t.uint32(10).string(e.trace), t);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = e1();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.trace = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return { trace: B(e.trace) ? String(e.trace) : "" };
},
toJSON(e) {
let t = {};
return (e.trace !== void 0 && (t.trace = e.trace), t);
},
fromPartial(e) {
let t = e1();
return ((t.trace = e.trace ?? ""), t);
},
fromProtoMsg(e) {
return ca.decode(e.value);
},
toProto(e) {
return ca.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashRequest",
value: ca.encode(e).finish(),
};
},
};
function t1() {
return { hash: "" };
}
var da = {
typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashResponse",
aminoType: "cosmos-sdk/QueryDenomHashResponse",
is(e) {
return e && (e.$typeUrl === da.typeUrl || typeof e.hash == "string");
},
isSDK(e) {
return e && (e.$typeUrl === da.typeUrl || typeof e.hash == "string");
},
encode(e, t = re.create()) {
return (e.hash !== "" && t.uint32(10).string(e.hash), t);
},
decode(e, t) {
let r = e instanceof $ ? e : new $(e),
o = t === void 0 ? r.len : r.pos + t,
n = t1();
for (; r.pos < o; ) {
let a = r.uint32();
switch (a >>> 3) {
case 1:
n.hash = r.string();
break;
default:
r.skipType(a & 7);
break;
}
}
return n;
},
fromJSON(e) {
return { hash: B(e.hash) ? String(e.hash) : "" };
},
toJSON(e) {
let t = {};
return (e.hash !== void 0 && (t.hash = e.hash), t);
},
fromPartial(e) {
let t = t1();
return ((t.hash = e.hash ?? ""), t);
},
fromProtoMsg(e) {
return da.decode(e.value);
},
toProto(e) {
return da.encode(e).finish();
},
toProtoMsg(e) {
return {
typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashResponse",
value: da.encode(e).finish(),
};
},
};
var qn = Ae("PacketTools"),
{ toCapData: FN } = At(void 0, void 0, {
marshalName: "JustEncoder",
serializeBodyFormat: "capdata",
}),
ku = (e) => {
let { body: t } = FN(e);
return Li(JSON.parse(t), !1);
},
r1 = [],
{ Vow$: mi } = dt,
Iu = (e) => s.or(mi(e), s.promise()),
KN = () => {};
harden(KN);
var pg = (e, t) => {
let { allVows: r, makeVowKit: o, watch: n, when: a } = t,
i = ci(t),
c = e.exoClassKit(
"PacketToolsKit",
{
packetWasSentWithMetaWatcher: s.interface(
"packetWasSentWithMetaWatcher",
{
onFulfilled: s
.call(
{
eventPattern: s.pattern(),
resultV: mi(s.any()),
meta: s.record(),
},
s.record(),
)
.returns(mi({ result: s.any(), meta: s.record() })),
},
),
...i.makeTombstonedWatcherShapes(r1),
public: s.interface("PacketTools", {
sendThenWaitForAck: s
.call(Iu(s.remotable("PacketSender")))
.optional(s.any())
.returns(Iu(s.any())),
matchFirstPacket: s.call(s.any()).returns(Iu(s.any())),
monitorTransfers: s
.call(s.remotable("TargetApp"))
.returns(Iu(s.any())),
}),
pickDataWatcher: i.watcherShapes.pickDataWatcher,
tap: s.interface("tap", {
receiveUpcall: s.callWhen(s.any()).returns(s.any()),
}),
monitorRegistration: s.interface("monitorRegistration", {
updateTargetApp: s
.callWhen(s.await(s.remotable("TargetApp")))
.returns(),
revoke: s.callWhen().returns(),
}),
watchPacketMatch: s.interface("watchPacketMatch", {
onFulfilled: s.call(s.any(), s.record()).returns(s.any()),
}),
watchPacketPattern: s.interface("watchPacketPattern", {
onFulfilled: s.call(s.any(), s.record()).returns(s.any()),
onRejected: s.call(s.any(), s.record()).returns(s.any()),
}),
watchDecrPendingPatterns: s.interface("watchDecrPendingPatterns", {
onFulfilled: s.call(s.any()).returns(s.any()),
onRejected: s.call(s.any()).returns(s.any()),
}),
sendPacketWatcher: s.interface("sendPacketWatcher", {
onFulfilled: s
.call([s.record(), s.remotable("PacketSender")], s.record())
.returns(s.any()),
}),
packetWasSentWatcher: s.interface("packetWasSentWatcher", {
onFulfilled: s
.call(
{ eventPattern: s.pattern(), resultV: mi(s.any()) },
s.record(),
)
.returns(s.any()),
}),
utils: s.interface("utils", {
pickVowProp: i.helperShapes.pickVowProp,
subscribeToTransfers: s.call().returns(s.promise()),
unsubscribeFromTransfers: s.call().returns(s.undefined()),
incrPendingPatterns: s.call().returns(mi(s.undefined())),
decrPendingPatterns: s.call().returns(mi(s.undefined())),
}),
rejectResolverAndRethrowWatcher: s.interface(
"rejectResolverWatcher",
{
onRejected: s
.call(s.any(), { resolver: s.remotable("resolver") })
.returns(s.any()),
},
),
},
(l) => {
let u = e.detached().mapStore("resolverToPattern");
return {
lca: l,
reg: null,
resolverToPattern: u,
upcallQueue: null,
pending: 0,
extra: null,
monitor: null,
};
},
{
packetWasSentWithMetaWatcher: {
onFulfilled({ eventPattern: l, resultV: u, meta: p }, y) {
let b = this.facets.packetWasSentWatcher.onFulfilled(
{ eventPattern: l, resultV: u },
y,
);
return harden({ result: b, meta: p });
},
},
...i.makeTombstonedWatchers(r1),
public: {
async monitorTransfers(l) {
let u = this.facets.monitorRegistration;
return (await u.updateTargetApp(l), u);
},
matchFirstPacket(l) {
return n(
this.facets.utils.incrPendingPatterns(),
this.facets.watchPacketMatch,
{ patternP: l },
);
},
sendThenWaitForAck(l, u = {}) {
let p = o(),
y = n(
r([this.facets.public.matchFirstPacket(p.vow), l]),
this.facets.sendPacketWatcher,
{ opts: u },
),
b = n(y, this.facets.packetWasSentWatcher, {
opts: u,
patternResolver: p.resolver,
});
return n(b, this.facets.rejectResolverAndRethrowWatcher, {
resolver: p.resolver,
});
},
},
pickDataWatcher: i.watchers.pickDataWatcher,
monitorRegistration: {
async updateTargetApp(l) {
((this.state.monitor = await l),
await this.facets.utils.subscribeToTransfers());
},
async revoke() {
this.state.monitor = null;
},
},
tap: {
async receiveUpcall(l) {
let {
monitor: u,
resolverToPattern: p,
upcallQueue: y,
pending: b,
} = this.state;
(qn(
`Trying ${p.getSize()} current patterns and ${b} pending patterns against`,
ku(l),
),
u && O(u).receiveUpcall(l));
for (let [m, v] of p.entries())
if (Ve(l, v)) {
(qn("Matched pattern:", ku(v)), m.resolve(l), p.delete(m));
return;
}
(y &&
(qn("Stashing object in upcallQueue"),
(this.state.upcallQueue = harden(y.concat(l)))),
qn("No match yet."));
},
},
sendPacketWatcher: {
onFulfilled([{ match: l }, u], p) {
return n(O(u).sendPacket(l, p.opts));
},
},
packetWasSentWatcher: {
onFulfilled({ eventPattern: l, resultV: u }, p) {
let { patternResolver: y } = p;
return (y.resolve(l), u);
},
},
rejectResolverAndRethrowWatcher: {
onRejected(l, { resolver: u }) {
throw (u.reject(l), l);
},
},
watchPacketMatch: {
onFulfilled(l, { patternP: u }) {
let { vow: p, resolver: y } = o(),
b = n(
u,
this.facets.watchPacketPattern,
harden({ resolver: y }),
);
return (
n(b, this.facets.watchDecrPendingPatterns),
harden({ match: p, resolver: y })
);
},
},
watchDecrPendingPatterns: {
onFulfilled() {
return this.facets.utils.decrPendingPatterns();
},
onRejected() {
return this.facets.utils.decrPendingPatterns();
},
},
watchPacketPattern: {
onFulfilled(l, { resolver: u }) {
let { resolverToPattern: p, upcallQueue: y } = this.state;
if ((qn("watchPacketPattern onFulfilled", ku(l)), !y)) {
(qn("No upcall queue yet. Save the pattern for later."),
p.init(u, l));
return;
}
let b = y.findIndex((m) => Ve(m, l));
if (b < 0) {
(qn("No match yet. Save the pattern for later."),
p.init(u, l));
return;
}
(qn(
"Success! Remove the matched object from the queue.",
ku(y[b]),
),
u.resolve(y[b]),
(this.state.upcallQueue = harden(
y.slice(0, b).concat(y.slice(b + 1)),
)));
},
onRejected(l, { resolver: u }) {
u.reject(l);
},
},
utils: {
pickVowProp: i.helper.pickVowProp,
incrPendingPatterns() {
let { pending: l, reg: u, upcallQueue: p } = this.state;
return (
(this.state.pending += 1),
p || (this.state.upcallQueue = harden([])),
u || l > 0
? n(void 0)
: n(this.facets.utils.subscribeToTransfers())
);
},
decrPendingPatterns() {
if (((this.state.pending -= 1), !(this.state.pending > 0)))
return (
(this.state.pending = 0),
(this.state.upcallQueue = null),
n(this.facets.utils.unsubscribeFromTransfers())
);
},
subscribeToTransfers() {
let { lca: l, reg: u } = this.state;
if (u) return a(u);
let { tap: p } = this.facets,
y = n(O(l).monitorTransfers(p));
return ((this.state.reg = y), a(y));
},
unsubscribeFromTransfers() {
let { reg: l, monitor: u } = this.state;
},
},
},
{
finish(l) {
l.facets.utils.subscribeToTransfers();
},
},
);
return Pr(c, "public");
};
harden(pg);
var JN = "",
Tu = btoa(JN),
VN = Ae("IBCP"),
{ Fail: pn, bare: HN } = assert,
{ Vow$: mg } = dt,
o1 = (e) => {
let t = [];
try {
let n = BigInt(e);
n > 0n && t.push(n);
} catch {}
let r = Number(e);
r > 0 && Number.isSafeInteger(r) && t.push(r);
let o = String(e);
switch (
(o && t.push(o), t.find((n) => n === e) || t.push(e), t.length)
) {
case 0:
throw pn`sequence ${e} is not valid`;
case 1:
return t[0];
default:
return s.or(...t);
}
};
harden(o1);
var n1 = (e, { watch: t, makeIBCReplyKit: r }) => {
let o = e.exoClassKit(
"IBCTransferSenderKit",
{
public: s.interface("IBCTransferSender", {
sendPacket: s.call(mg(s.any()), s.record()).returns(mg(s.record())),
}),
responseWatcher: s.interface("responseWatcher", {
onFulfilled: s.call([s.record()], s.record()).returns(s.any()),
}),
verifyTransferSuccess: s.interface("verifyTransferSuccess", {
onFulfilled: s.call(s.any()).returns(s.string()),
}),
},
(n, a) => ({ txExecutor: n, transferMsg: harden(a) }),
{
public: {
sendPacket(n, a) {
let { txExecutor: i, transferMsg: c } = this.state;
return t(O(i).executeTx([c]), this.facets.responseWatcher, {
opts: a,
match: n,
});
},
},
responseWatcher: {
onFulfilled([{ sequence: n }], a) {
let { match: i, opts: c } = a,
{ transferMsg: d } = this.state;
VN("sequence", n, d);
let l = s.splitRecord({
source_port: d.sourcePort,
source_channel: d.sourceChannel,
sequence: o1(n),
}),
{ resultV: u, ...p } = r(l, i, { opName: "transfer", ...c }),
y = t(u, this.facets.verifyTransferSuccess),
{ progressTracker: b, trafficSlice: m } = c || {};
if (b) {
let v = b.getCurrentProgressReport(),
h = li(v.traffic, m, (S) => Mo.IbcTransfer.finish(S, n)),
g = harden({ ...v, traffic: h });
b.update(g);
}
return harden({ ...p, resultV: y });
},
},
verifyTransferSuccess: {
onFulfilled(n) {
let a;
try {
a = JSON.parse(n);
} catch {
pn`ICS20-1 transfer ack data is not JSON: ${n}`;
}
let { result: i, error: c } = a;
if (
(c === void 0 || pn`ICS20-1 transfer error ${c}`,
i ?? pn`Missing result in ICS20-1 transfer ack ${a}`,
i === Tu)
)
return Tu;
let d = (p) => {
try {
return JSON.parse(atob(p));
} catch {
pn`Decoding of base64-encoded ack obj object failed: ${JSON.stringify(p)}`;
}
},
l = d(i);
return (
(l?.ibc_ack && d(l.ibc_ack))?.result === Tu ||
pn`ICS20-1 transfer unsuccessful with ack result: ${l}`,
Tu
);
},
},
},
);
return (...n) => o(...n).public;
};
harden(n1);
var s1 = (e, t) => {
let { watch: r } = t,
o = e.exo(
"ibcResultWatcher",
s.interface("processIBCWatcher", {
onFulfilled: s
.call(
s.splitRecord(
{ event: s.string() },
{ acknowledgement: s.string() },
),
s.splitRecord({}, { opName: s.string(), timeout: s.record() }),
)
.returns(mg(s.string())),
}),
{
onFulfilled(a, { opName: i = "unknown" }) {
let { event: c } = a;
switch (c) {
case "acknowledgementPacket": {
let { acknowledgement: d } = a;
return (
d || pn`acknowledgementPacket missing 'acknowledgement'`,
VS(d)
);
}
case "timeoutPacket":
throw pn`${HN(i)} operation received timeout packet`;
default:
throw pn`Unexpected event: ${c}`;
}
},
},
);
return (a, i, c) => {
let d = s.or(
s.splitRecord({
event: "acknowledgementPacket",
packet: a,
acknowledgement: s.string(),
}),
s.splitRecord({ event: "timeoutPacket", packet: a }),
),
l = r(i, o, c);
return harden({ eventPattern: d, resultV: l });
};
};
harden(s1);
var fg = (e, t) => {
let r = s1(e, t),
o = n1(e, { makeIBCReplyKit: r, ...t });
return harden({ makeIBCTransferSender: o, makeIBCReplyKit: r });
};
harden(fg);
var { details: yg } = assert,
WN = pe(cn),
LN = pe(ca),
qN = pe(da),
jN = pe(on),
GN = pe(rn),
QN = pe(sn),
zN = pe(an),
a1 = pe(nn),
i1 = [],
Fo = Ae("LocalOrchAccount"),
{ Vow$: la } = dt,
Uu = (e) => s.or(la(e), s.promise()),
YN = (e) =>
Array.isArray(e)
? (assert(
e.length > 0,
yg`Expected result to be a nonempty array, got ${e}`,
),
e[0])
: { reply: e },
ZN = s.interface("holder", {
...Su,
delegate: s.call(s.string(), et).returns(le),
undelegate: s.call(s.string(), et).returns(le),
deposit: s.call(Zt).returns(le),
withdraw: s.call(et).returns(la(Zt)),
executeTx: s.call(s.arrayOf(s.record())).returns(la(s.record())),
sendThenWaitForAck: s
.call(Uu(s.remotable("PacketSender")))
.optional(s.any())
.returns(Uu(s.any())),
matchFirstPacket: s.call(s.any()).returns(Uu(s.any())),
monitorTransfers: s.call(s.remotable("TargetApp")).returns(Uu(s.any())),
parseInboundTransfer: s
.call(s.recordOf(s.string(), s.any()))
.returns(
la({
amount: bt,
fromAccount: s.string(),
toAccount: s.string(),
extra: s.recordOf(s.string(), s.any()),
}),
),
}),
c1 = { account: ["Account holder status", s.any()] },
d1 = "denomination trace not found",
l1 = (
e,
{
makeRecorderKit: t,
makeProgressTracker: r,
zcf: o,
timerService: n,
vowTools: a,
chainHub: i,
localchain: c,
zoeTools: d,
},
) => {
let { watch: l, asVow: u, when: p } = a,
y = ci({ watch: l }),
{ makeIBCTransferSender: b } = fg(e.subZone("ibcTools"), a),
m = pg(e.subZone("packetTools"), a),
v = wu(n);
return e.exoClassKit(
"Local Orchestration Account Kit",
{
transferWithMetaWatcher: s.interface("transferWatcher", {
onFulfilled: s
.call([s.record(), s.record(), s.record(), s.nat()])
.optional({ opts: s.opt(Xo), route: Vc })
.returns(la(s.record())),
}),
...y.makeTombstonedWatcherShapes(i1),
...y.watcherShapes,
helper: s.interface("helper", {
...y.helperShapes,
amountToCoin: s.call(Jt).returns(s.record()),
}),
holder: ZN,
undelegateWatcher: s.interface("undelegateWatcher", {
onFulfilled: s
.call([s.splitRecord({ completionTime: iy })])
.optional(s.arrayOf(s.undefined()))
.returns(le),
}),
transferWatcher: s.interface("transferWatcher", {
onFulfilled: s
.call(s.array())
.optional({ opts: s.opt(Xo), route: Vc })
.returns(la(s.record())),
}),
transferConnectionWatcher: s.interface(
"transferConnectionWatcher",
{
onFulfilled: s
.call([s.record(), s.record(), s.nat()])
.optional({ opts: s.opt(Xo), route: Vc })
.returns(la(s.record())),
},
),
extractFirstResultWatcher: s.interface(
"extractFirstResultWatcher",
{
onFulfilled: s
.call([s.record()])
.optional(s.arrayOf(s.undefined()))
.returns(s.any()),
},
),
returnVoidWatcher: s.interface("returnVoidWatcher", {
onFulfilled: s
.call(s.any())
.optional(s.any())
.returns(s.undefined()),
}),
seatExiterHandler: s.interface("seatExiterHandler", {
onFulfilled: s
.call(s.undefined(), s.remotable())
.returns(s.undefined()),
onRejected: s
.call(s.error(), s.remotable())
.returns(s.undefined()),
}),
getBalanceWatcher: s.interface("getBalanceWatcher", {
onFulfilled: s.call(et, Za).returns(bt),
}),
queryBalanceWatcher: s.interface("queryBalanceWatcher", {
onFulfilled: s.call($c).returns(bt),
}),
queryBalancesWatcher: s.interface("queryBalancesWatcher", {
onFulfilled: s.call($c).returns(s.arrayOf(bt)),
}),
parseInboundTransferWatcher: s.interface(
"parseInboundTransferWatcher",
{
onFulfilled: s.call(s.any(), s.record()).returns(s.record()),
onRejected: s.call(s.any(), s.record()).returns(s.record()),
},
),
invitationMakers: s.interface("invitationMakers", {
CloseAccount: s.call().returns(s.promise()),
Delegate: s.call(s.string(), et).returns(s.promise()),
Deposit: s.call().returns(s.promise()),
Send: s.call().returns(s.promise()),
SendAll: s.call().returns(s.promise()),
Transfer: s.call().returns(s.promise()),
Undelegate: s.call(s.string(), et).returns(s.promise()),
Withdraw: s.call().returns(s.promise()),
}),
},
({ account: g, address: S, storageNode: w }) => {
let I = w ? t(w, c1.account[1]) : void 0;
I && O(I.recorder).write("");
let E = m(g);
return { account: g, address: S, packetTools: E, topicKit: I };
},
{
transferWithMetaWatcher: {
onFulfilled(g, S) {
let w = this.facets.transferWatcher.onFulfilled(g, S);
return harden({ result: w, meta: {} });
},
},
...y.makeTombstonedWatcherShapes(i1),
...y.watchers,
helper: {
...y.helper,
amountToCoin(g) {
return Es(i, g);
},
},
invitationMakers: {
Delegate(g, S) {
return (
Fo("Delegate", g, S),
o.makeInvitation(
(w) => (w.exit(), l(this.facets.holder.delegate(g, S))),
"Delegate",
)
);
},
Deposit() {
return (
Fo("Deposit"),
o.makeInvitation(
(g) => {
let { give: S } = g.getProposal();
return l(
d.localTransfer(g, this.state.account, S),
this.facets.seatExiterHandler,
g,
);
},
"Deposit",
void 0,
s.splitRecord({ give: cy, want: {} }),
)
);
},
Undelegate(g, S) {
return (
Fo("Undelegate", g, S),
o.makeInvitation(
(w) => (w.exit(), l(this.facets.holder.undelegate(g, S))),
"Undelegate",
)
);
},
CloseAccount() {
throw Error("not yet implemented");
},
Send() {
let g = (S, { toAccount: w, amount: I }) => (
S.exit(),
l(this.facets.holder.send(w, I))
);
return o.makeInvitation(g, "Send");
},
SendAll() {
let g = (S, { toAccount: w, amounts: I }) => (
S.exit(),
l(this.facets.holder.sendAll(w, I))
);
return o.makeInvitation(g, "SendAll");
},
Transfer() {
let g = (S, { amount: w, destination: I, opts: E }) => (
S.exit(),
l(this.facets.holder.transfer(I, w, E))
);
return o.makeInvitation(g, "Transfer");
},
Withdraw() {
return (
Fo("Withdraw"),
o.makeInvitation(
(g) => {
let { want: S } = g.getProposal();
return l(
d.withdrawToSeat(this.state.account, g, S),
this.facets.seatExiterHandler,
g,
);
},
"Withdraw",
void 0,
s.splitRecord({ give: {}, want: cy }),
)
);
},
},
undelegateWatcher: {
onFulfilled(g) {
let { completionTime: S } = g[0];
return l(
O(n).wakeAt(BigInt(S.seconds) + hu),
this.facets.returnVoidWatcher,
);
},
},
transferConnectionWatcher: {
onFulfilled([g, S, w], I) {
return l(
a.allVows([g, S, i.getConnectionInfo(g, S), w]),
this.facets.transferWatcher,
I,
);
},
},
transferWatcher: {
onFulfilled(
[g, S, { transferChannel: w }, I],
{ opts: E, route: K },
) {
let { forwardInfo: J, ...P } = K;
(assert.equal(
P.sourcePort,
w.portId,
yg`sourcePort ${x(P.sourcePort)} must match the portId ${x(w.portId)}`,
),
assert.equal(
P.sourceChannel,
w.channelId,
yg`sourceChannel ${x(P.sourceChannel)} must match the channelId ${x(w.channelId)}`,
));
let {
timeoutHeight: k,
timeoutTimestamp: U,
memo: D,
..._
} = E || {},
T = D;
J &&
(T = JSON.stringify({
forward: {
...J.forward,
...(T === void 0 ? {} : { next: T }),
},
}));
let R = WN.typedJson({
...P,
sender: this.state.address.value,
timeoutHeight: k,
timeoutTimestamp: I,
memo: T,
}),
{ holder: N } = this.facets,
F = b(N, R),
H,
q = E?.progressTracker;
if (q) {
let ne = q.getCurrentProgressReport(),
{ traffic: ee, slice: Q } = di(
ne.traffic,
Mo.IbcTransfer.start(
`${g.namespace}:${g.reference}`,
`${S.namespace}:${S.reference}`,
w,
),
);
H = Q;
let L = { ...ne, traffic: ee };
q.update(L);
}
return N.sendThenWaitForAck(F, { ..._, trafficSlice: H });
},
},
extractFirstResultWatcher: {
onFulfilled(g) {
return (
g.length === 1 || f`expected exactly one result; got ${g}`,
g[0]
);
},
},
returnVoidWatcher: { onFulfilled() {} },
getBalanceWatcher: {
onFulfilled(g, S) {
return harden({ denom: S, value: g.value });
},
},
seatExiterHandler: {
onFulfilled(g, S) {
S.exit();
},
onRejected(g, S) {
throw (S.exit(g), g);
},
},
queryBalanceWatcher: {
onFulfilled(g) {
let { balance: S } = g;
if (!S || !S?.denom) throw f`Expected balance ${x(g)};`;
return harden(Wn(S));
},
},
queryBalancesWatcher: {
onFulfilled(g) {
let { balances: S } = g;
if (!S || !Array.isArray(S))
throw f`Expected balances ${x(g)};`;
return harden(S.map(Wn));
},
},
parseInboundTransferWatcher: {
onFulfilled(g, S) {
let { error: w, reply: I } = YN(g);
if (w) {
if (w.includes(d1)) return S;
throw Error(`IBC denom trace query failed: ${w}`);
}
let K = `ibc/${qN.fromTyped(I).hash}`,
{ amount: J, ...P } = S,
{ denom: k, ...U } = J;
return harden({ ...P, amount: { ...U, denom: K } });
},
onRejected(g, S) {
if (g instanceof Error && String(g.message).includes(d1))
return S;
throw g;
},
},
holder: {
makeProgressTracker() {
return r();
},
asContinuingOffer() {
return u(async () => {
await null;
let { holder: g, invitationMakers: S } = this.facets,
w = S;
return harden({
publicSubscribers: await p(g.getPublicTopics()),
invitationMakers: w,
});
});
},
getBalance(g) {
return u(() => {
let [S, w] =
typeof g == "string"
? [i.getAsset(g, "agoric")?.brand, g]
: [g, i.getDenom(g)];
if (!w) throw f`No denom for brand: ${g}`;
return S
? l(
O(this.state.account).getBalance(S),
this.facets.getBalanceWatcher,
w,
)
: l(
O(c).query(
GN.typedJson({
address: this.state.address.value,
denom: w,
}),
),
this.facets.queryBalanceWatcher,
);
});
},
getBalances() {
return l(
O(c).query(
jN.typedJson({ address: this.state.address.value }),
),
this.facets.queryBalancesWatcher,
);
},
getPublicTopics() {
return u(async () => {
await null;
let { topicKit: g } = this.state;
if (!g) throw f`No topicKit; storageNode not provided`;
return harden({
account: {
description: c1.account[0],
subscriber: g.subscriber,
storagePath: await g.recorder.getStoragePath(),
},
});
});
},
delegate(g, S) {
let { account: w } = this.state,
I = Es(i, S);
return l(
O(w).executeTx([
QN.typedJson({
amount: I,
validatorAddress: g,
delegatorAddress: this.state.address.value,
}),
]),
this.facets.extractFirstResultWatcher,
);
},
undelegate(g, S) {
let w = Es(i, S),
{ account: I } = this.state;
return l(
O(I).executeTx([
zN.typedJson({
amount: w,
validatorAddress: g,
delegatorAddress: this.state.address.value,
}),
]),
this.facets.undelegateWatcher,
);
},
deposit(g) {
return l(O(this.state.account).deposit(g));
},
withdraw(g) {
return l(O(this.state.account).withdraw(g));
},
executeTx(g) {
return l(O(this.state.account).executeTx(g));
},
getAddress() {
return this.state.address;
},
send(g, S, w = {}) {
return u(() => {
Fo("send", g, S);
let I = i.coerceCosmosAddress(g);
I.chainId === this.state.address.chainId ||
f`bank/send cannot send to a different chain ${x(I.chainId)}`;
let { helper: E } = this.facets;
return l(
O(this.state.account).executeTx([
a1.typedJson({
amount: [E.amountToCoin(S)],
toAddress: I.value,
fromAddress: this.state.address.value,
}),
]),
this.facets.returnVoidWatcher,
);
});
},
sendAll(g, S) {
return u(() => {
Fo("sendAll", g, S);
let { helper: w } = this.facets;
return l(
O(this.state.account).executeTx([
a1.typedJson({
amount: S.map((I) => w.amountToCoin(I)),
toAddress: g.value,
fromAddress: this.state.address.value,
}),
]),
this.facets.returnVoidWatcher,
);
});
},
transfer(g, S, w) {
return u(() => {
Fo("Transferring funds over IBC");
let I = LA(i, S),
{ forwardOpts: E, ...K } = w ?? {},
J = "agoric",
P = i.makeTransferRoute(g, I, J, E);
Fo("got transfer route", P);
let k = i.getAsset(I.denom, J);
assert(k);
let { baseName: U } = k,
D = i.getChainInfoByChainId(Hf(this.state.address)),
_ =
J === U
? i.getChainInfoByChainId(Hf(g))
: i.getChainInfo(U);
return l(
a.allVows([D, _, v.vowOrValueFromOpts(w)]),
this.facets.transferConnectionWatcher,
{ opts: K, route: P },
);
});
},
parseInboundTransfer(g) {
return (
Fo("parseInboundTransfer", g),
u(() => {
let S = g,
w = JSON.parse(atob(S.data)),
{ denom: I, sender: E, receiver: K, amount: J } = w,
P = (D) =>
harden({
amount: { value: BigInt(J), denom: D },
fromAccount: E,
toAccount: K,
extra: { ...w },
}),
k,
U = `${S.source_port}/${S.source_channel}/`;
return (
Fo({ transferDenom: I, prefix: U }),
I.startsWith(U)
? (k = I.slice(U.length))
: (k = `${S.destination_port}/${S.destination_channel}/${I}`),
l(
O(c).queryMany([LN.typedJson({ trace: k })]),
this.facets.parseInboundTransferWatcher,
P(k),
)
);
})
);
},
transferSteps(g, S) {
return u(() => {
throw (
console.log("transferSteps got", g, S),
f`not yet implemented`
);
});
},
sendThenWaitForAck(g, S) {
return l(O(this.state.packetTools).sendThenWaitForAck(g, S));
},
matchFirstPacket(g) {
return l(O(this.state.packetTools).matchFirstPacket(g));
},
monitorTransfers(g) {
return l(O(this.state.packetTools).monitorTransfers(g));
},
},
},
);
};
var Cu = {
promiseFromVow: async (e) => {
let t = await e;
return (
!cr(t) ||
assert.Fail`Unexpected Vow ${t}; only use progress utilities within async flows (withOrchestration)`,
t
);
},
reduceProgressReports: async (e, t, r) => {
let { promiseFromVow: o } = Cu,
n = await o(e.exposePublicationInternals()),
a = harden(r);
for (;;) {
let i = await o(t(n?.value ?? null, a));
if ((harden(i), i == null ? (n = null) : (a = i), n == null))
return a;
n = (await o(n?.tail)) ?? null;
}
},
};
harden(Cu);
var gg = (e, { vowTools: { makeVowKit: t } }) => {
let r = e.exoClassKit(
"ProgressTrackerKit",
void 0,
() => {
let { vow: n, resolver: a } = t();
return {
currentPublication: harden({ value: {}, tail: n }),
done: !1,
tailResolver: a,
};
},
{
helper: {},
public: {
getCurrentProgressReport() {
let { currentPublication: n } = this.state;
return n.value;
},
update(n) {
let {
currentPublication: a,
tailResolver: i,
done: c,
} = this.state;
if (c) return a.value;
let { vow: d, resolver: l } = t(),
u = harden({ value: n, tail: d });
return (
(this.state.currentPublication = u),
i.resolve(u),
(this.state.tailResolver = l),
n
);
},
finish() {
let {
currentPublication: n,
tailResolver: a,
done: i,
} = this.state;
return (
i || (a.resolve(null), (this.state.done = !0)),
n.value
);
},
exposePublicationInternals() {
return this.state.currentPublication;
},
},
},
),
o = () => r().public;
return harden(o);
};
harden(gg);
var { Vow$: XN } = dt,
eB = Ae("Orchestrator"),
tB = s.interface("Orchestrator", {
getChain: s.call(s.string()).returns(XN(s.remotable("ChainFacade"))),
getDenomInfo: s.call(Za, s.string()).returns(sy),
asAmount: s.call(bt).returns(et),
}),
u1 = (
e,
{
chainHub: t,
makeLocalChainFacade: r,
makeRemoteChainFacade: o,
vowTools: { watch: n, asVow: a },
},
) => {
let i = Go("chainName");
return e.exoClassKit(
"Orchestrator",
{
orchestrator: tB,
makeLocalChainFacadeWatcher: s.interface(
"makeLocalChainFacadeWatcher",
{ onFulfilled: s.call(s.record()).returns(s.remotable()) },
),
makeRemoteChainFacadeWatcher: s.interface(
"makeRemoteChainFacadeWatcher",
{
onFulfilled: s
.call(s.any(), s.string())
.optional(s.arrayOf(s.undefined()))
.returns(s.remotable()),
},
),
},
() => (eB("making an Orchestrator"), {}),
{
makeLocalChainFacadeWatcher: {
onFulfilled(c) {
let d = r(c);
return (i.set("agoric", harden({ value: d, pending: !1 })), d);
},
},
makeRemoteChainFacadeWatcher: {
onFulfilled([c, d, l], u) {
let p = o(d, l);
return (i.set(u, harden({ value: p, pending: !1 })), p);
},
},
orchestrator: {
getChain(c) {
return a(() => {
if (i.has(c)) {
let l = i.get(c);
return l.pending ? l.vow : l.value;
}
let d =
c === "agoric"
? n(
t.getChainInfo("agoric"),
this.facets.makeLocalChainFacadeWatcher,
)
: n(
t.getChainsAndConnection("agoric", c),
this.facets.makeRemoteChainFacadeWatcher,
c,
);
return (i.init(c, harden({ vow: d, pending: !0 })), d);
});
},
getDenomInfo(c, d) {
let l = t.getAsset(c, d);
if (!l) throw f`No denom detail for ${x(c)}`;
let { chainName: u, baseName: p, baseDenom: y, brand: b } = l;
i.has(u) ||
f`use getChain(${x(u)}) before getDenomInfo(${x(c)})`;
let m = i.get(u);
if (m.pending)
throw f`wait until getChain(${x(u)}) completes before getDenomInfo(${x(c)})`;
let v = m.value;
i.has(p) ||
f`use getChain(${x(p)}) before getDenomInfo(${x(c)})`;
let h = i.get(p);
if (h.pending)
throw f`wait until getChain(${x(p)}) completes before getDenomInfo(${x(c)})`;
let g = h.value;
return harden({ chain: v, base: g, brand: b, baseDenom: y });
},
asAmount: () => f`not yet implemented`,
},
},
);
};
harden(u1);
var p1 = (e, t) => {
let r = u1(e, t);
return Pr(r, "orchestrator");
};
var rB = Ae("RemoteChainFacade"),
m1 = (
e,
{
makeCosmosOrchestrationAccount: t,
orchestration: r,
storageNode: o,
timer: n,
vowTools: { allVows: a, asVow: i, watch: c },
},
) =>
e.exoClassKit(
"RemoteChainFacade",
{
public: s.interface("RemoteChainFacade", {
..._c,
query: s.call(s.arrayOf(Mc)).returns(le),
}),
makeICQConnectionQueryWatcher: s.interface(
"makeICQConnectionQueryWatcher",
{ onFulfilled: s.call(s.remotable(), s.arrayOf(Mc)).returns(le) },
),
makeAccountAndProvideQueryConnWatcher: s.interface(
"makeAccountAndProvideQueryConnWatcher",
{
onFulfilled: s
.call([s.remotable(), s.or(s.remotable(), s.undefined())])
.returns(le),
},
),
getAddressesWatcher: s.interface("getAddressWatcher", {
onFulfilled: s
.call([je, s.string(), s.string()], s.remotable())
.returns(le),
}),
makeChildNodeWatcher: s.interface("makeChildNodeWatcher", {
onFulfilled: s
.call(s.or(s.remotable(), s.undefined()), {
account: s.remotable(),
chainAddress: je,
localAddress: s.string(),
remoteAddress: s.string(),
})
.returns(s.remotable()),
}),
},
(d, l) => (
rB("making a RemoteChainFacade"),
{ remoteChainInfo: d, connectionInfo: l, icqConnection: void 0 }
),
{
public: {
getChainInfo() {
return c(this.state.remoteChainInfo);
},
makeAccount() {
return i(() => {
let { remoteChainInfo: d, connectionInfo: l } = this.state;
if (d.namespace !== "cosmos")
throw f`only supported on 'cosmos' chains, not ${d.namespace}`;
if (!l) throw f`IBC connection info not found`;
let u =
d?.icqEnabled && !this.state.icqConnection
? O(r).provideICQConnection(l.id)
: void 0,
p = O(r).makeAccount(
d.chainId,
l.counterparty.connection_id,
l.id,
);
return c(
a([p, u]),
this.facets.makeAccountAndProvideQueryConnWatcher,
);
});
},
query(d) {
return i(() => {
let {
remoteChainInfo: { icqEnabled: l, chainId: u },
connectionInfo: p,
} = this.state;
if (!l) throw f`Queries not available for chain ${x(u)}`;
if (!p) throw f`IBC connection info not found`;
return this.state.icqConnection
? c(O(this.state.icqConnection).query(d))
: c(
O(r).provideICQConnection(p.id),
this.facets.makeICQConnectionQueryWatcher,
d,
);
});
},
},
makeAccountAndProvideQueryConnWatcher: {
onFulfilled([d, l]) {
return (
l &&
!this.state.icqConnection &&
(this.state.icqConnection = l),
c(
a([
O(d).getAddress(),
O(d).getLocalAddress(),
O(d).getRemoteAddress(),
]),
this.facets.getAddressesWatcher,
d,
)
);
},
},
makeICQConnectionQueryWatcher: {
onFulfilled(d, l) {
return (
this.state.icqConnection || (this.state.icqConnection = d),
c(O(d).query(l))
);
},
},
getAddressesWatcher: {
onFulfilled([d, l, u], p) {
let y = o ? O(o).makeChildNode(d.value) : void 0;
return c(y, this.facets.makeChildNodeWatcher, {
account: p,
chainAddress: d,
localAddress: l,
remoteAddress: u,
});
},
},
makeChildNodeWatcher: {
onFulfilled(
d,
{
account: l,
chainAddress: u,
localAddress: p,
remoteAddress: y,
},
) {
let { icqConnection: b } = this.state;
return t(
{ chainAddress: u, localAddress: p, remoteAddress: y },
{ account: l, storageNode: d, icqConnection: b, timer: n },
);
},
},
},
);
harden(m1);
var hg = (e, t) => {
let r = m1(e, t);
return Pr(r, "public");
};
harden(hg);
var bg = ({
zone: e,
timerService: t,
zcf: r,
orchestrationService: o,
makeOrchestrator: n,
vowTools: a,
asyncFlowTools: i,
}) => {
kc({
zone: e,
timerService: t,
zcf: r,
orchestrationService: o,
makeOrchestrator: n,
vowTools: a,
asyncFlowTools: i,
});
let { prepareEndowment: c, asyncFlow: d } = i,
l = (p, y, b) => {
let m = e.subZone(p),
[v] = c(m, "endowments", [y]),
h = d(m, "asyncFlow", b);
gf(
v,
(S) =>
S === r &&
assert.fail(
"do not use zcf in orchestration context; try zcfTools",
),
);
let g = (...S) => {
let w = n();
return h(w, v, ...S);
};
return harden(g);
},
u = (p, y) => {
let b = new Map(
Object.entries(p).map(([h, g]) => [g, (...S) => v[h](...S)]),
),
m = gf(y, (h) => b.get(h) || h),
v = Ne(p, (h, g) => l(String(g), m, h));
return { ...v };
};
return harden({ orchestrate: l, orchestrateAll: u });
};
harden(bg);
var Lc = harden({
add: (e, t) => Re(e) + Re(t),
subtract: (e, t) => Re(Re(e) - Re(t)),
multiply: (e, t) => Re(e) * Re(t),
floorDivide: (e, t) => Re(e) / Re(t),
ceilDivide: (e, t) => ((t = Re(t)), Re(Re(e) + t - 1n) / t),
bankersDivide: (e, t) => {
((e = Re(e)), (t = Re(t)));
let r = e / t,
o = e % t;
return o * 2n > t || (o * 2n === t && r % 2n === 1n) ? r + 1n : r;
},
isGTE: (e, t) => Re(e) >= Re(t),
});
var { subtract: poe, add: moe, multiply: foe, floorDivide: yoe } = Lc;
var f1 = (e, t) => {
let r = e,
o = new Map(t);
return harden({
canTransitionTo: (n) => o.get(r).includes(n),
transitionTo: (n) => {
(xe(o.get(r).includes(n)), (r = n));
},
getStatus: (n) => r,
});
};
harden(f1);
var ur = s.string(),
ua = s.remotable("InvitationHandle"),
Zr = s.remotable("Invitation"),
Rt = s.remotable("InstanceHandle"),
mn = s.remotable("Installation"),
Yr = s.remotable("Seat"),
jn = s.recordOf(ur, et),
oB = s.recordOf(ur, s.pattern()),
vg = s.recordOf(ur, s.eref(Zt)),
Ru = s.recordOf(ur, ir),
h1 = s.recordOf(ur, s.eref(ir)),
Ou = s.recordOf(ur, ot),
Sg = s.splitRecord(
{ brand: ot, issuer: ir, assetKind: As },
{ displayInfo: ko },
),
Eu = { issuers: Ru, brands: Ou };
harden(Eu);
var b1 = { installation: mn, instance: Rt, terms: s.splitRecord(Eu) };
harden(b1);
var woe = s.interface("Handle", {}),
nB = (e) => s.remotable(`${e}Handle`),
sB = nB("timer"),
v1 = {
want: oB,
give: jn,
exit: s.splitRecord(
{},
{
onDemand: null,
waived: null,
afterDeadline: { timer: s.eref(sB), deadline: xu },
},
{},
),
};
harden(v1);
var Du = s.splitRecord({}, v1, {}),
Poe = s.splitRecord({ give: {}, want: {}, exit: { onDemand: null } }),
aB = (e) => {
let [t] = Object.keys(e);
return t === "onDemand";
};
harden(aB);
var iB = (e) => {
let [t] = Object.keys(e);
return t === "waived";
};
harden(iB);
var cB = (e) => {
let [t] = Object.keys(e);
return t === "afterDeadline";
};
harden(cB);
var koe = s.splitRecord({
description: s.string(),
handle: ua,
instance: Rt,
installation: mn,
}),
S1 = s.interface("OfferHandler", {
handle: s.call(Yr).optional(s.any()).returns(s.any()),
}),
dB = s.arrayOf({ seatHandle: Yr, allocation: jn }),
y1 = s.remotable("ZoeMint"),
Ioe = s.interface("ZoeMint", {
getIssuerRecord: s.call().returns(Sg),
mintAndEscrow: s.call(et).returns(),
withdrawAndBurn: s.call(et).returns(),
}),
x1 = s.remotable("FeeMintAccess"),
Toe = s.interface("Exit Object", { exit: s.call().returns() }),
A1 = s.remotable("ExitObj"),
lB = s.remotable("InstanceAdmin"),
Uoe = s.interface("InstanceAdmin", {
makeInvitation: s
.call(ua, s.string())
.optional(s.record(), s.pattern())
.returns(Zr),
saveIssuer: s.callWhen(s.await(ir), ur).returns(Sg),
makeNoEscrowSeat: s.call(jn, Du, A1, Yr).returns(Yr),
exitAllSeats: s.call(s.any()).returns(),
failAllSeats: s.call(s.any()).returns(),
exitSeat: s.call(Yr, s.any()).returns(),
failSeat: s.call(Yr, s.any()).returns(),
makeZoeMint: s
.call(ur)
.optional(As, ko, s.splitRecord({}, { elementShape: s.pattern() }))
.returns(s.remotable("zoeMint")),
registerFeeMint: s.call(ur, x1).returns(s.remotable("feeMint")),
replaceAllocations: s.call(dB).returns(),
stopAcceptingOffers: s.call().returns(),
setOfferFilter: s.call(s.arrayOf(s.string())).returns(),
getOfferFilter: s.call().returns(s.arrayOf(s.string())),
getExitSubscriber: s.call(Yr).returns(wc),
isBlocked: s.call(s.string()).returns(s.boolean()),
repairContractCompletionWatcher: s.call().returns(),
}),
uB = {
instanceStorageManager: s.interface("InstanceStorageManager", {
getTerms: s.call().returns(s.splitRecord(Eu)),
getIssuers: s.call().returns(Ru),
getBrands: s.call().returns(Ou),
getInstallation: s.call().returns(mn),
getInvitationIssuer: s.call().returns(ir),
saveIssuer: s.call(ir, ur).returns(s.promise()),
makeZoeMint: s
.call(ur)
.optional(As, ko, s.splitRecord({}, { elementShape: s.pattern() }))
.returns(s.eref(y1)),
registerFeeMint: s.call(ur, x1).returns(s.remotable("feeMint")),
getInstanceRecord: s.call().returns(b1),
getIssuerRecords: s.call().returns(s.arrayOf(Sg)),
getWithdrawFacet: s.call().returns(s.remotable("WithdrawFacet")),
initInstanceAdmin: s
.call(Rt, s.remotable("instanceAdmin"))
.returns(s.promise()),
deleteInstanceAdmin: s.call(lB).returns(),
makeInvitation: s
.call(ua, s.string())
.optional(s.record(), s.pattern())
.returns(Zt),
getRoot: s.call().returns(s.any()),
getAdminNode: s.call().returns(s.remotable("adminNode")),
}),
withdrawFacet: s.interface("WithdrawFacet", {
withdrawPayments: s.call(jn).returns(vg),
}),
helpers: s.interface("InstanceStorageManager helper", {
wrapIssuerKitWithZoeMint: s
.call(ur, tf, s.remotable("adminNode"))
.returns(y1),
}),
};
harden(uB);
var w1 = s.remotable("bundleCap"),
g1 = s.and(
s.splitRecord({ moduleFormat: s.any() }),
s.recordOf(s.string(), s.string({ stringLengthLimit: 1 / 0 })),
),
pB = s.splitRecord(
{ installation: mn },
{
bundle: s.recordOf(
s.string(),
s.string({ stringLengthLimit: 1 / 0 }),
),
bundleCap: w1,
bundleID: s.string(),
},
{},
),
mB = {
zoeServiceDataAccess: s.interface("ZoeService dataAccess", {
getTerms: s.call(Rt).returns(s.splitRecord(Eu)),
getIssuers: s.call(Rt).returns(Ru),
getBrands: s.call(Rt).returns(Ou),
getInstallation: s
.call(Rt)
.returns(s.eref(s.remotable("Installation"))),
getInvitationIssuer: s.call().returns(ir),
getBundleIDFromInstallation: s.call(mn).returns(s.eref(s.string())),
installBundle: s.call(g1).optional(s.string()).returns(s.promise()),
installBundleID: s
.call(s.string())
.optional(s.string())
.returns(s.promise()),
getPublicFacet: s
.call(Rt)
.returns(s.eref(s.remotable("PublicFacet"))),
getOfferFilter: s.call(Rt).returns(s.arrayOf(s.string())),
getProposalShapeForInvitation: s.call(ua).returns(s.opt(s.pattern())),
}),
makeOfferAccess: s.interface("ZoeStorage makeOffer access", {
getAssetKindByBrand: s.call(ot).returns(As),
getInstanceAdmin: s.call(Rt).returns(s.remotable("instanceAdmin")),
getProposalShapeForInvitation: s.call(ua).returns(s.opt(s.pattern())),
getInvitationIssuer: s.call().returns(ir),
depositPayments: s.call(Du, vg).returns(s.promise()),
}),
startInstanceAccess: s.interface("ZoeStorage startInstance access", {
makeZoeInstanceStorageManager: s
.call(mn, s.any(), h1, Rt, s.or(w1, g1), s.string())
.returns(s.promise()),
unwrapInstallation: s.callWhen(s.eref(mn)).returns(pB),
}),
invitationIssuerAccess: s.interface("ZoeStorage invitationIssuer", {
getInvitationIssuer: s.call().returns(ir),
}),
};
harden(mB);
var Coe = s.interface("ZoeService", {
install: s.call(s.any()).optional(s.string()).returns(s.promise()),
installBundleID: s
.call(s.string())
.optional(s.string())
.returns(s.promise()),
startInstance: s
.call(s.eref(mn))
.optional(h1, s.record(), s.record(), s.string())
.returns(s.promise()),
offer: s
.call(s.eref(Zr))
.optional(Du, vg, s.any())
.returns(s.promise()),
getOfferFilter: s.callWhen(s.await(Rt)).returns(s.arrayOf(s.string())),
getInvitationIssuer: s.call().returns(s.promise()),
getFeeIssuer: s.call().returns(s.promise()),
getBrands: s.callWhen(s.await(Rt)).returns(Ou),
getIssuers: s.callWhen(s.await(Rt)).returns(Ru),
getPublicFacet: s
.callWhen(s.await(Rt))
.returns(s.remotable("PublicFacet")),
getTerms: s.callWhen(s.await(Rt)).returns(s.any()),
getInstallationForInstance: s
.callWhen(s.await(Rt))
.returns(s.eref(s.remotable("Installation"))),
getBundleIDFromInstallation: s
.callWhen(s.await(mn))
.returns(s.eref(s.string())),
getInstallation: s.call(s.eref(Zr)).returns(s.promise()),
getInstance: s.call(s.eref(Zr)).returns(s.promise()),
getConfiguration: s
.call()
.returns({
feeIssuerConfig: {
name: s.string(),
assetKind: "nat",
displayInfo: ko,
},
}),
getInvitationDetails: s.call(s.eref(Zr)).returns(s.any()),
getProposalShapeForInvitation: s.call(ua).returns(s.opt(s.pattern())),
}),
Roe = s.interface("ZcfAdminFacet", {
getVatShutdownPromise: s.call().returns(s.promise()),
restartContract: s.call().optional(s.any()).returns(s.promise()),
upgradeContract: s
.call(s.string())
.optional(s.any())
.returns(s.promise()),
terminateContract: s.call(s.error()).returns(s.promise()),
}),
fB = s.splitRecord(
{ proposal: Du, initialAllocation: jn, seatHandle: Yr },
{ offerArgs: s.any() },
),
Ooe = s.interface("HandleOffer", {
handleOffer: s
.call(ua, fB)
.returns({ offerResultPromise: s.promise(), exitObj: A1 }),
}),
yB = { quoteAmount: et, quotePayment: s.eref(Zt) };
harden(yB);
var Boe = s.splitArray(
harden([s.opt(Yr), s.opt(Yr), s.opt(jn)]),
harden([s.opt(jn)]),
);
var xg = (e, t = void 0, r = void 0, o = void 0, n = void 0) =>
e.atomicRearrange(harden([[t, r, o, n]]));
var P1 = (e = {}, t) => {
let r = ([o, n]) => {
if (t[o] === void 0) return 0;
let a = t[o];
return Le.isGTE(a, n) ? 1 : 0;
};
return Object.entries(e).every(r) ? 1 : 0;
},
Ag = (e, t) => P1(e.want, t),
gB = (e, t) => P1(e.give, t);
function hB(e, t) {
return gB(e, t) > 0 || Ag(e, t) > 0;
}
harden(hB);
harden(Ag);
var SB = "Deposit and reallocation successful.",
Nu = async (e, t, r, o) => {
!t.hasExited() || f`The recipientSeat cannot have exited.`;
let n = (l) => (xg(e, l, t, r), l.exit(), SB),
a = e.makeInvitation(n, "temporary seat for deposit"),
i = harden({ give: r });
harden(o);
let c = e.getZoeService(),
d = O(c).offer(a, i, o);
return O(d).getOfferResult();
};
var {
multiply: Xoe,
floorDivide: ene,
ceilDivide: tne,
bankersDivide: rne,
add: one,
subtract: nne,
} = Lc;
var xB = (e) => {
let t = new WeakMap();
return (r) => {
if (t.has(r)) return t.get(r);
let o = e(r);
return (t.set(r, o), o);
};
};
harden(xB);
var AB = (e, t, r) => wo(t, r, () => e.makeEmptySeatKit().zcfSeat);
harden(AB);
var wB = (e, t) => {
let r = Object.keys(t);
if (e.has(r[0])) {
let a = Ne(t, (i, c) => e.get(c));
return Promise.resolve(harden(a));
}
let n = Ne(t, (a) => a());
return OS(n).then((a) => {
for (let [i, c] of Object.entries(a)) e.init(i, c);
return a;
});
};
harden(wB);
var Bu = (e, t, r = {}) =>
harden({
...So(
t.map((o) => [
o,
{
[o](...n) {
let { underlying: a } = this.state;
return (a !== void 0 || f`${x(e)} revoked`, a[o](...n));
},
}[o],
]),
),
...r,
});
harden(Bu);
var k1 = (e, t, r, o = {}) => {
let {
uInterfaceName: n = t,
extraMethodGuards: a = {},
extraMethods: i = {},
} = o,
c = s.interface(`${n}_attenuator`, a, { defaultGuards: "raw" }),
d = `${t}_attenuator`;
return e.exoClass(d, c, (l) => ({ underlying: l }), Bu(d, r, i), {
stateShape: { underlying: s.opt(s.remotable("underlying")) },
});
};
harden(k1);
var PB = /^(Alleged: |DebugName: )/,
kB = (e, t, r = void 0) => {
let o = Yo(),
n = (e[Symbol.toStringTag] || "Underlying").replace(PB, "");
return k1(o, n, t, r)(e);
};
harden(kB);
var wg = (e, t, r, o = {}) => {
let {
uInterfaceName: n = t,
extraMethodGuards: a = {},
extraMethods: i = {},
} = o,
c = harden({
revoker: s.interface(`${n}_revoker`, {
revoke: s.call().returns(s.boolean()),
}),
revocable: s.interface(`${n}_revocable`, a, { defaultGuards: "raw" }),
}),
d = `${t}_caretaker`,
l,
u = e.exoClassKit(
d,
c,
(b) => ({ underlying: b }),
{
revoker: {
revoke() {
let { state: b } = this;
return b.underlying === void 0
? !1
: ((b.underlying = void 0), !0);
},
},
revocable: Bu(d, r, i),
},
{
stateShape: { underlying: s.opt(s.remotable("underlying")) },
receiveAmplifier: (b) => {
l = b;
},
},
),
p = (b) => u(b).revocable,
y = (b) => {
let m = l(b);
return m === void 0 ? !1 : m.revoker.revoke();
};
return harden({ revoke: y, makeRevocable: p, makeRevocableKit: u });
};
harden(wg);
var IB = s.splitRecord({ give: {}, want: {}, exit: { onDemand: null } }),
TB = (e, t, r, o, n = {}) => {
let { uInterfaceName: a = r } = n,
{ revoke: i, makeRevocable: c } = wg(e, r, o, {
uInterfaceName: a,
extraMethodGuards: {
makeTransferInvitation: s.call().returns(s.promise()),
},
extraMethods: {
makeTransferInvitation() {
let { underlying: u } = this.state,
{ revocable: p } = this.facets,
y = u.getInvitationCustomDetails(),
b = d(u),
m = t(b, "transfer", y, IB);
return (i(p), m);
},
},
}),
d = e.exoClass("TransferHandler", S1, (u) => ({ underlying: u }), {
handle(u) {
let { underlying: p } = this.state,
y = c(p);
return (u.exit(), y);
},
}),
l = (u) => c(u);
return harden(l);
};
harden(TB);
var Nne = Ae("PA", !1);
var Gn = s.call(et, et).returns(s.promise()),
Bne = s.interface("PriceAuthority", {
getQuoteIssuer: s.call(ot, ot).returns(s.promise()),
getTimerService: s.call(ot, ot).returns(s.promise()),
quoteGiven: s.call(et, ot).returns(s.promise()),
quoteWanted: s.call(ot, et).returns(s.promise()),
makeQuoteNotifier: s.call(et, ot).returns(s.promise()),
quoteAtTime: s.call(xu, et, ot).returns(s.promise()),
quoteWhenLT: Gn,
quoteWhenLTE: Gn,
quoteWhenGTE: Gn,
quoteWhenGT: Gn,
mutableQuoteWhenLT: Gn,
mutableQuoteWhenLTE: Gn,
mutableQuoteWhenGTE: Gn,
mutableQuoteWhenGT: Gn,
});
var UB = async (e) => {
let r = (await O(e).getDisplayInfo()).decimalPlaces ?? 0;
return Le.make(e, 10n ** Re(r));
};
harden(UB);
var I1 = Ae("ZoeTools"),
{ assign: T1, keys: Pg, values: U1 } = Object,
C1 = (e, { when: t, allVows: r, allSettled: o, asVow: n }) => {
let a = (c, d, l) =>
n(async () => {
!c.hasExited() || f`The seat cannot have exited.`;
let { zcfSeat: u, userSeat: p } = e.makeEmptySeatKit(),
y = await p;
(e.atomicRearrange(harden([[c, u, l]])), u.exit());
let b = await Promise.all(Pg(l).map((v) => O(y).getPayout(v))),
m = await t(o(b.map((v) => O(d).deposit(v))));
if (m.find((v) => v.status === "rejected")) {
let v = U1(l),
h = [],
g = m.map((E, K) =>
E.status === "rejected"
? (h.push(E.reason), b[K])
: O(d).withdraw(v[K]),
),
S = await t(r(g)),
w = harden(
Pg(l).reduce((E, K, J) => T1(E, { [K]: S[J] }), {}),
),
I = await Nu(e, c, l, w);
throw (
I1("localTransfer depositResponse", I),
Se(`One or more deposits failed ${x(h)}`)
);
}
}),
i = (c, d, l) =>
n(async () => {
!d.hasExited() || f`The seat cannot have exited.`;
let u = await t(o(U1(l).map((m) => O(c).withdraw(m))));
if (u.find((m) => m.status === "rejected")) {
let m = [],
v = [];
for (let h of u)
h.status === "fulfilled"
? m.push(O(c).deposit(h.value))
: v.push(h.reason);
throw (
await t(r(m)),
Se(`One or more withdrawals failed ${x(v)}`)
);
}
let p = u,
y = harden(
Pg(l).reduce((m, v, h) => T1(m, { [v]: p[h].value }), {}),
),
b = await Nu(e, d, l, y);
I1("withdrawToSeat depositResponse", b);
});
return harden({ localTransfer: a, withdrawToSeat: i });
};
var CB = s.remotable("OfferHandler"),
R1 = (e, t) =>
harden({
makeInvitation(r, o, n, a) {
return (Be(r, CB), t.watch(e.makeInvitation(r, o, n, a)));
},
atomicRearrange(r) {
e.atomicRearrange(r);
},
assertUniqueKeyword(r) {
e.assertUniqueKeyword(r);
},
});
var O1 = (e, t, r, o, n = {}) => {
let a = (() => {
let P = xs(t);
return {
asyncFlow: P.subZone("asyncFlow"),
orchestration: P.subZone("orchestration"),
chainHub: P.subZone("chainHub"),
vows: P.subZone("vows"),
contract: P.subZone("contract"),
};
})(),
{ agoricNames: i, timerService: c, localchain: d } = r,
l = Fn(a.vows),
u = WA(a.chainHub, i, l, {
chainInfoValueShape: n.chainInfoValueShape,
}),
p = C1(e, l),
y = R1(e, l),
b = MA(o),
{ makeRecorderKit: m } = FA(t, b),
v = gg(a.orchestration, { vowTools: l }),
h = l1(a.orchestration, {
makeProgressTracker: v,
makeRecorderKit: m,
zcf: e,
timerService: c,
vowTools: l,
chainHub: u,
localchain: d,
zoeTools: p,
}),
g = Oy(a.asyncFlow, { vowTools: l }),
S = Zw(a.orchestration, {
chainHub: u,
makeProgressTracker: v,
makeRecorderKit: m,
timerService: c,
vowTools: l,
zcf: e,
}),
w = hg(a.orchestration, {
makeCosmosOrchestrationAccount: S,
orchestration: r.orchestrationService,
storageNode: r.storageNode,
timer: r.timerService,
vowTools: l,
}),
I = ug(a.orchestration, {
makeLocalOrchestrationAccountKit: h,
localchain: r.localchain,
storageNode: r.storageNode,
agoricNames: i,
orchestration: r.orchestrationService,
timer: r.timerService,
vowTools: l,
}),
E = p1(a.orchestration, {
chainHub: u,
makeLocalChainFacade: I,
makeRemoteChainFacade: w,
vowTools: l,
}),
K = (P) =>
bg({
zone: P,
zcf: e,
makeOrchestrator: E,
asyncFlowTools: g,
vowTools: l,
...r,
}),
J = K(a.contract.subZone("orchestration"));
return (
e.setTestJig(() => ({ baggage: t, chainHub: u })),
{
...J,
makeOrchestrateKit: K,
baggage: t,
cachingMarshaller: b,
chainHub: u,
vowTools: l,
asyncFlowTools: g,
zcfTools: y,
zoeTools: p,
zone: a.contract,
}
);
};
harden(O1);
var Mu = (e, t) => async (r, o, n) => {
let { marshaller: a, ...i } = o,
{ storageNode: c, ...d } = i,
{ publishAccountInfo: l, chainInfoValueShape: u } = t ?? {},
{ zone: p, ...y } = O1(r, n, l ? i : d, a, { chainInfoValueShape: u }),
[b] = await Promise.all([e(r, o, p, y), y.asyncFlowTools.allWokenP]);
return b;
};
harden(Mu);
var RB = { omniflixhub: !0, osmosis: !0 };
harden(RB);
var OB = {
agoric: !0,
celestia: !0,
cosmoshub: !0,
juno: !0,
neutron: !0,
noble: !0,
omniflixhub: !0,
osmosis: !0,
secretnetwork: !0,
stargaze: !0,
stride: !0,
umee: !0,
};
harden(OB);
var EB = {
celestia: !0,
cosmoshub: !0,
dydx: !0,
juno: !0,
neutron: !0,
noble: !0,
omniflixhub: !0,
osmosis: !0,
secretnetwork: !0,
stargaze: !0,
stride: !0,
umee: !0,
};
harden(EB);
var kg = (e, t, r, o, { log: n = () => {} } = {}) => {
if ((n("chainHub: registering chains", Object.keys(r || {})), !r)) return;
let a = {};
for (let [c, d] of Object.entries(r))
if (d.namespace === "cosmos") {
let { connections: l, ...u } = d;
(e.registerChain(c, u), l && (a[u.chainId] = l));
} else e.registerChain(c, d);
let i = new Set();
for (let [c, d] of Object.entries(a))
for (let [l, u] of Object.entries(d)) {
let p = [c, l].sort().join("<->");
i.has(p) || (e.registerConnection(c, l, u), i.add(p));
}
if (
(n("chainHub: registered connections", [...i].sort()),
n(
"chainHub: registering assets",
o?.map(([c, { chainName: d }]) => `${d}: ${c}`),
),
!!o)
)
for (let [c, d] of o) {
let { brandKey: l, ...u } = d,
p = l ? { ...u, brand: t[l] } : u;
e.registerAsset(c, p);
}
};
var Tg = { features: { useProgressTracker: !0 } };
harden(Tg);
var Ug = Wr({
Aave: null,
Compound: null,
USDN: null,
Beefy: null,
ERC4626: null,
});
harden(Ug);
var DB = {
Supply: "supply",
Withdraw: "withdraw",
DepositForBurn: "depositforburn",
};
harden(DB);
var _e = Wr({
Arbitrum: null,
Avalanche: null,
Base: null,
Ethereum: null,
Optimism: null,
});
harden(_e);
var $u = {
mainnet: {
Arbitrum: 42161n,
Avalanche: 43114n,
Base: 8453n,
Ethereum: 1n,
Optimism: 10n,
},
testnet: {
Arbitrum: 421614n,
Avalanche: 43113n,
Base: 84532n,
Ethereum: 11155111n,
Optimism: 11155420n,
},
local: {},
};
harden($u);
var _u = Wr({
Arbitrum: "Arbitrum",
Avalanche: "Avalanche",
Base: "Base",
Ethereum: "Ethereum",
Optimism: "Optimism",
agoric: "agoric",
noble: "noble",
});
harden(_u);
var Ig = (e) => `eip155:${e}`,
NB = {
mainnet: {
...Ne($u.mainnet, Ig),
agoric: "cosmos:agoric-3",
noble: "cosmos:noble-1",
},
testnet: {
...Ne($u.testnet, Ig),
agoric: "cosmos:agoricdev-25",
noble: "cosmos:grand-1",
},
local: { ...Ne($u.local, Ig) },
};
harden(NB);
var BB = {
mainnet: {
Arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
Avalanche: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
Base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
Ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
Optimism: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
agoric:
"ibc/FE98AAD68F02F03565E9FA39A5E627946699B2B07115889ED812D8BA639576A9",
noble: "usdc",
},
testnet: {
Arbitrum: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
Avalanche: "0x5425890298aed601595a70AB815c96711a31Bc65",
Base: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
Ethereum: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
Optimism: "0x5fd84259d66Cd46123540766Be93DFE6D43130D7",
agoric:
"ibc/75F84596DDE9EE93010620701FFED959F3FFA1D0979F6773DE994FFEEA7D32F3",
noble: "usdc",
},
local: {},
};
harden(BB);
var MB = { Preset: "preset", PreserveExistingProportions: "pep" };
harden(MB);
var Cg = 100n,
$B = s.splitRecord({}, { useProgressTracker: s.boolean() }),
E1 = s.splitRecord({}, { features: $B }),
Fu = "&planner";
ed();
var k$ = class extends De {
constructor({ domain: e }) {
super(`Invalid domain "${CP(e)}".`, {
metaMessages: ["Must be a valid EIP-712 domain."],
});
}
},
I$ = class extends De {
constructor({ primaryType: e, types: t }) {
super(
`Invalid primary type \`${e}\` must be one of \`${JSON.stringify(Object.keys(t))}\`.`,
{
docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
metaMessages: [
"Check that the primary type is a key in `types`.",
],
},
);
}
},
T$ = class extends De {
constructor({ type: e }) {
super(`Struct type "${e}" is invalid.`, {
metaMessages: ["Struct type must not be a Solidity type."],
name: "InvalidStructTypeError",
});
}
};
function Ak(e) {
let { domain: t = {}, message: r, primaryType: o } = e,
n = { EIP712Domain: ap({ domain: t }), ...e.types };
sp({ domain: t, message: r, primaryType: o, types: n });
let a = ["0x1901"];
return (
t && a.push(U$({ domain: t, types: n })),
o !== "EIP712Domain" &&
a.push(ad({ data: r, primaryType: o, types: n })),
ro(ts(a))
);
}
function U$({ domain: e, types: t }) {
return ad({ data: e, primaryType: "EIP712Domain", types: t });
}
function ad({ data: e, primaryType: t, types: r }) {
let o = wk({ data: e, primaryType: t, types: r });
return ro(o);
}
function wk({ data: e, primaryType: t, types: r }) {
let o = [{ type: "bytes32" }],
n = [C$({ primaryType: t, types: r })];
for (let a of r[t]) {
let [i, c] = kk({
types: r,
name: a.name,
type: a.type,
value: e[a.name],
});
(o.push(i), n.push(c));
}
return oo(o, n);
}
function C$({ primaryType: e, types: t }) {
let r = xi(R$({ primaryType: e, types: t }));
return ro(r);
}
function R$({ primaryType: e, types: t }) {
let r = "",
o = Pk({ primaryType: e, types: t });
o.delete(e);
let n = [e, ...Array.from(o).sort()];
for (let a of n)
r += `${a}(${t[a].map(({ name: i, type: c }) => `${c} ${i}`).join(",")})`;
return r;
}
function Pk({ primaryType: e, types: t }, r = new Set()) {
let n = e.match(/^\w*/u)?.[0];
if (r.has(n) || t[n] === void 0) return r;
r.add(n);
for (let a of t[n]) Pk({ primaryType: a.type, types: t }, r);
return r;
}
function kk({ types: e, name: t, type: r, value: o }) {
if (e[r] !== void 0)
return [
{ type: "bytes32" },
ro(wk({ data: o, primaryType: r, types: e })),
];
if (r === "bytes") return [{ type: "bytes32" }, ro(o)];
if (r === "string") return [{ type: "bytes32" }, ro(xi(o))];
if (r.lastIndexOf("]") === r.length - 1) {
let n = r.slice(0, r.lastIndexOf("[")),
a = o.map((i) => kk({ name: t, type: n, types: e, value: i }));
return [
{ type: "bytes32" },
ro(
oo(
a.map(([i]) => i),
a.map(([, i]) => i),
),
),
];
}
return [{ type: r }, o];
}
function sp(e) {
let { domain: t, message: r, primaryType: o, types: n } = e,
a = (i, c) => {
for (let d of i) {
let { name: l, type: u } = d,
p = c[l],
y = u.match(Hg);
if (y && (typeof p == "number" || typeof p == "bigint")) {
let [v, h, g] = y;
vn(p, { signed: h === "int", size: Number.parseInt(g, 10) / 8 });
}
if (u === "address" && typeof p == "string" && !es(p))
throw new ju({ address: p });
let b = u.match(UP);
if (b) {
let [v, h] = b;
if (h && Nt(p) !== Number.parseInt(h, 10))
throw new lP({
expectedSize: Number.parseInt(h, 10),
givenSize: Nt(p),
});
}
let m = n[u];
m && (O$(u), a(m, p));
}
};
if (n.EIP712Domain && t) {
if (typeof t != "object") throw new k$({ domain: t });
a(n.EIP712Domain, t);
}
if (o !== "EIP712Domain")
if (n[o]) a(n[o], r);
else throw new I$({ primaryType: o, types: n });
}
function ap({ domain: e }) {
return [
typeof e?.name == "string" && { name: "name", type: "string" },
e?.version && { name: "version", type: "string" },
(typeof e?.chainId == "number" || typeof e?.chainId == "bigint") && {
name: "chainId",
type: "uint256",
},
e?.verifyingContract && { name: "verifyingContract", type: "address" },
e?.salt && { name: "salt", type: "bytes32" },
].filter(Boolean);
}
function O$(e) {
if (
e === "address" ||
e === "bool" ||
e === "string" ||
e.startsWith("bytes") ||
e.startsWith("uint") ||
e.startsWith("int")
)
throw new T$({ type: e });
}
function E$(e) {
let t = ro(`0x${e.substring(4)}`).substring(26);
return Gu(`0x${t}`);
}
async function D$({ hash: e, signature: t }) {
let r = to(e) ? e : xi(e),
{ secp256k1: o } = await Promise.resolve().then(() => (Sk(), vk));
return `0x${(() => {
if (typeof t == "object" && "r" in t && "s" in t) {
let { r: l, s: u, v: p, yParity: y } = t,
b = Number(y ?? p),
m = xk(b);
return new o.Signature(qu(l), qu(u)).addRecoveryBit(m);
}
let i = to(t) ? t : xi(t);
if (Nt(i) !== 65) throw new Error("invalid signature length");
let c = hP(`0x${i.slice(130)}`),
d = xk(c);
return o.Signature.fromCompact(i.substring(2, 130)).addRecoveryBit(d);
})()
.recoverPublicKey(r.substring(2))
.toHex(!1)}`;
}
function xk(e) {
if (e === 0 || e === 1) return e;
if (e === 27) return 0;
if (e === 28) return 1;
throw new Error("Invalid yParityOrV value");
}
async function N$({ hash: e, signature: t }) {
return E$(await D$({ hash: e, signature: t }));
}
async function ip(e) {
let { domain: t, message: r, primaryType: o, signature: n, types: a } = e;
return N$({
hash: Ak({ domain: t, message: r, primaryType: o, types: a }),
signature: n,
});
}
ed();
cp();
ed();
cp();
function Ik({ primaryType: e, types: t }) {
let r = "",
o = Tk({ primaryType: e, types: t });
o.delete(e);
let n = [e, ...Array.from(o).sort()];
for (let a of n)
r += `${a}(${t[a].map(({ name: i, type: c }) => `${c} ${i}`).join(",")})`;
return r;
}
function Tk({ primaryType: e, types: t }, r = new Set()) {
let n = e.match(/^\w*/u)?.[0];
if (r.has(n) || t[n] === void 0) return r;
r.add(n);
for (let a of t[n]) Tk({ primaryType: a.type, types: t }, r);
return r;
}
var Uk = "Permit2";
var Ck = [
{ name: "name", type: "string" },
{ name: "chainId", type: "uint256" },
{ name: "verifyingContract", type: "address" },
],
lh = [
{ name: "permitted", type: "TokenPermissions" },
{ name: "spender", type: "address" },
{ name: "nonce", type: "uint256" },
{ name: "deadline", type: "uint256" },
],
uh = [
{ name: "permitted", type: "TokenPermissions[]" },
{ name: "spender", type: "address" },
{ name: "nonce", type: "uint256" },
{ name: "deadline", type: "uint256" },
],
dp = [
{ name: "token", type: "address" },
{ name: "amount", type: "uint256" },
];
function Rk(e) {
return {
EIP712Domain: Ck,
PermitWitnessTransferFrom: [...lh, ...(e ? [e.witnessField] : [])],
TokenPermissions: dp,
...e?.witnessTypes,
};
}
function Ok(e) {
return {
EIP712Domain: Ck,
PermitBatchWitnessTransferFrom: [...uh, ...(e ? [e.witnessField] : [])],
TokenPermissions: dp,
...e?.witnessTypes,
};
}
var Ek = Wr({
PermitBatchWitnessTransferFrom: null,
PermitWitnessTransferFrom: null,
}),
ph = (e) => e in Ek,
Dk = (e) => {
let t = Object.keys(e).filter(ph);
if (t.length !== 1)
throw new Error(
`Exactly one of the following types must be defined: ${Object.keys(Ek).join(", ")}`,
);
return t[0];
},
B$ = {
PermitBatchWitnessTransferFrom: uh,
PermitWitnessTransferFrom: lh,
},
M$ = {
PermitBatchWitnessTransferFrom: Ok,
PermitWitnessTransferFrom: Rk,
},
Nk = (e) => {
let { encodeType: t } = e,
r = AS(M$, (n, a) => {
let i = n(void 0),
c = t({ primaryType: a, types: i });
return `${c.substring(0, c.indexOf(")"))},`;
});
return (n) => {
let a = Dk(n),
i = t({ primaryType: a, types: n }),
c = r[a];
if (!i.startsWith(c))
throw new Error(`${a} must start with expected base fields`);
return i.substring(c.length);
};
},
Bk = ({ TokenPermissions: e }) => {
for (let [t, { name: r, type: o }] of dp.entries())
if (e[t].name !== r || e[t].type !== o)
throw new Error(
`TokenPermissions field at index ${t} must be \`${o} ${r}\``,
);
};
function Mk(e, t) {
if (!e) throw new Error("Missing domain in permit2 data");
let { chainId: r, verifyingContract: o, name: n } = e;
if (n !== Uk) throw new Error(`Invalid permit2 domain name: ${n}`);
if (typeof r != "bigint" || !o)
throw new Error(
"Permit2 domain must include chainId and verifyingContract",
);
if (t) {
let a = String(r),
i = t[a];
if (!qe(o, i))
throw new Error(
`Invalid verifying contract for chain ID ${r}: ${o} (expected ${i})`,
);
}
}
var mh = (e) => {
let t = Dk(e),
r = e[t],
o = B$[t];
if (r.length !== o.length + 1)
throw new Error(`${t} must have ${o.length + 1} fields`);
for (let [n, { name: a, type: i }] of o.entries())
if (r[n].name !== a || r[n].type !== i)
throw new Error(`${t} field at index ${n} must be \`${i} ${a}\``);
return r[r.length - 1];
},
lp = [
{ name: "token", type: "address" },
{ name: "amount", type: "uint256" },
],
$k = "struct ISignatureTransfer.TokenPermissions",
id = [
{ name: "permitted", type: "tuple", internalType: $k, components: lp },
{ name: "nonce", type: "uint256" },
{ name: "deadline", type: "uint256" },
],
cd = "struct ISignatureTransfer.PermitTransferFrom",
$$ = [
{
name: "permitted",
type: "tuple[]",
internalType: `${$k}[]`,
components: lp,
},
{ name: "nonce", type: "uint256" },
{ name: "deadline", type: "uint256" },
],
_$ = "struct ISignatureTransfer.PermitBatchTransferFrom",
_k = [
{ name: "to", type: "address" },
{ name: "requestedAmount", type: "uint256" },
],
Fk = "struct ISignatureTransfer.SignatureTransferDetails",
fh = [
{ name: "permit", type: "tuple", internalType: cd, components: id },
{
name: "transferDetails",
type: "tuple",
internalType: Fk,
components: _k,
},
{ name: "owner", type: "address" },
{ name: "witness", type: "bytes32" },
{ name: "witnessTypeString", type: "string" },
{ name: "signature", type: "bytes" },
],
ele = [
{ name: "permit", type: "tuple", internalType: _$, components: $$ },
{
name: "transferDetails",
type: "tuple[]",
internalType: `${Fk}[]`,
components: _k,
},
{ name: "owner", type: "address" },
{ name: "witness", type: "bytes32" },
{ name: "witnessTypeString", type: "string" },
{ name: "signature", type: "bytes" },
],
Kk = {
name: "permitWitnessTransferFrom",
inputs: fh,
outputs: [],
stateMutability: "nonpayable",
type: "function",
};
var dd = "Ymax",
Jk = "1";
var Ii = { name: "portfolio", type: "uint256" };
var yh = {
OpenPortfolio: [{ name: "allocations", type: "Allocation[]" }],
Rebalance: [Ii],
SetTargetAllocation: [
{ name: "allocations", type: "Allocation[]" },
Ii,
],
Deposit: [Ii],
Withdraw: [{ name: "withdraw", type: "Asset" }, Ii],
Grant: [
{ name: "accountHolder", type: "string" },
{ name: "permissions", type: "PortfolioPermissions" },
Ii,
],
SetAutoFeatures: [
{ name: "features", type: "PortfolioAutoFeatures" },
Ii,
],
},
F$ = {
Allocation: [
{ name: "instrument", type: "string" },
{ name: "portion", type: "uint256" },
],
Asset: lp,
PortfolioPermissions: [{ name: "allocation", type: "bool" }],
PortfolioAutoFeatures: [{ name: "rebalance", type: "bool" }],
};
var K$ = (e, t) => ({ [e]: t, ...F$ });
var gh = (e) => K$(e, yh[e]);
function Vk(e) {
if (e.name !== dd)
throw new Error(`Invalid Ymax domain name: ${e.name} (expected ${dd})`);
if (e.version !== Jk)
throw new Error(
`Invalid Ymax domain version: ${e.version} (expected ${Jk})`,
);
}
function hh(e, t) {
if (
(Vk(e), typeof e.chainId != "bigint" || e.verifyingContract === void 0)
)
throw new Error(
"Ymax domain must include chain ID and verifying contract",
);
if (t) {
let o = String(e.chainId);
if (!(o in t))
throw new Error(`Unknown chain ID in Ymax domain: ${e.chainId}`);
if (!qe(e.verifyingContract, t[o]))
throw new Error(
`Invalid verifying contract for chain ID ${e.chainId}: ${e.verifyingContract} (expected ${t[o]})`,
);
}
}
function bh(e) {
if (!(e in yh))
throw new Error(
`Unknown Ymax operation type: ${e} (expected one of ${Object.keys(yh).join(", ")})`,
);
}
var Hk = (e) => {
let t =
e.startsWith(dd) && e.substring(dd.length).match(/^V(\d+)(\w+)$/u);
if (!t) throw new Error(`Invalid witness field type name: ${e}`);
let [, r, o] = t,
n = { name: dd, version: r };
return (Vk(n), bh(o), { domain: n, primaryType: o });
};
var Wk = (e) => {
let {
isHex: t,
hashStruct: r,
recoverTypedDataAddress: o,
validateTypedData: n,
encodeType: a,
getTypesForEIP712Domain: i,
} = e;
for (let b of [t, r, o, n, a, i])
if (typeof b != "function")
throw new Error(`Expected viemUtils.${b} to be a function`);
let c = Nk({ encodeType: a }),
d = (b, m) => {
let { domain: v, ...h } = b;
if (m)
throw new Error(
"Contract address validation expected to be validated separately",
);
bh(h.primaryType);
let { nonce: g, deadline: S, ...w } = h.message,
I = w,
E = h.primaryType;
return (
n({ types: gh(E), message: I, primaryType: E }),
{ operation: E, domain: v, data: I }
);
},
l = (b) => {
let m = b,
v = mh(m.types),
h = m.message[v.name],
{ primaryType: g, domain: S } = Hk(v.type),
w = BigInt(b.domain.chainId),
I = g;
n({ types: gh(I), message: h, primaryType: I });
let E = m.message.spender;
return {
operation: I,
domain: { ...S, chainId: w, verifyingContract: E },
data: h,
};
},
u = (b, m = b.address, v = b.signature) => {
let h = b;
if (!t(v)) throw new Error(`Invalid signature format: ${v}`);
if (!m) throw new Error("Missing owner address");
let g = mh(h.types);
Bk(h.types);
let { [g.name]: S, ...w } = h.message,
I = r({ primaryType: g.type, types: h.types, data: S }),
E = c(h.types),
{ spender: K, ...J } = w,
P = {
permit: J,
owner: m,
witness: I,
witnessTypeString: E,
signature: v,
};
return {
chainId: BigInt(b.domain.chainId),
token: w.permitted.token,
amount: w.permitted.amount,
permit2Payload: P,
spender: K,
};
},
p = (b, m = {}) => {
let { address: v, domain: h, ...g } = b,
{ nonce: S, deadline: w } = g.message;
if (!h) throw new Error("Missing domain in typed data");
if (
(n({
...g,
domain: h,
types: { ...g.types, EIP712Domain: i({ domain: h }) },
}),
ph(b.primaryType))
) {
let { signature: I, ...E } = g;
Mk(h, m.permit2);
let K = { ...E, domain: h },
J = u(K, v, I),
P = l(K);
return (
m.ymaxRepresentative && hh(P.domain, m.ymaxRepresentative),
{
...P,
permitDetails: J,
evmWalletAddress: v,
nonce: S,
deadline: w,
}
);
} else {
let I = g;
return (
hh(h, m.ymaxRepresentative),
{
...d({ ...I, domain: h }),
evmWalletAddress: v,
nonce: S,
deadline: w,
}
);
}
};
return {
extractOperationDetailsFromStandaloneData: d,
extractOperationDetailsFromPermit2WitnessData: l,
extractPermitDetails: u,
extractOperationDetailsFromDataWithAddress: p,
extractOperationDetailsFromSignedData: async (b, m) => {
let v = await o(b);
if (b.address && !qe(v, b.address))
throw new Error(
`Recovered address does not match provided address ${b.address}`,
);
return p({ ...b, address: v }, { ymaxRepresentative: m });
},
};
};
var Lk = Ae("PEWH"),
J$ = 60n * 60n * 24n,
V$ = (e) => {
let { decodePassable: t, encodePassable: r } = Oa({
format: "compactOrdered",
}),
o = (p) => r(harden([p.deadline, p.walletOwner, p.nonce])),
n = (p) => {
let [y, b, m] = t(p);
return { deadline: y, walletOwner: b, nonce: m };
},
a = (p) => r(harden([p.walletOwner, p.nonce, p.deadline])),
i = (p) => r(harden([p.walletOwner, p.nonce])),
c = e.setStore("noncesByDeadline", { keyShape: s.string() }),
d = e.setStore("noncesByOwner", { keyShape: s.string() }),
l = (p) => {
let y = i(p);
for (let b of d.keys(s.gte(y))) {
if (!b.startsWith(y)) break;
f`Nonce ${x(p.nonce)} for wallet ${x(p.walletOwner)} already used and not yet expired`;
}
(c.add(o(p)), d.add(a(p)));
},
u = (p) => {
for (let y of c.keys()) {
let b = n(y);
if (p <= b.deadline) break;
(c.delete(o(b)), d.delete(a(b)));
}
};
return harden({ insertNonce: l, removeExpiredNonces: u });
},
H$ = (e) => {
try {
let t = ce(e);
switch (t) {
case "bigint":
case "boolean":
case "null":
case "number":
case "string":
case "undefined":
case "symbol":
case "byteArray":
return e;
case "copyArray":
case "copyRecord":
case "tagged":
return e;
case "error":
case "remotable":
case "promise":
return;
default:
return t ? e : void 0;
}
} catch {
return;
}
},
W$ = (
e,
{
vowTools: { asVow: t, watch: r, when: o },
portfolioContractPublicFacet: n,
publishStatus: a,
},
) => {
let i = e.exoClassKit("OperationOutcomeHandlers", void 0, (d) => d, {
OpenOutcomeWatcher: {
async onFulfilled({ evmHandler: d }) {
await null;
try {
let l = await O(d).getReaderFacet(),
u = await O(l).getPortfolioId(),
{
wallet: { portfolios: p },
storageNode: y,
} = this.state;
p.init(BigInt(u), d);
let b = await Promise.all(
[...p.values()].map(async (m) => {
let v = O(m).getReaderFacet();
return await o(O(v).getStoragePath());
}),
);
return (
a(O(y).makeChildNode("portfolio"), b),
this.facets.BasicOutcomeWatcher.onFulfilled(`portfolio${u}`)
);
} catch (l) {
return this.facets.BasicOutcomeWatcher.onRejected(l);
}
},
onRejected(d) {
return this.facets.BasicOutcomeWatcher.onRejected(d);
},
},
BasicOutcomeWatcher: {
onFulfilled(d) {
let { storageNode: l, nonce: u, deadline: p } = this.state;
a(l, {
updated: "messageUpdate",
nonce: u,
deadline: p,
status: "ok",
result: H$(d),
});
},
onRejected(d) {
let { storageNode: l, nonce: u, deadline: p } = this.state;
a(l, {
updated: "messageUpdate",
nonce: u,
deadline: p,
status: "error",
error: String(d),
});
},
},
}),
c = ({
wallet: d,
storageNode: l,
address: u,
operationDetails: p,
nonce: y,
deadline: b,
}) =>
t(async () => {
a(l, {
updated: "messageUpdate",
nonce: y,
deadline: b,
status: "pending",
});
let { BasicOutcomeWatcher: m, OpenOutcomeWatcher: v } = i({
wallet: d,
storageNode: l,
nonce: y,
deadline: b,
});
await null;
try {
let h =
p.operation !== "OpenPortfolio" ? p.data.portfolio : void 0,
g = h !== void 0 ? d.portfolios.get(BigInt(h)) : void 0;
switch (
(await O(n).validateEVMMessageDomain(p.domain, g),
p.operation)
) {
case "OpenPortfolio": {
let { permitDetails: S, data: w } = p;
if (!S)
throw f`Missing permit details for OpenPortfolio operation`;
let I = O(n).openPortfolioFromEVM(w, S);
return r(I, v);
}
case "Rebalance": {
let { permitDetails: S } = p,
w = O(g).rebalance(void 0, S);
return r(w, m);
}
case "SetTargetAllocation": {
let {
data: { allocations: S },
permitDetails: w,
} = p,
I = O(g).rebalance(S, w);
return r(I, m);
}
case "Deposit": {
let { permitDetails: S } = p;
if (!S)
throw f`Missing permit details for Deposit operation`;
let w = O(g).deposit(S);
return r(w, m);
}
case "Withdraw": {
let {
data: { withdraw: S },
domain: w,
} = p,
I = O(g).withdraw({
withdrawDetails: S,
domain: w,
address: u,
});
return r(I, m);
}
case "Grant": {
let {
data: { accountHolder: S, permissions: w },
} = p,
I = O(g).grant(S, w);
return r(I, m);
}
case "SetAutoFeatures": {
let {
data: { features: S },
} = p,
w = O(g).setAutoFeatures(S);
return r(w, m);
}
default:
f`Unsupported operation: ${x(p.operation)}`;
}
} catch (h) {
return m.onRejected(h);
}
});
return harden({ handleOperation: c });
},
L$ = s.splitRecord(
{
domain: s.any(),
types: s.record(),
primaryType: s.string(),
message: s.record(),
signature: s.any(),
},
{ verifiedSigner: s.string() },
),
q$ = (
e,
{
vowTools: t,
storageNode: r,
timerService: o,
permit2Addresses: n,
handleOperation: a,
insertNonce: i,
removeExpiredNonces: c,
getWalletForAddress: d,
},
) => {
let { extractOperationDetailsFromDataWithAddress: l } = Wk({
isHex: to,
hashStruct: ad,
recoverTypedDataAddress: ip,
validateTypedData: sp,
encodeType: Ik,
getTypesForEIP712Domain: ap,
}),
u = s.interface("EVMWalletMessageHandler", {
handleMessage: s.call(L$).returns(le),
});
return e.exoClass(
"messageHandler",
u,
() => ({}),
{
handleMessage(p) {
return t.asVow(async () => {
Lk("handleMessage", p);
let { verifiedSigner: y, ...b } = p,
m = await (y ? Qu(y) : ip(b)),
v = { ...b, address: m },
h = l(v, { permit2: n });
Lk("extracted details", h);
let { nonce: g, deadline: S, ...w } = h,
{ absValue: I } = await O(o).getCurrentTimestamp();
if ((c(I), I > S))
throw f`Deadline has already passed: ${x(S)} vs ${x(I)}`;
(S < I + J$ ||
f`Deadline too far in the future: ${x(S)} vs ${x(I)}`,
i({ walletOwner: m, nonce: g, deadline: S }));
let E = d(m),
K = await O(r).makeChildNode(m);
return (
harden(w),
a({
wallet: E,
storageNode: K,
address: m,
operationDetails: w,
nonce: g,
deadline: S,
})
);
});
},
},
{ stateShape: {} },
);
},
qk = (
e,
{
storageNode: t,
vowTools: r,
timerService: o,
portfolioContractPublicFacet: n,
publishStatus: a,
permit2Addresses: i,
},
) => {
let c = e.mapStore("wallets"),
d = (b) =>
En(c, b, () =>
harden({ portfolios: e.detached().mapStore("portfolios") }),
),
{ insertNonce: l, removeExpiredNonces: u } = V$(e),
{ handleOperation: p } = W$(e, {
vowTools: r,
portfolioContractPublicFacet: n,
publishStatus: a,
}),
y = q$(e, {
vowTools: r,
storageNode: t,
timerService: o,
permit2Addresses: i,
handleOperation: p,
insertNonce: l,
removeExpiredNonces: u,
getWalletForAddress: d,
});
return harden({ makeEVMWalletMessageHandler: y });
};
var j$ = {
Aave_Arbitrum: "Aave_Arbitrum",
Aave_Avalanche: "Aave_Avalanche",
Aave_Base: "Aave_Base",
Aave_Ethereum: "Aave_Ethereum",
Aave_Optimism: "Aave_Optimism",
Beefy_compoundUsdc_Arbitrum: "Beefy_compoundUsdc_Arbitrum",
Beefy_compoundUsdc_Optimism: "Beefy_compoundUsdc_Optimism",
Beefy_morphoGauntletUsdc_Ethereum: "Beefy_morphoGauntletUsdc_Ethereum",
Beefy_morphoSeamlessUsdc_Base: "Beefy_morphoSeamlessUsdc_Base",
Beefy_morphoSmokehouseUsdc_Ethereum:
"Beefy_morphoSmokehouseUsdc_Ethereum",
Beefy_re7_Avalanche: "Beefy_re7_Avalanche",
Compound_Arbitrum: "Compound_Arbitrum",
Compound_Base: "Compound_Base",
Compound_Ethereum: "Compound_Ethereum",
Compound_Optimism: "Compound_Optimism",
ERC4626_vaultU2_Ethereum: "ERC4626_vaultU2_Ethereum",
ERC4626_morphoClearstarHighYieldUsdc_Ethereum:
"ERC4626_morphoClearstarHighYieldUsdc_Ethereum",
ERC4626_morphoClearstarUsdcCore_Ethereum:
"ERC4626_morphoClearstarUsdcCore_Ethereum",
ERC4626_morphoGauntletUsdcRwa_Ethereum:
"ERC4626_morphoGauntletUsdcRwa_Ethereum",
ERC4626_morphoSteakhouseHighYieldInstant_Ethereum:
"ERC4626_morphoSteakhouseHighYieldInstant_Ethereum",
ERC4626_morphoClearstarInstitutionalUsdc_Ethereum:
"ERC4626_morphoClearstarInstitutionalUsdc_Ethereum",
ERC4626_morphoClearstarUsdcReactor_Ethereum:
"ERC4626_morphoClearstarUsdcReactor_Ethereum",
ERC4626_morphoAlphaUsdcCore_Ethereum:
"ERC4626_morphoAlphaUsdcCore_Ethereum",
ERC4626_morphoResolvUsdc_Ethereum: "ERC4626_morphoResolvUsdc_Ethereum",
ERC4626_morphoGauntletUsdcFrontier_Ethereum:
"ERC4626_morphoGauntletUsdcFrontier_Ethereum",
ERC4626_morphoHyperithmUsdcMidcurve_Ethereum:
"ERC4626_morphoHyperithmUsdcMidcurve_Ethereum",
ERC4626_morphoHyperithmUsdcDegen_Ethereum:
"ERC4626_morphoHyperithmUsdcDegen_Ethereum",
ERC4626_morphoGauntletUsdcCore_Ethereum:
"ERC4626_morphoGauntletUsdcCore_Ethereum",
ERC4626_morphoSteakhousePrimeUsdc_Base:
"ERC4626_morphoSteakhousePrimeUsdc_Base",
ERC4626_morphoSteakhouseUsdc_Base: "ERC4626_morphoSteakhouseUsdc_Base",
ERC4626_morphoGauntletUsdcPrime_Base:
"ERC4626_morphoGauntletUsdcPrime_Base",
ERC4626_morphoSeamlessUsdcVault_Base:
"ERC4626_morphoSeamlessUsdcVault_Base",
ERC4626_morphoSteakhouseHighYieldUsdc_Arbitrum:
"ERC4626_morphoSteakhouseHighYieldUsdc_Arbitrum",
ERC4626_morphoGauntletUsdcCore_Arbitrum:
"ERC4626_morphoGauntletUsdcCore_Arbitrum",
ERC4626_morphoHyperithmUsdc_Arbitrum:
"ERC4626_morphoHyperithmUsdc_Arbitrum",
ERC4626_morphoGauntletUsdcPrime_Optimism:
"ERC4626_morphoGauntletUsdcPrime_Optimism",
USDN: "USDN",
USDNVault: "USDNVault",
};
harden(j$);
var G$ = (e) => Object(e) !== e,
jk = (e) => {
if (G$(e)) return e;
let t = e;
Object.freeze(t);
for (let r of Reflect.ownKeys(t)) jk(t[r]);
return e;
},
Rle = jk({
debug: !0,
environment: "prod",
chains: [
{ name: "agoric", control: "local" },
{ name: "noble", control: "ibc" },
{ name: "Arbitrum", control: "axelar" },
{ name: "Avalanche", control: "axelar" },
{ name: "Base", control: "axelar" },
{ name: "Ethereum", control: "axelar" },
{ name: "Optimism", control: "axelar" },
],
pools: [
{ pool: "Aave_Arbitrum", chain: "Arbitrum", protocol: "Aave" },
{ pool: "Aave_Avalanche", chain: "Avalanche", protocol: "Aave" },
{ pool: "Aave_Base", chain: "Base", protocol: "Aave" },
{ pool: "Aave_Ethereum", chain: "Ethereum", protocol: "Aave" },
{ pool: "Aave_Optimism", chain: "Optimism", protocol: "Aave" },
{
pool: "Beefy_re7_Avalanche",
chain: "Avalanche",
protocol: "Beefy",
},
{
pool: "Beefy_morphoGauntletUsdc_Ethereum",
chain: "Ethereum",
protocol: "Beefy",
},
{
pool: "Beefy_morphoSmokehouseUsdc_Ethereum",
chain: "Ethereum",
protocol: "Beefy",
},
{
pool: "Beefy_morphoSeamlessUsdc_Base",
chain: "Base",
protocol: "Beefy",
},
{
pool: "Beefy_compoundUsdc_Optimism",
chain: "Optimism",
protocol: "Beefy",
},
{
pool: "Beefy_compoundUsdc_Arbitrum",
chain: "Arbitrum",
protocol: "Beefy",
},
{
pool: "ERC4626_morphoClearstarHighYieldUsdc_Ethereum",
chain: "Ethereum",
protocol: "ERC4626",
blockDepositReason: "AT_CAPACITY",
blockWithdrawReason: "LOW_LIQUIDITY",
},
{
pool: "ERC4626_morphoSeamlessUsdcVault_Base",
chain: "Base",
protocol: "ERC4626",
blockDepositReason: "AT_CAPACITY",
},
{
pool: "Compound_Arbitrum",
chain: "Arbitrum",
protocol: "Compound",
},
{ pool: "Compound_Base", chain: "Base", protocol: "Compound" },
{
pool: "Compound_Ethereum",
chain: "Ethereum",
protocol: "Compound",
},
{
pool: "Compound_Optimism",
chain: "Optimism",
protocol: "Compound",
},
{ pool: "USDN", chain: "noble", protocol: "USDN" },
{ pool: "USDNVault", chain: "noble", protocol: "USDN" },
],
localPlaces: [
{ id: "<Deposit>", chain: "agoric" },
{ id: "<Cash>", chain: "agoric" },
{ id: "+agoric", chain: "agoric" },
],
links: [
{
src: "@noble",
dest: "USDN",
transfer: "local",
variableFeeBps: 10,
timeSec: 0,
feeMode: "toUSDN",
},
{
src: "@noble",
dest: "USDNVault",
transfer: "local",
variableFeeBps: 10,
timeSec: 0,
feeMode: "toUSDN",
},
{
src: "@Arbitrum",
dest: "@agoric",
transfer: "cctpToNoble",
variableFeeBps: 0,
timeSec: 1080,
feeMode: "evmToNoble",
},
{
src: "@Avalanche",
dest: "@agoric",
transfer: "cctpToNoble",
variableFeeBps: 0,
timeSec: 30,
feeMode: "evmToNoble",
},
{
src: "@Ethereum",
dest: "@agoric",
transfer: "cctpToNoble",
variableFeeBps: 0,
timeSec: 1080,
feeMode: "evmToNoble",
},
{
src: "@Optimism",
dest: "@agoric",
transfer: "cctpToNoble",
variableFeeBps: 0,
timeSec: 1080,
feeMode: "evmToNoble",
},
{
src: "@Base",
dest: "@agoric",
transfer: "cctpToNoble",
variableFeeBps: 0,
timeSec: 1080,
feeMode: "evmToNoble",
},
{
src: "@noble",
dest: "@Arbitrum",
transfer: "cctpFromNoble",
variableFeeBps: 0,
timeSec: 20,
min: 1000000n,
feeMode: "makeEvmAccount",
},
{
src: "@noble",
dest: "@Avalanche",
transfer: "cctpFromNoble",
variableFeeBps: 0,
timeSec: 20,
min: 1000000n,
feeMode: "makeEvmAccount",
},
{
src: "@noble",
dest: "@Ethereum",
transfer: "cctpFromNoble",
variableFeeBps: 0,
timeSec: 20,
min: 1000000n,
feeMode: "makeEvmAccount",
},
{
src: "@noble",
dest: "@Optimism",
transfer: "cctpFromNoble",
variableFeeBps: 0,
timeSec: 20,
min: 1000000n,
feeMode: "makeEvmAccount",
},
{
src: "@noble",
dest: "@Base",
transfer: "cctpFromNoble",
variableFeeBps: 0,
timeSec: 20,
min: 1000000n,
feeMode: "makeEvmAccount",
},
{
src: "@agoric",
dest: "@noble",
transfer: "ibc",
variableFeeBps: 0,
timeSec: 10,
},
{
src: "@noble",
dest: "@agoric",
transfer: "ibc",
variableFeeBps: 0,
timeSec: 10,
},
{
src: "@Arbitrum",
dest: "@Ethereum",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Ethereum",
dest: "@Arbitrum",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Arbitrum",
dest: "@Base",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Base",
dest: "@Arbitrum",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Arbitrum",
dest: "@Avalanche",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 30,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Avalanche",
dest: "@Arbitrum",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Arbitrum",
dest: "@Optimism",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Optimism",
dest: "@Arbitrum",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Base",
dest: "@Ethereum",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Ethereum",
dest: "@Base",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Base",
dest: "@Avalanche",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 30,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Avalanche",
dest: "@Base",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Base",
dest: "@Optimism",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Optimism",
dest: "@Base",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Ethereum",
dest: "@Avalanche",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 30,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Avalanche",
dest: "@Ethereum",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Ethereum",
dest: "@Optimism",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Optimism",
dest: "@Ethereum",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Avalanche",
dest: "@Optimism",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 60,
min: 100000n,
feeMode: "evmToEvm",
},
{
src: "@Optimism",
dest: "@Avalanche",
transfer: "cctpV2",
variableFeeBps: 0,
timeSec: 30,
min: 100000n,
feeMode: "evmToEvm",
},
],
});
var Gk
Raw
beta3.js
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
gistfile1.txt
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment