@meteora-ag/cp-amm-sdk 1.0.0-rc.9 → 1.0.1-1.rc-0

package/node_modules/stream-chain/utils/Reduce.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const {Writable} = require('stream');
+
+const defaultInitial = 0;
+const defaultReducer = (acc, value) => value;
+
+class Reduce extends Writable {
+  constructor(options) {
+    super(Object.assign({}, options, {objectMode: true}));
+    this.accumulator = defaultInitial;
+    this._reducer = defaultReducer;
+    if (options) {
+      'initial' in options && (this.accumulator = options.initial);
+      'reducer' in options && (this._reducer = options.reducer);
+    }
+  }
+  _write(chunk, encoding, callback) {
+    const result = this._reducer.call(this, this.accumulator, chunk);
+    if (result && typeof result.then == 'function') {
+      result.then(
+        value => {
+          this.accumulator = value;
+          callback(null);
+        },
+        error => callback(error)
+      );
+    } else {
+      this.accumulator = result;
+      callback(null);
+    }
+  }
+  static make(reducer, initial) {
+    return new Reduce(typeof reducer == 'object' ? reducer : {reducer, initial});
+  }
+}
+Reduce.reduce = Reduce.make;
+Reduce.make.Constructor = Reduce;
+
+module.exports = Reduce;

package/node_modules/stream-chain/utils/asFun.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const {none, final, isFinal, getFinalValue, many, isMany, getManyValues} = require('../defs');
+
+const next = async (value, fns, index, push) => {
+  for (let i = index; i <= fns.length; ++i) {
+    if (value && typeof value.then == 'function') {
+      // thenable
+      value = await value;
+    }
+    if (value === none) break;
+    if (isFinal(value)) {
+      const val = getFinalValue(value);
+      val !== none && push(val);
+      break;
+    }
+    if (isMany(value)) {
+      const values = getManyValues(value);
+      if (i == fns.length) {
+        values.forEach(val => push(val));
+      } else {
+        for (let j = 0; j < values.length; ++j) {
+          await next(values[j], fns, i, push);
+        }
+      }
+      break;
+    }
+    if (value && typeof value.next == 'function') {
+      // generator
+      for (;;) {
+        let data = value.next();
+        if (data && typeof data.then == 'function') {
+          data = await data;
+        }
+        if (data.done) break;
+        if (i == fns.length) {
+          push(data.value);
+        } else {
+          await next(data.value, fns, i, push);
+        }
+      }
+      break;
+    }
+    if (i == fns.length) {
+      push(value);
+      break;
+    }
+    value = fns[i](value);
+  }
+};
+
+const nop = () => {};
+
+const asFun = (...fns) => {
+  fns = fns.filter(fn => fn);
+  if (!fns.length) return nop;
+  if (Symbol.asyncIterator && fns[0][Symbol.asyncIterator]) {
+    fns[0] = fns[0][Symbol.asyncIterator];
+  } else if (Symbol.iterator && fns[0][Symbol.iterator]) {
+    fns[0] = fns[0][Symbol.iterator];
+  }
+  return async value => {
+    const results = [];
+    await next(value, fns, 0, value => results.push(value));
+    switch (results.length) {
+      case 0:
+        return none;
+      case 1:
+        return results[0];
+    }
+    return many(results);
+  };
+};
+
+asFun.next = next;
+
+asFun.none = none;
+asFun.final = final;
+asFun.isFinal = isFinal;
+asFun.getFinalValue = getFinalValue;
+asFun.many = many;
+asFun.isMany = isMany;
+asFun.getManyValues = getManyValues;
+
+module.exports = asFun;

package/node_modules/stream-chain/utils/asGen.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const {none, final, isFinal, getFinalValue, many, isMany, getManyValues} = require('../defs');
+
+const next = async function*(value, fns, index) {
+  for (let i = index; i <= fns.length; ++i) {
+    if (value && typeof value.then == 'function') {
+      // thenable
+      value = await value;
+    }
+    if (value === none) break;
+    if (isFinal(value)) {
+      const val = getFinalValue(value);
+      if (val !== none) yield val;
+      break;
+    }
+    if (isMany(value)) {
+      const values = getManyValues(value);
+      if (i == fns.length) {
+        yield* values;
+      } else {
+        for (let j = 0; j < values.length; ++j) {
+          yield* next(values[j], fns, i);
+        }
+      }
+      break;
+    }
+    if (value && typeof value.next == 'function') {
+      // generator
+      for (;;) {
+        let data = value.next();
+        if (data && typeof data.then == 'function') {
+          data = await data;
+        }
+        if (data.done) break;
+        if (i == fns.length) {
+          yield data.value;
+        } else {
+          yield* next(data.value, fns, i);
+        }
+      }
+      break;
+    }
+    if (i == fns.length) {
+      yield value;
+      break;
+    }
+    value = fns[i](value);
+  }
+};
+
+const nop = async function*() {};
+
+const asGen = (...fns) => {
+  fns = fns.filter(fn => fn);
+  if (!fns.length) return nop;
+  if (Symbol.asyncIterator && fns[0][Symbol.asyncIterator]) {
+    fns[0] = fns[0][Symbol.asyncIterator];
+  } else if (Symbol.iterator && fns[0][Symbol.iterator]) {
+    fns[0] = fns[0][Symbol.iterator];
+  }
+  return async function*(value) {
+    yield* next(value, fns, 0);
+  };
+};
+
+asGen.next = next;
+
+asGen.none = none;
+asGen.final = final;
+asGen.isFinal = isFinal;
+asGen.getFinalValue = getFinalValue;
+asGen.many = many;
+asGen.isMany = isMany;
+asGen.getManyValues = getManyValues;
+
+module.exports = asGen;

package/node_modules/stream-chain/utils/comp.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const {Transform} = require('stream');
+const {next} = require('./asFun');
+const {sanitize} = require('../index');
+
+const comp = (...fns) => {
+  fns = fns.filter(fn => fn);
+  return fns.length
+    ? new Transform({
+        writableObjectMode: true,
+        readableObjectMode: true,
+        transform(chunk, encoding, callback) {
+          next(chunk, fns, 0, value => sanitize(value, this)).then(() => callback(null), error => callback(error));
+        }
+      })
+    : null;
+};
+
+module.exports = comp;

package/node_modules/stream-chain/utils/fold.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const {Transform} = require('stream');
+
+const defaultInitial = 0;
+const defaultReducer = (acc, value) => value;
+
+class Fold extends Transform {
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));
+    this._accumulator = defaultInitial;
+    this._reducer = defaultReducer;
+    if (options) {
+      'initial' in options && (this._accumulator = options.initial);
+      'reducer' in options && (this._reducer = options.reducer);
+    }
+  }
+  _transform(chunk, encoding, callback) {
+    const result = this._reducer.call(this, this._accumulator, chunk);
+    if (result && typeof result.then == 'function') {
+      result.then(
+        value => {
+          this._accumulator = value;
+          callback(null);
+        },
+        error => callback(error)
+      );
+    } else {
+      this._accumulator = result;
+      callback(null);
+    }
+  }
+  _final(callback) {
+    this.push(this._accumulator);
+    callback(null);
+  }
+  static make(reducer, initial) {
+    return new Fold(typeof reducer == 'object' ? reducer : {reducer, initial});
+  }
+}
+Fold.make.Constructor = Fold;
+
+module.exports = Fold.make;

package/node_modules/stream-chain/utils/gen.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const {Transform} = require('stream');
+const {next} = require('./asGen');
+const {sanitize} = require('../index');
+
+const gen = (...fns) => {
+  fns = fns.filter(fn => fn);
+  return fns.length
+    ? new Transform({
+        writableObjectMode: true,
+        readableObjectMode: true,
+        transform(chunk, encoding, callback) {
+          (async () => {
+            for await (let value of next(chunk, fns, 0)) {
+              sanitize(value, this);
+            }
+          })().then(() => callback(null), error => callback(error));
+        }
+      })
+    : null;
+};
+
+module.exports = gen;

package/node_modules/stream-chain/utils/scan.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const {Transform} = require('stream');
+
+const defaultInitial = 0;
+const defaultReducer = (acc, value) => value;
+
+class Scan extends Transform {
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));
+    this._accumulator = defaultInitial;
+    this._reducer = defaultReducer;
+    if (options) {
+      'initial' in options && (this._accumulator = options.initial);
+      'reducer' in options && (this._reducer = options.reducer);
+    }
+  }
+  _transform(chunk, encoding, callback) {
+    const result = this._reducer.call(this, this._accumulator, chunk);
+    if (result && typeof result.then == 'function') {
+      result.then(
+        value => {
+          this._accumulator = value;
+          this.push(this._accumulator);
+          callback(null);
+        },
+        error => callback(error)
+      );
+    } else {
+      this._accumulator = result;
+      this.push(this._accumulator);
+      callback(null);
+    }
+  }
+  static make(reducer, initial) {
+    return new Scan(typeof reducer == 'object' ? reducer : {reducer, initial});
+  }
+}
+Scan.make.Constructor = Scan;
+
+module.exports = Scan.make;

package/node_modules/stream-chain/utils/skip.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const {Transform} = require('stream');
+
+class Skip extends Transform {
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));
+    this._n = 0;
+    if (options) {
+      'n' in options && (this._n = options.n);
+    }
+    if (this._n <= 0) {
+      this._transform = this._passThrough;
+    }
+  }
+  _transform(chunk, encoding, callback) {
+    if (--this._n <= 0) {
+      this._transform = this._passThrough;
+    }
+    callback(null);
+  }
+  _passThrough(chunk, encoding, callback) {
+    this.push(chunk);
+    callback(null);
+  }
+  static make(n) {
+    return new Skip(typeof n == 'object' ? n : {n});
+  }
+}
+Skip.make.Constructor = Skip;
+
+module.exports = Skip.make;

package/node_modules/stream-chain/utils/skipWhile.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const {Transform} = require('stream');
+
+const alwaysFalse = () => false;
+
+class SkipWhile extends Transform {
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));
+    this._condition = alwaysFalse;
+    if (options) {
+      'condition' in options && (this._condition = options.condition);
+    }
+  }
+  _transform(chunk, encoding, callback) {
+    const result = this._condition.call(this, chunk);
+    if (result && typeof result.then == 'function') {
+      result.then(
+        flag => {
+          if (!flag) {
+            this._transform = this._passThrough;
+            this.push(chunk);
+          }
+          callback(null);
+        },
+        error => callback(error)
+      );
+    } else {
+      if (!result) {
+        this._transform = this._passThrough;
+        this.push(chunk);
+      }
+      callback(null);
+    }
+  }
+  _passThrough(chunk, encoding, callback) {
+    this.push(chunk);
+    callback(null);
+  }
+  static make(condition) {
+    return new SkipWhile(typeof condition == 'object' ? condition : {condition});
+  }
+}
+SkipWhile.make.Constructor = SkipWhile;
+
+module.exports = SkipWhile.make;

package/node_modules/stream-chain/utils/take.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const {Transform} = require('stream');
+
+class Take extends Transform {
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));
+    this._n = this._skip = 0;
+    if (options) {
+      'n' in options && (this._n = options.n);
+      'skip' in options && (this._skip = options.skip);
+    }
+    if (this._skip <= 0) {
+      this._transform = this._n > 0 ? this._countValues : this._doNothing;
+    }
+  }
+  _transform(chunk, encoding, callback) {
+    if (--this._skip <= 0) {
+      this._transform = this._n > 0 ? this._countValues : this._doNothing;
+    }
+    callback(null);
+  }
+  _countValues(chunk, encoding, callback) {
+    if (--this._n <= 0) {
+      this._transform = this._doNothing;
+    }
+    this.push(chunk);
+    callback(null);
+  }
+  _doNothing(chunk, encoding, callback) {
+    callback(null);
+  }
+  static make(n) {
+    return new Take(typeof n == 'object' ? n : {n});
+  }
+}
+Take.make.Constructor = Take;
+
+module.exports = Take.make;

package/node_modules/stream-chain/utils/takeWhile.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const {Transform} = require('stream');
+
+const alwaysTrue = () => true;
+
+class TakeWhile extends Transform {
+  constructor(options) {
+    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));
+    this._condition = alwaysTrue;
+    if (options) {
+      'condition' in options && (this._condition = options.condition);
+    }
+  }
+  _transform(chunk, encoding, callback) {
+    const result = this._condition.call(this, chunk);
+    if (result && typeof result.then == 'function') {
+      result.then(
+        flag => {
+          if (flag) {
+            this.push(chunk);
+          } else {
+            this._transform = this._doNothing;
+          }
+          callback(null);
+        },
+        error => callback(error)
+      );
+    } else {
+      if (result) {
+        this.push(chunk);
+      } else {
+        this._transform = this._doNothing;
+      }
+      callback(null);
+    }
+  }
+  _doNothing(chunk, encoding, callback) {
+    callback(null);
+  }
+  static make(condition) {
+    return new TakeWhile(typeof condition == 'object' ? condition : {condition});
+  }
+}
+TakeWhile.make.Constructor = TakeWhile;
+
+module.exports = TakeWhile.make;

package/node_modules/stream-json/Assembler.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const EventEmitter = require('events');
+
+const startObject = Ctr =>
+  function () {
+    if (this.done) {
+      this.done = false;
+    } else {
+      this.stack.push(this.current, this.key);
+    }
+    this.current = new Ctr();
+    this.key = null;
+  };
+
+class Assembler extends EventEmitter {
+  static connectTo(stream, options) {
+    return new Assembler(options).connectTo(stream);
+  }
+
+  constructor(options) {
+    super();
+    this.stack = [];
+    this.current = this.key = null;
+    this.done = true;
+    if (options) {
+      this.reviver = typeof options.reviver == 'function' && options.reviver;
+      if (this.reviver) {
+        this.stringValue = this._saveValue = this._saveValueWithReviver;
+      }
+      if (options.numberAsString) {
+        this.numberValue = this.stringValue;
+      }
+    }
+  }
+
+  connectTo(stream) {
+    stream.on('data', chunk => {
+      if (this[chunk.name]) {
+        this[chunk.name](chunk.value);
+        if (this.done) this.emit('done', this);
+      }
+    });
+    return this;
+  }
+
+  get depth() {
+    return (this.stack.length >> 1) + (this.done ? 0 : 1);
+  }
+
+  get path() {
+    const path = [];
+    for (let i = 0; i < this.stack.length; i += 2) {
+      const key = this.stack[i + 1];
+      path.push(key === null ? this.stack[i].length : key);
+    }
+    return path;
+  }
+
+  dropToLevel(level) {
+    if (level < this.depth) {
+      if (level) {
+        const index = (level - 1) << 1;
+        this.current = this.stack[index];
+        this.key = this.stack[index + 1];
+        this.stack.splice(index);
+      } else {
+        this.stack = [];
+        this.current = this.key = null;
+        this.done = true;
+      }
+    }
+    return this;
+  }
+
+  consume(chunk) {
+    this[chunk.name] && this[chunk.name](chunk.value);
+    return this;
+  }
+
+  keyValue(value) {
+    this.key = value;
+  }
+
+  //stringValue() - aliased below to _saveValue()
+
+  numberValue(value) {
+    this._saveValue(parseFloat(value));
+  }
+  nullValue() {
+    this._saveValue(null);
+  }
+  trueValue() {
+    this._saveValue(true);
+  }
+  falseValue() {
+    this._saveValue(false);
+  }
+
+  //startObject() - assigned below
+
+  endObject() {
+    if (this.stack.length) {
+      const value = this.current;
+      this.key = this.stack.pop();
+      this.current = this.stack.pop();
+      this._saveValue(value);
+    } else {
+      this.done = true;
+    }
+  }
+
+  //startArray() - assigned below
+  //endArray() - aliased below to endObject()
+
+  _saveValue(value) {
+    if (this.done) {
+      this.current = value;
+    } else {
+      if (this.current instanceof Array) {
+        this.current.push(value);
+      } else {
+        this.current[this.key] = value;
+        this.key = null;
+      }
+    }
+  }
+  _saveValueWithReviver(value) {
+    if (this.done) {
+      this.current = this.reviver('', value);
+    } else {
+      if (this.current instanceof Array) {
+        value = this.reviver('' + this.current.length, value);
+        this.current.push(value);
+        if (value === undefined) {
+          delete this.current[this.current.length - 1];
+        }
+      } else {
+        value = this.reviver(this.key, value);
+        if (value !== undefined) {
+          this.current[this.key] = value;
+        }
+        this.key = null;
+      }
+    }
+  }
+}
+
+Assembler.prototype.stringValue = Assembler.prototype._saveValue;
+Assembler.prototype.startObject = startObject(Object);
+Assembler.prototype.startArray = startObject(Array);
+Assembler.prototype.endArray = Assembler.prototype.endObject;
+
+module.exports = Assembler;