@aboutcircles/sdk-runner 0.1.2 → 0.1.3

package/dist/index.js

@@ -106620,7 +106620,7 @@ __export(exports_buffer, {
 function getLens(b64) {
   var len2 = b64.length;
   if (len2 % 4 > 0)
-    throw new Error("Invalid string. Length must be a multiple of 4");
+    throw Error("Invalid string. Length must be a multiple of 4");
   var validLen = b64.indexOf("=");
   if (validLen === -1)
     validLen = len2;
@@ -106704,12 +106704,12 @@ function write(buffer2, value, offset, isLE2, mLen, nBytes) {
 }
 function createBuffer(length2) {
   if (length2 > kMaxLength)
-    throw new RangeError('The value "' + length2 + '" is invalid for option "size"');
+    throw RangeError('The value "' + length2 + '" is invalid for option "size"');
   let buf = new Uint8Array(length2);
   return Object.setPrototypeOf(buf, Buffer2.prototype), buf;
 }
 function E(sym, getMessage, Base) {
-  return class NodeError extends Base {
+  return class extends Base {
     constructor() {
       super();
       Object.defineProperty(this, "message", { value: getMessage.apply(this, arguments), writable: true, configurable: true }), this.name = `${this.name} [${sym}]`, this.stack, delete this.name;
@@ -106728,7 +106728,7 @@ function E(sym, getMessage, Base) {
 function Buffer2(arg, encodingOrOffset, length2) {
   if (typeof arg === "number") {
     if (typeof encodingOrOffset === "string")
-      throw new TypeError('The "string" argument must be of type string. Received type number');
+      throw TypeError('The "string" argument must be of type string. Received type number');
     return allocUnsafe(arg);
   }
   return from15(arg, encodingOrOffset, length2);
@@ -106739,28 +106739,28 @@ function from15(value, encodingOrOffset, length2) {
   if (ArrayBuffer.isView(value))
     return fromArrayView(value);
   if (value == null)
-    throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+    throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
   if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer))
     return fromArrayBuffer(value, encodingOrOffset, length2);
-  if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer)))
+  if (typeof SharedArrayBuffer < "u" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer)))
     return fromArrayBuffer(value, encodingOrOffset, length2);
   if (typeof value === "number")
-    throw new TypeError('The "value" argument must not be of type number. Received type number');
+    throw TypeError('The "value" argument must not be of type number. Received type number');
   let valueOf = value.valueOf && value.valueOf();
   if (valueOf != null && valueOf !== value)
     return Buffer2.from(valueOf, encodingOrOffset, length2);
   let b = fromObject(value);
   if (b)
     return b;
-  if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function")
+  if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function")
     return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length2);
-  throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+  throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
 }
 function assertSize4(size5) {
   if (typeof size5 !== "number")
-    throw new TypeError('"size" argument must be of type number');
+    throw TypeError('"size" argument must be of type number');
   else if (size5 < 0)
-    throw new RangeError('The value "' + size5 + '" is invalid for option "size"');
+    throw RangeError('The value "' + size5 + '" is invalid for option "size"');
 }
 function alloc(size5, fill, encoding) {
   if (assertSize4(size5), size5 <= 0)
@@ -106776,7 +106776,7 @@ function fromString3(string, encoding) {
   if (typeof encoding !== "string" || encoding === "")
     encoding = "utf8";
   if (!Buffer2.isEncoding(encoding))
-    throw new TypeError("Unknown encoding: " + encoding);
+    throw TypeError("Unknown encoding: " + encoding);
   let length2 = byteLength(string, encoding) | 0, buf = createBuffer(length2), actual = buf.write(string, encoding);
   if (actual !== length2)
     buf = buf.slice(0, actual);
@@ -106797,9 +106797,9 @@ function fromArrayView(arrayView) {
 }
 function fromArrayBuffer(array, byteOffset, length2) {
   if (byteOffset < 0 || array.byteLength < byteOffset)
-    throw new RangeError('"offset" is outside of buffer bounds');
+    throw RangeError('"offset" is outside of buffer bounds');
   if (array.byteLength < byteOffset + (length2 || 0))
-    throw new RangeError('"length" is outside of buffer bounds');
+    throw RangeError('"length" is outside of buffer bounds');
   let buf;
   if (byteOffset === undefined && length2 === undefined)
     buf = new Uint8Array(array);
@@ -106826,7 +106826,7 @@ function fromObject(obj) {
 }
 function checked(length2) {
   if (length2 >= kMaxLength)
-    throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + kMaxLength.toString(16) + " bytes");
+    throw RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + kMaxLength.toString(16) + " bytes");
   return length2 | 0;
 }
 function byteLength(string, encoding) {
@@ -106835,7 +106835,7 @@ function byteLength(string, encoding) {
   if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer))
     return string.byteLength;
   if (typeof string !== "string")
-    throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
+    throw TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
   let len2 = string.length, mustMatch = arguments.length > 2 && arguments[2] === true;
   if (!mustMatch && len2 === 0)
     return 0;
@@ -106899,7 +106899,7 @@ function slowToString(encoding, start, end) {
         return utf16leSlice(this, start, end);
       default:
         if (loweredCase)
-          throw new TypeError("Unknown encoding: " + encoding);
+          throw TypeError("Unknown encoding: " + encoding);
         encoding = (encoding + "").toLowerCase(), loweredCase = true;
     }
 }
@@ -106944,7 +106944,7 @@ function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
         return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
     return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
   }
-  throw new TypeError("val must be string, number or Buffer");
+  throw TypeError("val must be string, number or Buffer");
 }
 function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
   let indexSize = 1, arrLength = arr.length, valLength = val.length;
@@ -107109,17 +107109,17 @@ function utf16leSlice(buf, start, end) {
 }
 function checkOffset(offset, ext, length2) {
   if (offset % 1 !== 0 || offset < 0)
-    throw new RangeError("offset is not uint");
+    throw RangeError("offset is not uint");
   if (offset + ext > length2)
-    throw new RangeError("Trying to access beyond buffer length");
+    throw RangeError("Trying to access beyond buffer length");
 }
 function checkInt(buf, value, offset, ext, max, min) {
   if (!Buffer2.isBuffer(buf))
-    throw new TypeError('"buffer" argument must be a Buffer instance');
+    throw TypeError('"buffer" argument must be a Buffer instance');
   if (value > max || value < min)
-    throw new RangeError('"value" argument is out of bounds');
+    throw RangeError('"value" argument is out of bounds');
   if (offset + ext > buf.length)
-    throw new RangeError("Index out of range");
+    throw RangeError("Index out of range");
 }
 function wrtBigUInt64LE(buf, value, offset, min, max) {
   checkIntBI(value, min, max, buf, offset, 7);
@@ -107137,9 +107137,9 @@ function wrtBigUInt64BE(buf, value, offset, min, max) {
 }
 function checkIEEE754(buf, value, offset, ext, max, min) {
   if (offset + ext > buf.length)
-    throw new RangeError("Index out of range");
+    throw RangeError("Index out of range");
   if (offset < 0)
-    throw new RangeError("Index out of range");
+    throw RangeError("Index out of range");
 }
 function writeFloat(buf, value, offset, littleEndian, noAssert) {
   if (value = +value, offset = offset >>> 0, !noAssert)
@@ -107239,7 +107239,7 @@ function utf8ToBytes3(string, units) {
         break;
       bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
     } else
-      throw new Error("Invalid code point");
+      throw Error("Invalid code point");
   }
   return bytes;
 }
@@ -107274,14 +107274,14 @@ function isInstance(obj, type) {
   return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
 }
 function defineBigIntMethod(fn) {
-  return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+  return typeof BigInt > "u" ? BufferBigIntNotDefined : fn;
 }
 function BufferBigIntNotDefined() {
-  throw new Error("BigInt not supported");
+  throw Error("BigInt not supported");
 }
 function notimpl(name) {
   return () => {
-    throw new Error(name + " is not implemented for node:buffer browser polyfill");
+    throw Error(name + " is not implemented for node:buffer browser polyfill");
   };
 }
 var lookup, revLookup, code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i, len, customInspectSymbol, INSPECT_MAX_BYTES = 50, kMaxLength = 2147483647, kStringMaxLength = 536870888, btoa2, atob2, File, Blob, constants, ERR_BUFFER_OUT_OF_BOUNDS, ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE, MAX_ARGUMENTS_LENGTH = 4096, INVALID_BASE64_RE, hexSliceLookupTable, resolveObjectURL, isUtf8, isAscii = (str) => {
@@ -107347,16 +107347,16 @@ var init_buffer = __esm(() => {
   Buffer2.allocUnsafeSlow = function(size5) {
     return allocUnsafe(size5);
   };
-  Buffer2.isBuffer = function isBuffer(b) {
+  Buffer2.isBuffer = function(b) {
     return b != null && b._isBuffer === true && b !== Buffer2.prototype;
   };
-  Buffer2.compare = function compare(a, b) {
+  Buffer2.compare = function(a, b) {
     if (isInstance(a, Uint8Array))
       a = Buffer2.from(a, a.offset, a.byteLength);
     if (isInstance(b, Uint8Array))
       b = Buffer2.from(b, b.offset, b.byteLength);
     if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b))
-      throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+      throw TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
     if (a === b)
       return 0;
     let x = a.length, y = b.length;
@@ -107371,7 +107371,7 @@ var init_buffer = __esm(() => {
       return 1;
     return 0;
   };
-  Buffer2.isEncoding = function isEncoding(encoding) {
+  Buffer2.isEncoding = function(encoding) {
     switch (String(encoding).toLowerCase()) {
       case "hex":
       case "utf8":
@@ -107389,9 +107389,9 @@ var init_buffer = __esm(() => {
         return false;
     }
   };
-  Buffer2.concat = function concat3(list, length2) {
+  Buffer2.concat = function(list, length2) {
     if (!Array.isArray(list))
-      throw new TypeError('"list" argument must be an Array of Buffers');
+      throw TypeError('"list" argument must be an Array of Buffers');
     if (list.length === 0)
       return Buffer2.alloc(0);
     let i2;
@@ -107411,7 +107411,7 @@ var init_buffer = __esm(() => {
         } else
           Uint8Array.prototype.set.call(buffer2, buf, pos);
       else if (!Buffer2.isBuffer(buf))
-        throw new TypeError('"list" argument must be an Array of Buffers');
+        throw TypeError('"list" argument must be an Array of Buffers');
       else
         buf.copy(buffer2, pos);
       pos += buf.length;
@@ -107420,31 +107420,31 @@ var init_buffer = __esm(() => {
   };
   Buffer2.byteLength = byteLength;
   Buffer2.prototype._isBuffer = true;
-  Buffer2.prototype.swap16 = function swap16() {
+  Buffer2.prototype.swap16 = function() {
     let len2 = this.length;
     if (len2 % 2 !== 0)
-      throw new RangeError("Buffer size must be a multiple of 16-bits");
+      throw RangeError("Buffer size must be a multiple of 16-bits");
     for (let i2 = 0;i2 < len2; i2 += 2)
       swap(this, i2, i2 + 1);
     return this;
   };
-  Buffer2.prototype.swap32 = function swap32() {
+  Buffer2.prototype.swap32 = function() {
     let len2 = this.length;
     if (len2 % 4 !== 0)
-      throw new RangeError("Buffer size must be a multiple of 32-bits");
+      throw RangeError("Buffer size must be a multiple of 32-bits");
     for (let i2 = 0;i2 < len2; i2 += 4)
       swap(this, i2, i2 + 3), swap(this, i2 + 1, i2 + 2);
     return this;
   };
-  Buffer2.prototype.swap64 = function swap64() {
+  Buffer2.prototype.swap64 = function() {
     let len2 = this.length;
     if (len2 % 8 !== 0)
-      throw new RangeError("Buffer size must be a multiple of 64-bits");
+      throw RangeError("Buffer size must be a multiple of 64-bits");
     for (let i2 = 0;i2 < len2; i2 += 8)
       swap(this, i2, i2 + 7), swap(this, i2 + 1, i2 + 6), swap(this, i2 + 2, i2 + 5), swap(this, i2 + 3, i2 + 4);
     return this;
   };
-  Buffer2.prototype.toString = function toString2() {
+  Buffer2.prototype.toString = function() {
     let length2 = this.length;
     if (length2 === 0)
       return "";
@@ -107453,14 +107453,14 @@ var init_buffer = __esm(() => {
     return slowToString.apply(this, arguments);
   };
   Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
-  Buffer2.prototype.equals = function equals3(b) {
+  Buffer2.prototype.equals = function(b) {
     if (!Buffer2.isBuffer(b))
-      throw new TypeError("Argument must be a Buffer");
+      throw TypeError("Argument must be a Buffer");
     if (this === b)
       return true;
     return Buffer2.compare(this, b) === 0;
   };
-  Buffer2.prototype.inspect = function inspect() {
+  Buffer2.prototype.inspect = function() {
     let str = "", max = INSPECT_MAX_BYTES;
     if (str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(), this.length > max)
       str += " ... ";
@@ -107468,11 +107468,11 @@ var init_buffer = __esm(() => {
   };
   if (customInspectSymbol)
     Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
-  Buffer2.prototype.compare = function compare2(target, start, end, thisStart, thisEnd) {
+  Buffer2.prototype.compare = function(target, start, end, thisStart, thisEnd) {
     if (isInstance(target, Uint8Array))
       target = Buffer2.from(target, target.offset, target.byteLength);
     if (!Buffer2.isBuffer(target))
-      throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
+      throw TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
     if (start === undefined)
       start = 0;
     if (end === undefined)
@@ -107482,7 +107482,7 @@ var init_buffer = __esm(() => {
     if (thisEnd === undefined)
       thisEnd = this.length;
     if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length)
-      throw new RangeError("out of range index");
+      throw RangeError("out of range index");
     if (thisStart >= thisEnd && start >= end)
       return 0;
     if (thisStart >= thisEnd)
@@ -107503,16 +107503,16 @@ var init_buffer = __esm(() => {
       return 1;
     return 0;
   };
-  Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
+  Buffer2.prototype.includes = function(val, byteOffset, encoding) {
     return this.indexOf(val, byteOffset, encoding) !== -1;
   };
-  Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+  Buffer2.prototype.indexOf = function(val, byteOffset, encoding) {
     return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
   };
-  Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+  Buffer2.prototype.lastIndexOf = function(val, byteOffset, encoding) {
     return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
   };
-  Buffer2.prototype.write = function write2(string, offset, length2, encoding) {
+  Buffer2.prototype.write = function(string, offset, length2, encoding) {
     if (offset === undefined)
       encoding = "utf8", length2 = this.length, offset = 0;
     else if (length2 === undefined && typeof offset === "string")
@@ -107524,12 +107524,12 @@ var init_buffer = __esm(() => {
       } else
         encoding = length2, length2 = undefined;
     else
-      throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+      throw Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
     let remaining = this.length - offset;
     if (length2 === undefined || length2 > remaining)
       length2 = remaining;
     if (string.length > 0 && (length2 < 0 || offset < 0) || offset > this.length)
-      throw new RangeError("Attempt to write outside buffer bounds");
+      throw RangeError("Attempt to write outside buffer bounds");
     if (!encoding)
       encoding = "utf8";
     let loweredCase = false;
@@ -107553,14 +107553,14 @@ var init_buffer = __esm(() => {
           return ucs2Write(this, string, offset, length2);
         default:
           if (loweredCase)
-            throw new TypeError("Unknown encoding: " + encoding);
+            throw TypeError("Unknown encoding: " + encoding);
           encoding = ("" + encoding).toLowerCase(), loweredCase = true;
       }
   };
-  Buffer2.prototype.toJSON = function toJSON() {
+  Buffer2.prototype.toJSON = function() {
     return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
   };
-  Buffer2.prototype.slice = function slice4(start, end) {
+  Buffer2.prototype.slice = function(start, end) {
     let len2 = this.length;
     if (start = ~~start, end = end === undefined ? len2 : ~~end, start < 0) {
       if (start += len2, start < 0)
@@ -107577,7 +107577,7 @@ var init_buffer = __esm(() => {
     let newBuf = this.subarray(start, end);
     return Object.setPrototypeOf(newBuf, Buffer2.prototype), newBuf;
   };
-  Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+  Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function(offset, byteLength2, noAssert) {
     if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
       checkOffset(offset, byteLength2, this.length);
     let val = this[offset], mul = 1, i2 = 0;
@@ -107585,7 +107585,7 @@ var init_buffer = __esm(() => {
       val += this[offset + i2] * mul;
     return val;
   };
-  Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+  Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function(offset, byteLength2, noAssert) {
     if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
       checkOffset(offset, byteLength2, this.length);
     let val = this[offset + --byteLength2], mul = 1;
@@ -107593,32 +107593,32 @@ var init_buffer = __esm(() => {
       val += this[offset + --byteLength2] * mul;
     return val;
   };
-  Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+  Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 1, this.length);
     return this[offset];
   };
-  Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+  Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 2, this.length);
     return this[offset] | this[offset + 1] << 8;
   };
-  Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+  Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 2, this.length);
     return this[offset] << 8 | this[offset + 1];
   };
-  Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+  Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 4, this.length);
     return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
   };
-  Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+  Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 4, this.length);
     return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
   };
-  Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+  Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function(offset) {
     offset = offset >>> 0, validateNumber(offset, "offset");
     let first = this[offset], last = this[offset + 7];
     if (first === undefined || last === undefined)
@@ -107626,7 +107626,7 @@ var init_buffer = __esm(() => {
     let lo = first + this[++offset] * 256 + this[++offset] * 65536 + this[++offset] * 16777216, hi = this[++offset] + this[++offset] * 256 + this[++offset] * 65536 + last * 16777216;
     return BigInt(lo) + (BigInt(hi) << BigInt(32));
   });
-  Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+  Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function(offset) {
     offset = offset >>> 0, validateNumber(offset, "offset");
     let first = this[offset], last = this[offset + 7];
     if (first === undefined || last === undefined)
@@ -107634,7 +107634,7 @@ var init_buffer = __esm(() => {
     let hi = first * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + this[++offset], lo = this[++offset] * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + last;
     return (BigInt(hi) << BigInt(32)) + BigInt(lo);
   });
-  Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+  Buffer2.prototype.readIntLE = function(offset, byteLength2, noAssert) {
     if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
       checkOffset(offset, byteLength2, this.length);
     let val = this[offset], mul = 1, i2 = 0;
@@ -107644,7 +107644,7 @@ var init_buffer = __esm(() => {
       val -= Math.pow(2, 8 * byteLength2);
     return val;
   };
-  Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+  Buffer2.prototype.readIntBE = function(offset, byteLength2, noAssert) {
     if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
       checkOffset(offset, byteLength2, this.length);
     let i2 = byteLength2, mul = 1, val = this[offset + --i2];
@@ -107654,36 +107654,36 @@ var init_buffer = __esm(() => {
       val -= Math.pow(2, 8 * byteLength2);
     return val;
   };
-  Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
+  Buffer2.prototype.readInt8 = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 1, this.length);
     if (!(this[offset] & 128))
       return this[offset];
     return (255 - this[offset] + 1) * -1;
   };
-  Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+  Buffer2.prototype.readInt16LE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 2, this.length);
     let val = this[offset] | this[offset + 1] << 8;
     return val & 32768 ? val | 4294901760 : val;
   };
-  Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+  Buffer2.prototype.readInt16BE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 2, this.length);
     let val = this[offset + 1] | this[offset] << 8;
     return val & 32768 ? val | 4294901760 : val;
   };
-  Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+  Buffer2.prototype.readInt32LE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 4, this.length);
     return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
   };
-  Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+  Buffer2.prototype.readInt32BE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 4, this.length);
     return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
   };
-  Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+  Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function(offset) {
     offset = offset >>> 0, validateNumber(offset, "offset");
     let first = this[offset], last = this[offset + 7];
     if (first === undefined || last === undefined)
@@ -107691,7 +107691,7 @@ var init_buffer = __esm(() => {
     let val = this[offset + 4] + this[offset + 5] * 256 + this[offset + 6] * 65536 + (last << 24);
     return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 256 + this[++offset] * 65536 + this[++offset] * 16777216);
   });
-  Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+  Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function(offset) {
     offset = offset >>> 0, validateNumber(offset, "offset");
     let first = this[offset], last = this[offset + 7];
     if (first === undefined || last === undefined)
@@ -107699,27 +107699,27 @@ var init_buffer = __esm(() => {
     let val = (first << 24) + this[++offset] * 65536 + this[++offset] * 256 + this[++offset];
     return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + last);
   });
-  Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+  Buffer2.prototype.readFloatLE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 4, this.length);
     return read2(this, offset, true, 23, 4);
   };
-  Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+  Buffer2.prototype.readFloatBE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 4, this.length);
     return read2(this, offset, false, 23, 4);
   };
-  Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+  Buffer2.prototype.readDoubleLE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 8, this.length);
     return read2(this, offset, true, 52, 8);
   };
-  Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+  Buffer2.prototype.readDoubleBE = function(offset, noAssert) {
     if (offset = offset >>> 0, !noAssert)
       checkOffset(offset, 8, this.length);
     return read2(this, offset, false, 52, 8);
   };
-  Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+  Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function(value, offset, byteLength2, noAssert) {
     if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
       let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
       checkInt(this, value, offset, byteLength2, maxBytes, 0);
@@ -107730,7 +107730,7 @@ var init_buffer = __esm(() => {
       this[offset + i2] = value / mul & 255;
     return offset + byteLength2;
   };
-  Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+  Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function(value, offset, byteLength2, noAssert) {
     if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
       let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
       checkInt(this, value, offset, byteLength2, maxBytes, 0);
@@ -107741,38 +107741,38 @@ var init_buffer = __esm(() => {
       this[offset + i2] = value / mul & 255;
     return offset + byteLength2;
   };
-  Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+  Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 1, 255, 0);
     return this[offset] = value & 255, offset + 1;
   };
-  Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+  Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 2, 65535, 0);
     return this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
   };
-  Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+  Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 2, 65535, 0);
     return this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
   };
-  Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+  Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 4, 4294967295, 0);
     return this[offset + 3] = value >>> 24, this[offset + 2] = value >>> 16, this[offset + 1] = value >>> 8, this[offset] = value & 255, offset + 4;
   };
-  Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+  Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 4, 4294967295, 0);
     return this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = value & 255, offset + 4;
   };
-  Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+  Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function(value, offset = 0) {
     return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
   });
-  Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+  Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function(value, offset = 0) {
     return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
   });
-  Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+  Buffer2.prototype.writeIntLE = function(value, offset, byteLength2, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert) {
       let limit = Math.pow(2, 8 * byteLength2 - 1);
       checkInt(this, value, offset, byteLength2, limit - 1, -limit);
@@ -107786,7 +107786,7 @@ var init_buffer = __esm(() => {
     }
     return offset + byteLength2;
   };
-  Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+  Buffer2.prototype.writeIntBE = function(value, offset, byteLength2, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert) {
       let limit = Math.pow(2, 8 * byteLength2 - 1);
       checkInt(this, value, offset, byteLength2, limit - 1, -limit);
@@ -107800,56 +107800,56 @@ var init_buffer = __esm(() => {
     }
     return offset + byteLength2;
   };
-  Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+  Buffer2.prototype.writeInt8 = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 1, 127, -128);
     if (value < 0)
       value = 255 + value + 1;
     return this[offset] = value & 255, offset + 1;
   };
-  Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+  Buffer2.prototype.writeInt16LE = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 2, 32767, -32768);
     return this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
   };
-  Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+  Buffer2.prototype.writeInt16BE = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 2, 32767, -32768);
     return this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
   };
-  Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+  Buffer2.prototype.writeInt32LE = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 4, 2147483647, -2147483648);
     return this[offset] = value & 255, this[offset + 1] = value >>> 8, this[offset + 2] = value >>> 16, this[offset + 3] = value >>> 24, offset + 4;
   };
-  Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+  Buffer2.prototype.writeInt32BE = function(value, offset, noAssert) {
     if (value = +value, offset = offset >>> 0, !noAssert)
       checkInt(this, value, offset, 4, 2147483647, -2147483648);
     if (value < 0)
       value = 4294967295 + value + 1;
     return this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = value & 255, offset + 4;
   };
-  Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+  Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function(value, offset = 0) {
     return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
   });
-  Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+  Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function(value, offset = 0) {
     return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
   });
-  Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+  Buffer2.prototype.writeFloatLE = function(value, offset, noAssert) {
     return writeFloat(this, value, offset, true, noAssert);
   };
-  Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+  Buffer2.prototype.writeFloatBE = function(value, offset, noAssert) {
     return writeFloat(this, value, offset, false, noAssert);
   };
-  Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+  Buffer2.prototype.writeDoubleLE = function(value, offset, noAssert) {
     return writeDouble(this, value, offset, true, noAssert);
   };
-  Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+  Buffer2.prototype.writeDoubleBE = function(value, offset, noAssert) {
     return writeDouble(this, value, offset, false, noAssert);
   };
-  Buffer2.prototype.copy = function copy(target, targetStart, start, end) {
+  Buffer2.prototype.copy = function(target, targetStart, start, end) {
     if (!Buffer2.isBuffer(target))
-      throw new TypeError("argument should be a Buffer");
+      throw TypeError("argument should be a Buffer");
     if (!start)
       start = 0;
     if (!end && end !== 0)
@@ -107865,11 +107865,11 @@ var init_buffer = __esm(() => {
     if (target.length === 0 || this.length === 0)
       return 0;
     if (targetStart < 0)
-      throw new RangeError("targetStart out of bounds");
+      throw RangeError("targetStart out of bounds");
     if (start < 0 || start >= this.length)
-      throw new RangeError("Index out of range");
+      throw RangeError("Index out of range");
     if (end < 0)
-      throw new RangeError("sourceEnd out of bounds");
+      throw RangeError("sourceEnd out of bounds");
     if (end > this.length)
       end = this.length;
     if (target.length - targetStart < end - start)
@@ -107881,16 +107881,16 @@ var init_buffer = __esm(() => {
       Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
     return len2;
   };
-  Buffer2.prototype.fill = function fill(val, start, end, encoding) {
+  Buffer2.prototype.fill = function(val, start, end, encoding) {
     if (typeof val === "string") {
       if (typeof start === "string")
         encoding = start, start = 0, end = this.length;
       else if (typeof end === "string")
         encoding = end, end = this.length;
       if (encoding !== undefined && typeof encoding !== "string")
-        throw new TypeError("encoding must be a string");
+        throw TypeError("encoding must be a string");
       if (typeof encoding === "string" && !Buffer2.isEncoding(encoding))
-        throw new TypeError("Unknown encoding: " + encoding);
+        throw TypeError("Unknown encoding: " + encoding);
       if (val.length === 1) {
         let code2 = val.charCodeAt(0);
         if (encoding === "utf8" && code2 < 128 || encoding === "latin1")
@@ -107901,7 +107901,7 @@ var init_buffer = __esm(() => {
     else if (typeof val === "boolean")
       val = Number(val);
     if (start < 0 || this.length < start || this.length < end)
-      throw new RangeError("Out of range index");
+      throw RangeError("Out of range index");
     if (end <= start)
       return this;
     if (start = start >>> 0, end = end === undefined ? this.length : end >>> 0, !val)
@@ -107913,7 +107913,7 @@ var init_buffer = __esm(() => {
     else {
       let bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding), len2 = bytes.length;
       if (len2 === 0)
-        throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+        throw TypeError('The value "' + val + '" is invalid for argument "value"');
       for (i2 = 0;i2 < end - start; ++i2)
         this[i2 + start] = bytes[i2 % len2];
     }
@@ -107921,7 +107921,7 @@ var init_buffer = __esm(() => {
   };
   INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
   hexSliceLookupTable = function() {
-    let table = new Array(256);
+    let table = Array(256);
     for (let i2 = 0;i2 < 16; ++i2) {
       let i16 = i2 * 16;
       for (let j = 0;j < 16; ++j)
@@ -109281,7 +109281,7 @@ var require_utils14 = __commonJS((exports) => {
   }
   function fromBase64(input, useUrlTemplate = false, cutTailZeros = false) {
     const template = useUrlTemplate ? base64UrlTemplate : base64Template;
-    function indexOf2(toSearch) {
+    function indexOf(toSearch) {
       for (let i3 = 0;i3 < 64; i3++) {
         if (template.charAt(i3) === toSearch)
           return i3;
@@ -109294,10 +109294,10 @@ var require_utils14 = __commonJS((exports) => {
     let i2 = 0;
     let output = "";
     while (i2 < input.length) {
-      const enc1 = indexOf2(input.charAt(i2++));
-      const enc2 = i2 >= input.length ? 0 : indexOf2(input.charAt(i2++));
-      const enc3 = i2 >= input.length ? 0 : indexOf2(input.charAt(i2++));
-      const enc4 = i2 >= input.length ? 0 : indexOf2(input.charAt(i2++));
+      const enc1 = indexOf(input.charAt(i2++));
+      const enc2 = i2 >= input.length ? 0 : indexOf(input.charAt(i2++));
+      const enc3 = i2 >= input.length ? 0 : indexOf(input.charAt(i2++));
+      const enc4 = i2 >= input.length ? 0 : indexOf(input.charAt(i2++));
       const chr1 = test(enc1) << 2 | test(enc2) >> 4;
       const chr2 = (test(enc2) & 15) << 4 | test(enc3) >> 2;
       const chr3 = (test(enc3) & 3) << 6 | test(enc4);
@@ -109437,7 +109437,7 @@ var require_build2 = __commonJS((exports) => {
       throw new Error("BigInt is not defined. Your environment doesn't implement BigInt.");
     }
   }
-  function concat4(buffers) {
+  function concat3(buffers) {
     let outputLength = 0;
     let prevLength = 0;
     for (let i2 = 0;i2 < buffers.length; i2++) {
@@ -109484,7 +109484,7 @@ var require_build2 = __commonJS((exports) => {
       this.items.push(buf);
     }
     final() {
-      return concat4(this.items);
+      return concat3(this.items);
     }
   }
   var powers2 = [new Uint8Array([1])];
@@ -111168,7 +111168,7 @@ ${values.join(`
         }
         retBuffers.push(valueBuf);
       }
-      return concat4(retBuffers);
+      return concat3(retBuffers);
     }
     fromString(string) {
       this.value = [];
@@ -111400,7 +111400,7 @@ ${values.join(`
         }
         retBuffers.push(valueBuf);
       }
-      return concat4(retBuffers);
+      return concat3(retBuffers);
     }
     fromString(string) {
       this.value = [];
@@ -114426,9 +114426,9 @@ var require_lib = __commonJS((exports) => {
     decode(str) {
       let res = [];
       for (let i2 = 0;i2 < str.length; i2 += 11) {
-        const slice5 = str.slice(i2, i2 + 11);
-        const blockLen = XMR_BLOCK_LEN.indexOf(slice5.length);
-        const block = exports.base58.decode(slice5);
+        const slice4 = str.slice(i2, i2 + 11);
+        const blockLen = XMR_BLOCK_LEN.indexOf(slice4.length);
+        const block = exports.base58.decode(slice4);
         for (let j = 0;j < block.length - blockLen; j++) {
           if (block[j] !== 0)
             throw new Error("base58xmr: wrong padding");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aboutcircles/sdk-runner",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Contract runner implementations for Circles SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,6 +25,10 @@
     "ethereum",
     "viem"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aboutcircles/sdk"
+  },
   "license": "MIT",
   "dependencies": {
     "@aboutcircles/sdk-types": "workspace:*",