@alephium/web3 1.4.0 → 1.5.0

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

@@ -15,79 +15,53 @@ 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, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
-import { P2C } from './lockup-script-codec'
-import { Codec } from './codec'
+import { u256Codec } from './compact-int-codec'
+import { P2C, p2cCodec } from './lockup-script-codec'
+import { ObjectCodec } from './codec'
 import { Token, tokensCodec } from './token-codec'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { blakeHash, createHint } from './hash'
 import { binToHex, bs58, concatBytes, hexToBinUnsafe } from '../utils'
-import { signedIntCodec } from './signed-int-codec'
+import { intAs4BytesCodec } from './int-as-4bytes-codec'
 import { lockupScriptCodec } from './lockup-script-codec'
 
 export interface ContractOutput {
-  amount: DecodedCompactInt
+  amount: bigint
   lockupScript: P2C
-  tokens: DecodedArray<Token>
+  tokens: 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): Uint8Array {
-    const amount = compactUnsignedIntCodec.encode(input.amount)
-    const lockupScript = input.lockupScript.contractId
-    const tokens = tokensCodec.encode(input.tokens.value)
-
-    return concatBytes([amount, lockupScript, tokens])
-  }
-
-  decode(input: Uint8Array): ContractOutput {
-    return this.parser.parse(input)
-  }
-
+export class ContractOutputCodec extends ObjectCodec<ContractOutput> {
   static convertToApiContractOutput(txIdBytes: Uint8Array, output: ContractOutput, index: number): ApiContractOutput {
-    const hint = createHint(output.lockupScript.contractId)
-    const key = binToHex(blakeHash(concatBytes([txIdBytes, signedIntCodec.encode(index)])))
-    const attoAlphAmount = compactUnsignedIntCodec.toU256(output.amount).toString()
-    const address = bs58.encode(new Uint8Array([0x03, ...output.lockupScript.contractId]))
-    const tokens = output.tokens.value.map((token) => {
+    const hint = createHint(output.lockupScript)
+    const key = binToHex(blakeHash(concatBytes([txIdBytes, intAs4BytesCodec.encode(index)])))
+    const attoAlphAmount = output.amount.toString()
+    const address = bs58.encode(new Uint8Array([0x03, ...output.lockupScript]))
+    const tokens = output.tokens.map((token) => {
       return {
         id: binToHex(token.tokenId),
-        amount: compactUnsignedIntCodec.toU256(token.amount).toString()
+        amount: token.amount.toString()
       }
     })
     return { hint, key, attoAlphAmount, address, tokens, type: 'ContractOutput' }
   }
 
   static convertToOutput(apiContractOutput: ApiContractOutput): ContractOutput {
-    const amount: DecodedCompactInt = compactUnsignedIntCodec.fromU256(BigInt(apiContractOutput.attoAlphAmount))
-    const lockupScript: P2C = lockupScriptCodec.decode(bs58.decode(apiContractOutput.address)).script as P2C
+    const amount = BigInt(apiContractOutput.attoAlphAmount)
+    const lockupScript: P2C = lockupScriptCodec.decode(bs58.decode(apiContractOutput.address)).value as P2C
 
-    const tokensValue = apiContractOutput.tokens.map((token) => {
+    const tokens = apiContractOutput.tokens.map((token) => {
       return {
         tokenId: hexToBinUnsafe(token.id),
-        amount: compactUnsignedIntCodec.fromU256(BigInt(token.amount))
+        amount: BigInt(token.amount)
       }
     })
-    const tokens: DecodedArray<Token> = {
-      length: compactSignedIntCodec.fromI32(tokensValue.length),
-      value: tokensValue
-    }
-
     return { amount, lockupScript, tokens }
   }
 }
 
-export const contractOutputCodec = new ContractOutputCodec()
+export const contractOutputCodec = new ContractOutputCodec({
+  amount: u256Codec,
+  lockupScript: p2cCodec,
+  tokens: tokensCodec
+})

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

@@ -15,28 +15,17 @@ 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'
-import { concatBytes } from '../utils'
+import { byte32Codec, ObjectCodec } from './codec'
+import { intAs4BytesCodec } from './int-as-4bytes-codec'
 
 export interface ContractOutputRef {
   hint: number
   key: Uint8Array
 }
 
-export class ContractOutputRefCodec implements Codec<ContractOutputRef> {
-  parser = Parser.start().int32('hint').buffer('key', { length: 32 })
-
-  encode(input: ContractOutputRef): Uint8Array {
-    return concatBytes([signedIntCodec.encode(input.hint), input.key])
-  }
-
-  decode(input: Uint8Array): ContractOutputRef {
-    return this.parser.parse(input)
-  }
-}
-
-export const contractOutputRefCodec = new ContractOutputRefCodec()
+export const contractOutputRefCodec = new ObjectCodec<ContractOutputRef>({
+  hint: intAs4BytesCodec,
+  key: byte32Codec
+})
 export const contractOutputRefsCodec = new ArrayCodec(contractOutputRefCodec)

package/src/codec/either-codec.ts

@@ -15,59 +15,10 @@ 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'
+import { Codec, EnumCodec } 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>): Uint8Array {
-    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 new Uint8Array(result)
-  }
-
-  decode(input: Uint8Array): 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
-    }
-  }
+export type Either<L, R> = { kind: 'Left'; value: L } | { kind: 'Right'; value: R }
 
-  fromRight(right: R): Either<L, R> {
-    return {
-      either: 1,
-      value: right
-    }
-  }
+export function either<L, R>(name: string, l: Codec<L>, r: Codec<R>): Codec<Either<L, R>> {
+  return new EnumCodec(name, { Left: l, Right: r })
 }

package/src/codec/index.ts

@@ -20,7 +20,7 @@ export * from './array-codec'
 export * as assetOutput from './asset-output-codec'
 export * from './bigint-codec'
 export * from './bytestring-codec'
-export * from './codec'
+export { Codec, boolCodec } from './codec'
 export * from './compact-int-codec'
 export * as contractOutput from './contract-output-codec'
 export * from './contract-output-ref-codec'
@@ -29,12 +29,13 @@ export * from './input-codec'
 export * from './instr-codec'
 export * as lockupScript from './lockup-script-codec'
 export * as unlockScript from './unlock-script-codec'
-export * from './long-codec'
+export * as val from './val'
+export * from './timestamp-codec'
 export * from './method-codec'
 export * from './option-codec'
 export * as script from './script-codec'
 export * from './signature-codec'
-export * from './signed-int-codec'
+export * from './int-as-4bytes-codec'
 export * as token from './token-codec'
 export * from './transaction-codec'
 export * from './unsigned-tx-codec'

package/src/codec/input-codec.ts

@@ -15,47 +15,24 @@ 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 { AssetInput } from '../api/api-alephium'
-import { binToHex, concatBytes, hexToBinUnsafe } from '../utils'
+import { binToHex, hexToBinUnsafe } from '../utils'
 import { UnlockScript, unlockScriptCodec } from './unlock-script-codec'
-import { Codec } from './codec'
-import { signedIntCodec } from './signed-int-codec'
+import { byte32Codec, ObjectCodec } from './codec'
 import { ArrayCodec } from './array-codec'
+import { intAs4BytesCodec } from './int-as-4bytes-codec'
 
 export interface Input {
-  outputRef: {
-    hint: number
-    key: Uint8Array
-  }
+  hint: number
+  key: Uint8Array
   unlockScript: UnlockScript
 }
 
-export class InputCodec implements Codec<Input> {
-  parser = Parser.start()
-    .nest('outputRef', {
-      type: Parser.start().int32('hint').buffer('key', { length: 32 })
-    })
-    .nest('unlockScript', {
-      type: unlockScriptCodec.parser
-    })
-
-  encode(input: Input): Uint8Array {
-    return concatBytes([
-      signedIntCodec.encode(input.outputRef.hint),
-      input.outputRef.key,
-      unlockScriptCodec.encode(input.unlockScript)
-    ])
-  }
-
-  decode(input: Uint8Array): Input {
-    return this.parser.parse(input)
-  }
-
+export class InputCodec extends ObjectCodec<Input> {
   static toAssetInputs(inputs: Input[]): AssetInput[] {
     return inputs.map((input) => {
-      const hint = input.outputRef.hint
-      const key = binToHex(input.outputRef.key)
+      const hint = input.hint
+      const key = binToHex(input.key)
       const unlockScript = unlockScriptCodec.encode(input.unlockScript)
       return {
         outputRef: { hint, key },
@@ -69,13 +46,14 @@ export class InputCodec implements Codec<Input> {
       const hint = input.outputRef.hint
       const key = hexToBinUnsafe(input.outputRef.key)
       const unlockScript = unlockScriptCodec.decode(hexToBinUnsafe(input.unlockScript))
-      return {
-        outputRef: { hint, key },
-        unlockScript
-      }
+      return { hint, key, unlockScript }
     })
   }
 }
 
-export const inputCodec = new InputCodec()
+export const inputCodec = new InputCodec({
+  hint: intAs4BytesCodec,
+  key: byte32Codec,
+  unlockScript: unlockScriptCodec
+})
 export const inputsCodec = new ArrayCodec(inputCodec)