liminal 0.4.1 → 1.0.0-beta.2

package/src/core/Call.ts

@@ -0,0 +1,38 @@
+import * as G from "../util/generator/collect.js"
+import { Type } from "./Type.js"
+
+export type Yield = Type
+export type Result = Type | void
+
+export type ValueCall<R, A extends unknown[]> = R | ((...args: A) => R)
+
+export type GenCall<
+  Y extends Yield = any,
+  R extends Result = any,
+  A extends unknown[] = any,
+> = Generator<Y, R> | ((...args: A) => Generator<Y, R>)
+
+export type Call<
+  Y extends Yield = any,
+  R extends Result = any,
+  A extends unknown[] = any,
+> = ValueCall<R, A> | GenCall<Y, R, A>
+
+export namespace Call {
+  export function collect<Y extends Yield, R extends Result>(
+    call: Call<Y, R>,
+  ): G.Collected<Y, R> {
+    if (typeof call === "function") {
+      const maybeGen = call()
+      if (typeof maybeGen === "object" && Symbol.iterator in maybeGen) {
+        return G.collect(maybeGen)
+      } else {
+        return [[], maybeGen]
+      }
+    } else if (typeof call === "object" && Symbol.iterator in call) {
+      return G.collect(call)
+    } else {
+      return [[], call]
+    }
+  }
+}

package/src/core/Effect.ts

@@ -0,0 +1,87 @@
+import { Flatten } from "../util/Flatten.js"
+import { unimplemented } from "../util/unimplemented.js"
+import { GenCall, Result, ValueCall, Yield } from "./Call.js"
+import { Factory, Type } from "./Type.js"
+import { ExtractUse, Use } from "./Use.js"
+
+export abstract class Effect<Y extends Yield, R extends Result> implements Generator<Y, R> {
+  declare yields?: Y[]
+  declare result?: R
+
+  map<R2 extends Result>(_f: (value: R) => R2): Effect<Y, R2> {
+    unimplemented()
+  }
+
+  next(): IteratorResult<Y, R> {
+    unimplemented()
+  }
+
+  return(): IteratorResult<Y, R> {
+    unimplemented()
+  }
+
+  throw(): IteratorResult<Y, R> {
+    unimplemented()
+  }
+
+  *[Symbol.iterator](): Generator<Y, R> {
+    while (this.yields?.length) {
+      yield this.yields.shift()!
+    }
+    delete this.yields
+    const result = this.result!
+    delete this.result
+    return result
+  }
+
+  "?"<M extends Factory<Exclude<R, void>>>(
+    match: M,
+  ): Effect<Y | InstanceType<M>, Exclude<R, InstanceType<M>>>
+  "?"<M extends Factory<Exclude<R, void>>, W extends Type>(
+    match: M,
+    with_: W,
+  ): Effect<Y | W, Exclude<R, InstanceType<M>>>
+  "?"(
+    _match: Factory<Exclude<R, void>>,
+    _maybeWith_?: Type,
+  ) {
+    return unimplemented()
+  }
+
+  handle<M extends Factory<Y>, R extends Result>(
+    match: M,
+    f: ValueCall<R, [value: InstanceType<M>]>,
+  ): [Exclude<Y, InstanceType<M>>] extends [never] ? R : Effect<Exclude<Y, InstanceType<M>>, R>
+  handle<M extends Factory<Y>, Y2 extends Yield, R extends Result>(
+    match: M,
+    f: GenCall<Y2, R, [value: InstanceType<M>]>,
+  ): [Exclude<Y, InstanceType<M>> | Y2] extends [never] ? R
+    : Effect<Exclude<Y, InstanceType<M>> | Y2, R>
+  handle(_match: any, _f: any): any {
+    unimplemented()
+  }
+
+  rehandle<M extends Factory[]>(
+    ..._match: M
+  ): [Exclude<Y, InstanceType<M[number]>>] extends [never] ? Extract<Y, InstanceType<M[number]>> | R
+    : Effect<Exclude<Y, InstanceType<M[number]>>, R>
+  {
+    unimplemented()
+  }
+}
+
+export function call<
+  Y extends Yield,
+  R extends Result,
+  D extends ExtractUse<Y>,
+  A extends Partial<D>,
+  N extends Omit<D, keyof A>,
+>(
+  _call: Generator<Y, R> | (() => Generator<Y, R>),
+  _uses: A,
+): Effect<
+  Exclude<Y, Use> | [keyof N] extends [never] ? never : Use<Flatten<N>>,
+  R
+> {
+  unimplemented()
+}

package/src/core/Hash.ts

@@ -0,0 +1,23 @@
+import { Factory, Type } from "./Type.js"
+
+export function Hash<T extends Type, A extends HashAlgorithm>(
+  targetType: Factory<T>,
+  algorithm: A,
+) {
+  return class extends Type.make("Hash")<HashSource, Uint8Array, never, never> {
+    targetType = targetType
+    algorithm = algorithm
+  }
+}
+
+export type HashAlgorithm =
+  | "Keccak256"
+  | "Keccak384"
+  | "Keccak512"
+  | "Poseidon"
+  | "SHA2_256"
+  | "SHA3_256"
+  | "SHA3_384"
+  | "SHA3_512"
+
+export type HashSource = never

package/src/core/Id.ts

@@ -0,0 +1,97 @@
+import { Store } from "../client/mod.js"
+import { Tagged } from "../util/Tagged.js"
+import { unimplemented } from "../util/unimplemented.js"
+import { Effect } from "./Effect.js"
+import { u64 } from "./Int.js"
+import { State } from "./State.js"
+import { Type } from "./Type.js"
+
+export type IdSource = IdSource.Sender | IdSource.Self | IdSource.Caller | IdSource.Null
+export namespace IdSource {
+  export class Hex extends Tagged("Hex") {}
+  export class Bytes extends Tagged("Bytes") {}
+  export class Sender extends Tagged("Sender") {}
+  export class Self extends Tagged("Self") {}
+  export class Caller extends Tagged("Caller") {}
+  export class Null extends Tagged("Null") {}
+}
+
+export class id extends Type.make("id")<IdSource, Uint8Array, Uint8Array> {
+  static fromHex(_hex: string): id {
+    unimplemented()
+  }
+
+  bind<N>(_namespace: N): Contract<N> {
+    unimplemented()
+  }
+
+  signer<K extends string>(_key: K): SignerEffect<K> {
+    unimplemented()
+  }
+}
+
+export class SignerEffect<K extends string> extends Effect<SignerRequirement<K>, signer<K>> {
+  constructor(readonly key: K) {
+    super()
+  }
+
+  deploy<N>(
+    _namespace: N,
+    _deployOptions: DeployOptions<N>,
+  ): Generator<SignerRequirement<K>, Contract<N>> {
+    unimplemented()
+  }
+}
+
+export class SignerRequirement<K extends string = any>
+  extends Type.make("SignerRequirement")<K, never>
+{
+  constructor(readonly key: K) {
+    super(key)
+  }
+}
+
+export interface signer<K extends keyof any = any>
+  extends InstanceType<ReturnType<typeof signer<K>>>
+{}
+
+export function signer<K extends keyof any>(key: K) {
+  return class extends id {
+    readonly key = key
+
+    deploy<N>(
+      _namespace: N,
+      _deployOptions: DeployOptions<N>,
+    ): Generator<never, Contract<N>> {
+      unimplemented()
+    }
+
+    send(_props: SendProps): Effect<never, never> {
+      unimplemented()
+    }
+  }
+}
+
+export const nullId = new id(new IdSource.Null())
+export const caller = new id(new IdSource.Caller())
+export const self = new id(new IdSource.Self())
+export const sender = new id(new IdSource.Sender())
+
+export interface DeployOptions<N> {
+  deployer?: signer
+  state: DeployState<N>
+}
+
+export type DeployState<N> = {
+  [K in keyof N as N[K] extends State ? K : never]: N[K] extends State<infer T> ? T : never
+}
+
+export interface SendProps {
+  to: id
+  amount: u64
+}
+
+// TODO
+export type Contract<T> = id & T & {
+  store(store: Store): Contract<T>
+}

package/src/core/Int.ts

@@ -0,0 +1,177 @@
+import { Tagged } from "../util/Tagged.js"
+import type { bool } from "./Bool.js"
+import type { MerkleList } from "./MerkleList.js"
+import type { MerkleMap } from "./MerkleMap.js"
+import { Factory, Type } from "./Type.js"
+
+// TODO: bit manipulation, floats, floor/ceil, power ...
+
+export type Int = SignedInt | UnsignedInt
+export type SignedInt = i8 | i16 | i32 | i64 | i256
+export type UnsignedInt = u8 | u16 | u32 | u64 | u256
+
+// TODO: allow from/into from opposite-signed types (effectively enabling an `absolute` method)
+export class u8 extends Int(false, 8)<never, u16 | u32 | u64 | u128 | u256> {}
+export class u16 extends Int(false, 16)<u8, u32 | u64 | u128 | u256> {}
+export class u32 extends Int(false, 32)<u8 | u16, u64 | u128 | u256> {}
+export class u64 extends Int(false, 64)<u8 | u16 | u32, u128 | u256> {}
+export class u128 extends Int(false, 128)<u8 | u16 | u32 | u64, u256> {}
+export class u256 extends Int(false, 256)<u8 | u16 | u32 | u64 | u128, never, U256Source> {}
+
+export class i8 extends Int(true, 8)<never, i16 | i32 | i64 | i128 | i256> {}
+export class i16 extends Int(true, 16)<i8, i32 | i64 | i128 | i256> {}
+export class i32 extends Int(true, 32)<i8 | i16, i64 | i128 | i256> {}
+export class i64 extends Int(true, 64)<i8 | i16 | i32, i128 | i256> {}
+export class i128 extends Int(true, 128)<i8 | i16 | i32 | i64, i256> {}
+export class i256 extends Int(true, 256)<i8 | i16 | i32 | i64 | i256, never> {}
+
+export type IntSize = 8 | 16 | 32 | 64 | 128 | 256
+
+function Int<Signed extends boolean, Size extends IntSize>(signed: Signed, size: Size) {
+  return class<From extends Type, Into extends Type, ExtraSource = never>
+    extends Type.make(`${signed ? "i" : "u"}${size}`)<
+      IntSource | ExtraSource,
+      number,
+      number | From,
+      Into
+    >
+  {
+    signed = signed
+
+    static min<This extends Factory>(this: This) {
+      return new this(new IntSource.Min())
+    }
+
+    static max<This extends Factory>(this: This) {
+      return new this(new IntSource.Max())
+    }
+
+    static random<This extends Factory>(this: This) {
+      return new this(new IntSource.Random())
+    }
+
+    add(value: this): this {
+      return new this.ctor(new IntSource.Add(this, value))
+    }
+
+    subtract(value: this): this {
+      return new this.ctor(new IntSource.Subtract(this, value))
+    }
+
+    multiply(value: this): this {
+      return new this.ctor(new IntSource.Multiply(this, value))
+    }
+
+    divide(value: this): this {
+      return new this.ctor(new IntSource.Divide(this, value))
+    }
+
+    square(this: this): this {
+      return new this.ctor(new IntSource.Square(this))
+    }
+
+    logarithm(value: this): this {
+      return new this.ctor(new IntSource.Logarithm(this, value))
+    }
+
+    gt(value: this): bool {
+      return new this.ctor(new IntSource.Gt(this, value)) as never
+    }
+
+    gte(value: this): bool {
+      return new this.ctor(new IntSource.Gte(this, value)) as never
+    }
+
+    lt(value: this): bool {
+      return new this.ctor(new IntSource.Lt(this, value)) as never
+    }
+
+    lte(value: this): bool {
+      return new this.ctor(new IntSource.Lte(this, value)) as never
+    }
+  }
+}
+
+export type IntSource =
+  | IntSource.Random
+  | IntSource.Min
+  | IntSource.Max
+  | IntSource.Add
+  | IntSource.Subtract
+  | IntSource.Multiply
+  | IntSource.Divide
+  | IntSource.Square
+  | IntSource.Logarithm
+  | IntSource.Gt
+  | IntSource.Gte
+  | IntSource.Lt
+  | IntSource.Lte
+export namespace IntSource {
+  export class Random extends Tagged("Random") {}
+  export class Min extends Tagged("Min") {}
+  export class Max extends Tagged("Max") {}
+  export class Add extends Tagged("Add") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+  export class Subtract extends Tagged("Subtract") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+  export class Multiply extends Tagged("Multiply") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+  export class Divide extends Tagged("Divide") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+  export class Square extends Tagged("Square") {
+    constructor(readonly self: Type) {
+      super()
+    }
+  }
+  export class Logarithm extends Tagged("Logarithm") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+  export class Gt extends Tagged("Gt") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+  export class Gte extends Tagged("Gte") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+  export class Lt extends Tagged("Lt") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+  export class Lte extends Tagged("Lte") {
+    constructor(readonly left: Type, readonly right: Type) {
+      super()
+    }
+  }
+}
+
+export type U256Source = U256Source.MerkleMapSize | U256Source.MerkleListSize
+export namespace U256Source {
+  export class MerkleMapSize extends Tagged("MerkleMapSize") {
+    constructor(readonly self: MerkleMap) {
+      super()
+    }
+  }
+  export class MerkleListSize extends Tagged("MerkleMapSize") {
+    constructor(readonly self: MerkleList) {
+      super()
+    }
+  }
+}

package/src/core/Key.ts

@@ -0,0 +1,9 @@
+import { Type } from "./Type.js"
+
+export interface Key<T extends keyof any> extends InstanceType<ReturnType<typeof Key<T>>> {}
+
+export function Key<T extends keyof any>(value: T) {
+  return class Key extends Type.make("Key")<never, T> {
+    value = value
+  }
+}

package/src/core/MerkleList.ts

@@ -0,0 +1,92 @@
+import { MerkleList as MerkleListNative } from "../lib/mod.js"
+import { Tagged } from "../util/Tagged.js"
+import { unimplemented } from "../util/unimplemented.js"
+import { Effect } from "./Effect.js"
+import { u256, U256Source } from "./Int.js"
+import { None } from "./None.js"
+import { Factory, Type } from "./Type.js"
+import { Union } from "./Union.js"
+
+export interface MerkleList<T extends Type = Type>
+  extends InstanceType<ReturnType<typeof MerkleList<T>>>
+{}
+
+export function MerkleList<T extends Type>(elementType: Factory<T>) {
+  return class extends Type.make("MerkleList")<
+    MerkleListSource,
+    MerkleListNative<Type.Native<T>>,
+    undefined,
+    never
+  > {
+    elementType = elementType
+
+    length: u256 = new u256(new U256Source.MerkleListSize(this))
+
+    first = this.at(u256.new(1))
+
+    last = this.at(this.length.subtract(u256.new(1)))
+
+    prepend(value: T): MerkleList<T> {
+      return new this.ctor(new MerkleListSource.Prepend(this, value))
+    }
+
+    append(value: T): MerkleList<T> {
+      return new this.ctor(new MerkleListSource.Append(this, value))
+    }
+
+    shift(): MerkleList<T> {
+      return new this.ctor(new MerkleListSource.Shift(this))
+    }
+
+    pop(): MerkleList<T> {
+      return new this.ctor(new MerkleListSource.Pop(this))
+    }
+
+    at(index: u256): T | None {
+      return new (Union(None, this.elementType))(
+        new MerkleListSource.At(this, index),
+      ) as never as T | None
+    }
+
+    reduceKeys<R extends Type, Y extends Type>(
+      _initial: R,
+      _f: (acc: R, cur: T) => Generator<Y, R>,
+    ): Effect<R, Y> {
+      unimplemented()
+    }
+  }
+}
+
+export type MerkleListSource =
+  | MerkleListSource.Prepend
+  | MerkleListSource.Append
+  | MerkleListSource.Shift
+  | MerkleListSource.Pop
+  | MerkleListSource.At
+export namespace MerkleListSource {
+  export class Prepend extends Tagged("Prepend") {
+    constructor(readonly self: MerkleList, readonly value: Type) {
+      super()
+    }
+  }
+  export class Append extends Tagged("Append") {
+    constructor(readonly self: MerkleList, readonly value: Type) {
+      super()
+    }
+  }
+  export class Shift extends Tagged("Shift") {
+    constructor(readonly self: MerkleList) {
+      super()
+    }
+  }
+  export class Pop extends Tagged("Pop") {
+    constructor(readonly self: MerkleList) {
+      super()
+    }
+  }
+  export class At extends Tagged("At") {
+    constructor(readonly list: MerkleList, readonly index: u256) {
+      super()
+    }
+  }
+}

package/src/core/MerkleMap.ts

@@ -0,0 +1,86 @@
+import { MerkleMap as MerkleMapNative } from "../lib/mod.js"
+import { Tagged } from "../util/Tagged.js"
+import { unimplemented } from "../util/unimplemented.js"
+import { Effect } from "./Effect.js"
+import { u256, U256Source } from "./Int.js"
+import { None } from "./None.js"
+import { Factory, Type } from "./Type.js"
+import { Union } from "./Union.js"
+
+export interface MerkleMap<K extends Type = Type, V extends Type = Type>
+  extends InstanceType<ReturnType<typeof MerkleMap<K, V>>>
+{}
+
+export function MerkleMap<K extends Type, V extends Type>(
+  keyType: Factory<K>,
+  valueType: Factory<V>,
+) {
+  return class extends Type.make("MerkleMap")<
+    MerkleMapSource,
+    MerkleMapNative<Type.Native<K>, Type.Native<V>>,
+    undefined
+  > {
+    keyType = keyType
+    valueType = valueType
+
+    size: u256 = new u256(new U256Source.MerkleMapSize(this))
+
+    set(key: K, value: V): MerkleMap<K, V> {
+      return new this.ctor(new MerkleMapSource.Set(this, key, value))
+    }
+
+    delete(key: K): MerkleMap<K, V> {
+      return new this.ctor(new MerkleMapSource.Delete(this, key))
+    }
+
+    get(key: K): V | None {
+      return new (Union(None, this.valueType))(
+        new MerkleMapSource.Get(this, key),
+      ) as never as V | None
+    }
+
+    reduceKeys<R extends Type, Y extends Type>(
+      _initial: R,
+      _f: (acc: R, cur: K) => Generator<Y, R>,
+    ): Effect<R, Y> {
+      unimplemented()
+    }
+
+    reduceValues<R extends Type, Y extends Type>(
+      _initial: R,
+      _f: (acc: R, cur: V) => Generator<Y, R>,
+    ): Effect<R, Y> {
+      unimplemented()
+    }
+
+    reduceEntries<R extends Type, Y extends Type>(
+      _initial: R,
+      _f: (acc: R, cur: [K, V]) => Generator<Y, R>,
+    ): Effect<R, Y> {
+      unimplemented()
+    }
+  }
+}
+
+export type MerkleMapSource = MerkleMapSource.Get | MerkleMapSource.Set | MerkleMapSource.Delete
+export namespace MerkleMapSource {
+  export class Get extends Tagged("Get") {
+    constructor(readonly map: MerkleMap, readonly key: Type) {
+      super()
+    }
+  }
+  export class Delete extends Tagged("Delete") {
+    constructor(readonly map: MerkleMap, readonly key: Type) {
+      super()
+    }
+  }
+  export class Set extends Tagged("Set") {
+    constructor(
+      readonly map: MerkleMap,
+      readonly key: Type,
+      readonly value: Type,
+    ) {
+      super()
+    }
+  }
+}

package/src/core/None.ts

@@ -0,0 +1,11 @@
+import { Tagged } from "../util/Tagged.js"
+import { Type } from "./Type.js"
+
+export class None extends Type.make("None")<NoneSource, undefined> {}
+
+export type NoneSource = NoneSource.Intrinsic
+export namespace NoneSource {
+  export class Intrinsic extends Tagged("Default") {}
+}
+
+export const none = new None(new NoneSource.Intrinsic())

package/src/core/State.ts

@@ -0,0 +1,31 @@
+import { Effect } from "./Effect.js"
+import { Factory, Type } from "./Type.js"
+
+export type State<T extends Type = any> = {
+  (): Effect<never, T>
+  (setter: StateSetter<T>): Effect<never, T>
+  tag: "State"
+  type: Factory<T>
+}
+
+export function State<T extends Type>(type: Factory<T>): State<T> {
+  const state = Object.assign((setter?: StateSetter<T>) => {
+    return new StateEffect<T>(state, setter)
+  }, {
+    tag: "State" as const,
+    type,
+  })
+  return state
+}
+
+export class StateEffect<T extends Type> extends Effect<never, T> {
+  declare setter?: StateSetter<T>
+  constructor(readonly state: State<T>, setter?: StateSetter<T>) {
+    super()
+    this.yields = [this as never]
+    this.result = new state.type(this)
+    if (setter) this.setter = setter
+  }
+}
+
+export type StateSetter<T> = T | ((value: T) => T)

package/src/core/String.ts

@@ -0,0 +1,5 @@
+import { Type } from "./Type.js"
+
+export class String extends Type.make("String")<StringSource, string, string> {}
+
+export type StringSource = never