@alephium/web3 0.29.3 → 0.30.0-beta.1

package/src/codec/bytestring-codec.ts

@@ -0,0 +1,55 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Parser } from 'binary-parser'
+import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { Codec } from './codec'
+
+export interface ByteString {
+  length: DecodedCompactInt
+  value: Buffer
+}
+
+export class ByteStringCodec implements Codec<ByteString> {
+  parser = new Parser()
+    .nest('length', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .buffer('value', {
+      length: function (ctx) {
+        return compactUnsignedIntCodec.toU32(this['length']! as any as DecodedCompactInt)
+      }
+    })
+
+  encode(input: ByteString): Buffer {
+    return Buffer.from([...compactUnsignedIntCodec.encode(input.length), ...input.value])
+  }
+
+  decode(input: Buffer): ByteString {
+    return this.parser.parse(input)
+  }
+
+  encodeBuffer(input: Buffer): Buffer {
+    return Buffer.from([...compactUnsignedIntCodec.encodeU32(input.length), ...input])
+  }
+
+  decodeBuffer(input: Buffer): Buffer {
+    return this.decode(input).value
+  }
+}
+
+export const byteStringCodec = new ByteStringCodec()

package/src/codec/codec.ts

@@ -0,0 +1,30 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Parser } from 'binary-parser'
+
+export interface Codec<T> {
+  parser: Parser
+  encode(input: T): Buffer
+  decode(input: Buffer): T
+}
+
+export function assert(value: boolean, message: string) {
+  if (!value) {
+    throw new Error(message)
+  }
+}

package/src/codec/compact-int-codec.ts

@@ -0,0 +1,299 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Parser } from 'binary-parser'
+import { Codec, assert } from './codec'
+import { BigIntCodec } from './bigint-codec'
+import { ArrayCodec } from './array-codec'
+
+export class CompactInt {
+  static readonly oneBytePrefix = 0x00
+  static readonly oneByteNegPrefix = 0xc0
+  static readonly twoBytePrefix = 0x40
+  static readonly twoByteNegPrefix = 0x80
+  static readonly fourBytePrefix = 0x80
+  static readonly fourByteNegPrefix = 0x40
+  static readonly multiBytePrefix = 0xc0
+}
+
+const maskRest = 0xc0
+const maskMode = 0x3f
+const maskModeNeg = 0xffffffc0
+const signFlag = 0x20 // 0b00100000
+
+export interface DecodedCompactInt {
+  mode: number
+  rest: Uint8Array
+}
+
+const compactIntParser = new Parser().uint8('mode').buffer('rest', {
+  length: function (ctx) {
+    const rawMode = this['mode']
+    const mode = rawMode & maskRest
+
+    switch (mode) {
+      case CompactInt.oneBytePrefix:
+        return 0
+      case CompactInt.twoBytePrefix:
+        return 1
+      case CompactInt.fourBytePrefix:
+        return 3
+      default:
+        return (rawMode & maskMode) + 4
+    }
+  }
+})
+
+export class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
+  private oneByteBound = 0x40
+  private twoByteBound = this.oneByteBound << 8
+  private fourByteBound = this.oneByteBound << (8 * 3)
+
+  parser = compactIntParser
+
+  encode(input: DecodedCompactInt): Buffer {
+    return Buffer.from([input.mode, ...input.rest])
+  }
+
+  encodeU32(value: number): Buffer {
+    if (value < this.oneByteBound) {
+      return Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff])
+    } else if (value < this.twoByteBound) {
+      return Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff])
+    } else if (value < this.fourByteBound) {
+      return Buffer.from([
+        (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
+        (value >> 16) & 0xff,
+        (value >> 8) & 0xff,
+        value & 0xff
+      ])
+    } else {
+      return Buffer.from([
+        CompactInt.multiBytePrefix,
+        (value >> 24) & 0xff,
+        (value >> 16) & 0xff,
+        (value >> 8) & 0xff,
+        value & 0xff
+      ])
+    }
+  }
+
+  encodeU256(value: bigint): Buffer {
+    assert(value >= 0n, 'Value should be positive')
+
+    if (value < this.fourByteBound) {
+      return this.encodeU32(Number(value))
+    } else {
+      let bytes = BigIntCodec.encode(value)
+      if (bytes[0] === 0) {
+        bytes = bytes.slice(1)
+      }
+
+      assert(bytes.length <= 32, 'Expect <= 32 bytes for U256')
+
+      const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff
+      return Buffer.concat([Buffer.from([header]), bytes])
+    }
+  }
+
+  decodeU32(input: Buffer): number {
+    const decoded = this.decode(input)
+    return this.toU32(decoded)
+  }
+
+  decodeU256(input: Buffer): bigint {
+    const decoded = this.decode(input)
+    return this.toU256(decoded)
+  }
+
+  decode(input: Buffer): DecodedCompactInt {
+    return this.parser.parse(input)
+  }
+
+  toU32(value: DecodedCompactInt): number {
+    const body = Buffer.from([value.mode, ...value.rest])
+    return decodePositiveInt(value.mode, body)
+  }
+
+  toU256(value: DecodedCompactInt): bigint {
+    const mode = value.mode & maskRest
+    if (fixedSize(mode)) {
+      return BigInt(this.toU32(value))
+    } else {
+      assert(value.rest.length <= 32, 'Expect <= 32 bytes for U256')
+      return BigIntCodec.decode(Buffer.from(value.rest), false)
+    }
+  }
+}
+
+export const compactUnsignedIntCodec = new CompactUnsignedIntCodec()
+
+export class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
+  private signFlag = 0x20 // 0b00100000
+  private oneByteBound = 0x20 // 0b00100000
+  private twoByteBound = this.oneByteBound << 8
+  private fourByteBound = this.oneByteBound << (8 * 3)
+
+  parser = compactIntParser
+
+  encode(input: DecodedCompactInt): Buffer {
+    return Buffer.from([input.mode, ...input.rest])
+  }
+
+  decode(input: Buffer): DecodedCompactInt {
+    return this.parser.parse(input)
+  }
+
+  decodeI32(input: Buffer): number {
+    const decoded = this.decode(input)
+    return this.toI32(decoded)
+  }
+
+  encodeI32(value: number): Buffer {
+    if (value >= 0) {
+      if (value < this.oneByteBound) {
+        return Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff])
+      } else if (value < this.twoByteBound) {
+        return Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff])
+      } else if (value < this.fourByteBound) {
+        return Buffer.from([
+          (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        ])
+      } else {
+        return Buffer.from([
+          CompactInt.multiBytePrefix,
+          (value >> 24) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        ])
+      }
+    } else {
+      if (value >= -this.oneByteBound) {
+        return Buffer.from([(value ^ CompactInt.oneByteNegPrefix) & 0xff])
+      } else if (value >= -this.twoByteBound) {
+        return Buffer.from([((value >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, value & 0xff])
+      } else if (value >= -this.fourByteBound) {
+        return Buffer.from([
+          ((value >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        ])
+      } else {
+        return Buffer.from([
+          CompactInt.multiBytePrefix,
+          (value >> 24) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        ])
+      }
+    }
+  }
+
+  encodeI256(value: bigint): Buffer {
+    if (value >= -0x20000000 && value < 0x20000000) {
+      return this.encodeI32(Number(value))
+    } else {
+      const bytes = BigIntCodec.encode(value)
+      const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff
+      return Buffer.concat([Buffer.from([header]), bytes])
+    }
+  }
+
+  decodeI256(input: Buffer): bigint {
+    const decoded = this.decode(input)
+    return this.toI256(decoded)
+  }
+
+  toI32(value: DecodedCompactInt): number {
+    const body = Buffer.from([value.mode, ...value.rest])
+    const mode = value.mode & maskRest
+    if (fixedSize(mode)) {
+      const isPositive = (value.mode & signFlag) == 0
+      if (isPositive) {
+        return decodePositiveInt(value.mode, body)
+      } else {
+        return decodeNegativeInt(value.mode, body)
+      }
+    } else {
+      if (body.length === 5) {
+        return ((body[1] & 0xff) << 24) | ((body[2] & 0xff) << 16) | ((body[3] & 0xff) << 8) | (body[4] & 0xff)
+      } else {
+        throw new Error(`Expect 4 bytes int, but get ${body.length - 1} bytes int`)
+      }
+    }
+  }
+
+  toI256(value: DecodedCompactInt): bigint {
+    const mode = value.mode & maskRest
+
+    if (fixedSize(mode)) {
+      return BigInt(this.toI32(value))
+    } else {
+      assert(value.rest.length <= 32, 'Expect <= 32 bytes for I256')
+      return BigIntCodec.decode(Buffer.from(value.rest), true)
+    }
+  }
+}
+
+export const compactSignedIntCodec = new CompactSignedIntCodec()
+
+function decodePositiveInt(rawMode: number, body: Buffer): number {
+  const mode = rawMode & maskRest
+
+  switch (mode) {
+    case CompactInt.oneBytePrefix:
+      return rawMode
+    case CompactInt.twoBytePrefix:
+      assert(body.length === 2, 'Length should be 2')
+      return ((body[0] & maskMode) << 8) | (body[1] & 0xff)
+    case CompactInt.fourBytePrefix:
+      assert(body.length === 4, 'Length should be 4')
+      return ((body[0] & maskMode) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff)
+    default:
+      if (body.length === 5) {
+        return Number(BigInt('0x' + body.slice(1).toString('hex')))
+      } else {
+        throw new Error(`decodePositiveInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`)
+      }
+  }
+}
+
+function decodeNegativeInt(rawMode: number, body: Buffer) {
+  const mode = rawMode & maskRest
+  switch (mode) {
+    case CompactInt.oneBytePrefix:
+      return rawMode | maskModeNeg
+    case CompactInt.twoBytePrefix:
+      assert(body.length === 2, 'Length should be 2')
+      return ((body[0] | maskModeNeg) << 8) | (body[1] & 0xff)
+    case CompactInt.fourBytePrefix:
+      assert(body.length === 4, 'Length should be 4')
+      return ((body[0] | maskModeNeg) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff)
+    default:
+      throw new Error(`decodeNegativeInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`)
+  }
+}
+
+function fixedSize(mode: number): boolean {
+  return mode === CompactInt.oneBytePrefix || mode === CompactInt.twoBytePrefix || mode === CompactInt.fourBytePrefix
+}

package/src/codec/contract-codec.ts

@@ -0,0 +1,76 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { Parser } from 'binary-parser'
+import { ArrayCodec, DecodedArray } from './array-codec'
+import { Codec } from './codec'
+import { compactSignedIntCodec, compactUnsignedIntCodec, DecodedCompactInt } from './compact-int-codec'
+import { Method, MethodCodec, methodCodec } from './method-codec'
+
+const compactSignedIntsCodec = new ArrayCodec(compactSignedIntCodec)
+
+export interface HalfDecodedContract {
+  fieldLength: DecodedCompactInt
+  methodIndexes: DecodedArray<DecodedCompactInt>
+  methods: Buffer
+}
+
+export interface Contract {
+  fieldLength: number
+  methods: Method[]
+}
+
+export class ContractCodec implements Codec<HalfDecodedContract> {
+  parser = Parser.start()
+    .nest('fieldLength', {
+      type: compactSignedIntCodec.parser
+    })
+    .nest('methodIndexes', {
+      type: compactSignedIntsCodec.parser
+    })
+    .buffer('methods', { readUntil: 'eof' })
+
+  encode(input: HalfDecodedContract): Buffer {
+    return Buffer.from([
+      ...compactSignedIntCodec.encode(input.fieldLength),
+      ...compactSignedIntsCodec.encode(input.methodIndexes.value),
+      ...input.methods
+    ])
+  }
+
+  decode(input: Buffer): HalfDecodedContract {
+    return this.parser.parse(input)
+  }
+
+  decodeContract(input: Buffer): Contract {
+    const halfDecoded = this.decode(input)
+    const fieldLength = compactUnsignedIntCodec.toU32(halfDecoded.fieldLength)
+    const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compactUnsignedIntCodec.toU32(v))
+    const methods: Method[] = []
+    for (let i = 0, start = 0; i < methodIndexes.length; i++) {
+      const end = methodIndexes[i]
+      const method = MethodCodec.toMethod(methodCodec.decode(halfDecoded.methods.slice(start, end)))
+      methods.push(method)
+      start = end
+    }
+
+    return { fieldLength, methods }
+  }
+}
+
+export const contractCodec = new ContractCodec()

package/src/codec/contract-output-codec.ts

@@ -0,0 +1,97 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Parser } from 'binary-parser'
+import { DecodedArray } from './array-codec'
+import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { P2C } from './lockup-script-codec'
+import { Codec } from './codec'
+import { Token, tokensCodec } from './token-codec'
+import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
+import { blakeHash, createHint } from './hash'
+import { binToHex, bs58 } from '..'
+import { signedIntCodec } from './signed-int-codec'
+import { LockupScript } from './lockup-script-codec'
+import { lockupScriptCodec } from './lockup-script-codec'
+
+export interface ContractOutput {
+  amount: DecodedCompactInt
+  lockupScript: P2C
+  tokens: DecodedArray<Token>
+}
+
+export class ContractOutputCodec implements Codec<ContractOutput> {
+  parser = Parser.start()
+    .nest('amount', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .nest('lockupScript', {
+      type: Parser.start().buffer('contractId', { length: 32 })
+    })
+    .nest('tokens', {
+      type: tokensCodec.parser
+    })
+
+  encode(input: ContractOutput): Buffer {
+    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
+    const lockupScript = (input.lockupScript as P2C).contractId
+    const tokens = Buffer.from(tokensCodec.encode(input.tokens.value))
+
+    return Buffer.concat([amount, lockupScript, tokens])
+  }
+
+  decode(input: Buffer): ContractOutput {
+    return this.parser.parse(input)
+  }
+
+  static convertToApiContractOutput(txIdBytes: Uint8Array, output: ContractOutput, index: number): ApiContractOutput {
+    const hint = createHint(output.lockupScript.contractId)
+    const key = binToHex(blakeHash(Buffer.concat([txIdBytes, signedIntCodec.encode(index)])))
+    const attoAlphAmount = compactUnsignedIntCodec.toU256(output.amount).toString()
+    const address = bs58.encode(Buffer.concat([Buffer.from([0x03]), output.lockupScript.contractId]))
+    const tokens = output.tokens.value.map((token) => {
+      return {
+        id: token.tokenId.toString('hex'),
+        amount: compactUnsignedIntCodec.toU256(token.amount).toString()
+      }
+    })
+    return { hint, key, attoAlphAmount, address, tokens, type: 'ContractOutput' }
+  }
+
+  static convertToOutput(apiContractOutput: ApiContractOutput): ContractOutput {
+    const amount: DecodedCompactInt = compactUnsignedIntCodec.decode(
+      compactUnsignedIntCodec.encodeU256(BigInt(apiContractOutput.attoAlphAmount))
+    )
+    const lockupScript: P2C = lockupScriptCodec.decode(Buffer.from(bs58.decode(apiContractOutput.address)))
+      .script as P2C
+
+    const tokensValue = apiContractOutput.tokens.map((token) => {
+      return {
+        tokenId: Buffer.from(token.id, 'hex'),
+        amount: compactUnsignedIntCodec.decode(compactUnsignedIntCodec.encodeU256(BigInt(token.amount)))
+      }
+    })
+    const tokens: DecodedArray<Token> = {
+      length: compactUnsignedIntCodec.decode(compactUnsignedIntCodec.encodeU32(tokensValue.length)),
+      value: tokensValue
+    }
+
+    return { amount, lockupScript, tokens }
+  }
+}
+
+export const contractOutputCodec = new ContractOutputCodec()

package/src/codec/contract-output-ref-codec.ts

@@ -0,0 +1,41 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Parser } from 'binary-parser'
+import { ArrayCodec } from './array-codec'
+import { Codec } from './codec'
+import { signedIntCodec } from './signed-int-codec'
+
+export interface ContractOutputRef {
+  hint: number
+  key: Buffer
+}
+
+export class ContractOutputRefCodec implements Codec<ContractOutputRef> {
+  parser = Parser.start().int32('hint').buffer('key', { length: 32 })
+
+  encode(input: ContractOutputRef): Buffer {
+    return Buffer.concat([Buffer.from([...signedIntCodec.encode(input.hint), ...input.key])])
+  }
+
+  decode(input: Buffer): ContractOutputRef {
+    return this.parser.parse(input)
+  }
+}
+
+export const contractOutputRefCodec = new ContractOutputRefCodec()
+export const contractOutputRefsCodec = new ArrayCodec(contractOutputRefCodec)

package/src/codec/either-codec.ts

@@ -0,0 +1,73 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Parser } from 'binary-parser'
+import { Codec } from './codec'
+
+export interface Either<L, R> {
+  either: number
+  value: L | R
+}
+
+export class EitherCodec<L, R> implements Codec<Either<L, R>> {
+  constructor(
+    private leftCodec: Codec<L>,
+    private rightCodec: Codec<R>,
+    public parser = Parser.start()
+      .uint8('either')
+      .choice('value', {
+        tag: 'either',
+        choices: {
+          0: leftCodec.parser,
+          1: rightCodec.parser
+        }
+      })
+  ) {}
+
+  encode(input: Either<L, R>): Buffer {
+    const result = [input.either]
+    if (input.either === 0) {
+      result.push(...this.leftCodec.encode(input.value as L))
+    } else {
+      result.push(...this.rightCodec.encode(input.value as R))
+    }
+    return Buffer.from(result)
+  }
+
+  decode(input: Buffer): Either<L, R> {
+    const result = this.parser.parse(input)
+    return {
+      ...result,
+      value:
+        result.either === 0 ? this.leftCodec.decode(result.value.value) : this.rightCodec.decode(result.value.value)
+    }
+  }
+
+  fromLeft(left: L): Either<L, R> {
+    return {
+      either: 0,
+      value: left
+    }
+  }
+
+  fromRight(right: R): Either<L, R> {
+    return {
+      either: 1,
+      value: right
+    }
+  }
+}