tempo.ts 0.0.5 → 0.1.0

package/src/prool/internal/consensus.toml

@@ -1,32 +0,0 @@
-signer = "0x117be1de549d1d4322c4711f11efa0c5137903124f85fc37c761ffc91ace30cb"
-share = "0x006b170a6a737021ce871c154f6681ea2297b65bfcce6eb2e6a43c5e8a40fefba4"
-polynomial = "0x98c6e82fdf8990fa8b78df3788c45d4a36d83dd6c4e619b7b746abe12891427dd93ccd2d00596b8a87a5b084578fd2cf0a1f3a02672f4b370b2601e6425f873eafeb10a62adaa093b503a8630b89994c5f1401e62001896d2bd4f858be2cb94186445b36c1e706cf466b003845b0aabdade971bd12eae6c97c5c489d77b55301fc0c20d3c70172c9e80441cf1c1168680906ac1638aa86671fb3e5cecbc9356b30044ca8e8cc1b3baa4389d62fba2812e1d3820f63f7785f763f82fb3b3cf1a787f4417a797c779941dc3a61fe17cf23ea885f447cd319aed4ebe916242968f781480c2c06980ec7c1b6b6c73f0b51cf04f301e6bd7d10b45e2106510af7bff7ee392f4319224352722fd1cd5c1d1f2785caf6808be769232813fd78804397b7"
-listen_port = 8000
-metrics_port = 8001
-storage_directory = "/tmp/consensus"
-worker_threads = 3
-bootstrappers = [
-  "0x2a685998ee44953a3eb0a5d316937f810a80bdcc952c0aa07b4d82b3fed459c2",
-]
-message_backlog = 16384
-mailbox_size = 16384
-deque_size = 10
-fee_recipient = "0x0000000000000000000000000000000000000000"
-
-[p2p]
-max_message_size_bytes = 1048576
-
-[peers]
-0x0c229e27a8c69e7afe86900dfbceab6ef6d207582c127a0d99fe9b3fb5a2068a = "tempo-validator-0:8000"
-0x2a685998ee44953a3eb0a5d316937f810a80bdcc952c0aa07b4d82b3fed459c2 = "tempo-validator-1:8000"
-0x7f7fdd1ca8d7c3ed8206137178b47bcafe7a54d4a0b4ce5bd9e25978184b48ce = "tempo-validator-2:8000"
-0xee1aa49a4459dfe813a3cf6eb882041230c7b2558469de81f87c9bf23bf10a03 = "tempo-validator-3:8000"
-
-[timeouts]
-time_for_peer_response = "200ms"
-time_to_collect_notarizations = "200ms"
-time_to_propose = "200ms"
-time_to_retry_nullify_broadcast = "3s"
-views_to_track = 256
-views_until_leader_skip = 32
-new_payload_wait_time = "100ms"

package/src/viem/addresses.ts

@@ -1,10 +0,0 @@
-export const accountImplementationAddress =
-  '0x7702c00000000000000000000000000000000000'
-export const accountRegistrarAddress =
-  '0x7702ac0000000000000000000000000000000000'
-export const feeManagerAddress = '0xfeec000000000000000000000000000000000000'
-export const tip20FactoryAddress = '0x20fc000000000000000000000000000000000000'
-export const tip403RegistryAddress =
-  '0x403c000000000000000000000000000000000000'
-export const usdAddress = '0x20c0000000000000000000000000000000000000'
-export const usdId = 0n

package/src/viem/transaction.ts

@@ -1,253 +0,0 @@
-import type * as Calls from 'ox/erc7821/Calls'
-import * as Execute from 'ox/erc7821/Execute'
-import * as Hex from 'ox/Hex'
-import * as Secp256k1 from 'ox/Secp256k1'
-import * as Signature from 'ox/Signature'
-import {
-  type AccessList,
-  type Account,
-  type Address,
-  type AuthorizationList,
-  type FeeValuesEIP1559,
-  type ParseTransactionReturnType,
-  type SignedAuthorizationList,
-  type TransactionBase,
-  type TransactionRequestBase,
-  type TransactionSerializableBase,
-  type TransactionSerializableGeneric,
-  type TransactionSerializedGeneric,
-  parseTransaction as viem_parseTransaction,
-  type RpcTransaction as viem_RpcTransaction,
-  type RpcTransactionRequest as viem_RpcTransactionRequest,
-  type Signature as viem_Signature,
-  serializeTransaction as viem_serializeTransaction,
-  type Transaction as viem_Transaction,
-  type TransactionRequest as viem_TransactionRequest,
-  type TransactionSerializable as viem_TransactionSerializable,
-  type TransactionSerialized as viem_TransactionSerialized,
-  type TransactionType as viem_TransactionType,
-} from 'viem'
-import type { ExactPartial, OneOf } from '../internal/types.js'
-import * as TxFeeToken from '../ox/TransactionEnvelopeFeeToken.js'
-
-export type Transaction<
-  bigintType = bigint,
-  numberType = number,
-  pending extends boolean = false,
-> = OneOf<
-  | viem_Transaction<bigintType, numberType, pending>
-  | TransactionFeeToken<bigintType, numberType, pending>
->
-export type TransactionRpc<pending extends boolean = false> = OneOf<
-  | viem_RpcTransaction<pending>
-  | TransactionFeeToken<Hex.Hex, Hex.Hex, pending, '0x77'>
->
-
-export type TransactionFeeToken<
-  quantity = bigint,
-  index = number,
-  isPending extends boolean = boolean,
-  type = 'feeToken',
-> = TransactionBase<quantity, index, isPending> & {
-  /** EIP-2930 Access List. */
-  accessList: AccessList
-  /** Authorization list for the transaction. */
-  authorizationList: SignedAuthorizationList
-  /** Chain ID that this transaction is valid on. */
-  chainId: index
-  /** Fee token preference. */
-  feeToken?: Address | undefined
-  /** Fee payer address. */
-  feePayer?: Address | undefined
-  /** Fee payer signature. */
-  feePayerSignature?: viem_Signature | undefined
-  type: type
-} & FeeValuesEIP1559<quantity>
-
-export type TransactionRequest<
-  bigintType = bigint,
-  numberType = number,
-> = OneOf<
-  | viem_TransactionRequest<bigintType, numberType>
-  | TransactionRequestFeeToken<bigintType, numberType>
->
-export type TransactionRequestRpc = OneOf<
-  | viem_RpcTransactionRequest
-  | TransactionRequestFeeToken<Hex.Hex, Hex.Hex, '0x77'>
->
-
-export type TransactionRequestFeeToken<
-  quantity = bigint,
-  index = number,
-  type = 'feeToken',
-> = TransactionRequestBase<quantity, index, type> &
-  ExactPartial<FeeValuesEIP1559<quantity>> & {
-    accessList?: AccessList | undefined
-    authorizationList?: AuthorizationList<index, boolean> | undefined
-    calls?: readonly Calls.Call[] | undefined
-    feePayer?: Account | true | undefined
-    feeToken?: Address | bigint | undefined
-  }
-
-export type TransactionSerializable = OneOf<
-  viem_TransactionSerializable | TransactionSerializableFeeToken
->
-
-export type TransactionSerializableFeeToken<
-  quantity = bigint,
-  index = number,
-> = TransactionSerializableBase<quantity, index> &
-  ExactPartial<FeeValuesEIP1559<quantity>> & {
-    accessList?: AccessList | undefined
-    authorizationList: SignedAuthorizationList
-    feeToken?: Address | bigint | undefined
-    feePayerSignature?: viem_Signature | undefined
-    chainId: number
-    type?: 'feeToken' | undefined
-    yParity?: number | undefined
-  }
-
-export type TransactionSerialized<
-  type extends TransactionType = TransactionType,
-> = viem_TransactionSerialized<type> | TransactionSerializedFeeToken
-
-export type TransactionSerializedFeeToken = `0x77${string}`
-
-export type TransactionType = viem_TransactionType | 'feeToken'
-
-export function isTempoTransaction(transaction: Record<string, unknown>) {
-  if (transaction.type === 'feeToken') return true
-  if (typeof transaction.calls !== 'undefined') return true
-  if (typeof transaction.feePayer !== 'undefined') return true
-  if (typeof transaction.feeToken !== 'undefined') return true
-  return false
-}
-
-export function parseTransaction<
-  const serialized extends TransactionSerializedGeneric,
->(serializedTransaction: serialized): parseTransaction.ReturnValue<serialized> {
-  const type = Hex.slice(serializedTransaction, 0, 1)
-  if (type === '0x77') {
-    const { authorizationList, nonce, r, s, v, ...tx } = TxFeeToken.deserialize(
-      serializedTransaction as `0x77${string}`,
-    )
-    return {
-      ...tx,
-      authorizationList: authorizationList?.map((auth) => ({
-        ...auth,
-        nonce: Number(auth.nonce ?? 0n),
-        r: Hex.fromNumber(auth.r, { size: 32 }),
-        s: Hex.fromNumber(auth.s, { size: 32 }),
-      })),
-      nonce: Number(nonce ?? 0n),
-      ...(r ? { r: Hex.fromNumber(r, { size: 32 }) } : {}),
-      ...(s ? { s: Hex.fromNumber(s, { size: 32 }) } : {}),
-      ...(v ? { v: BigInt(v) } : {}),
-    } satisfies TransactionSerializableGeneric as never
-  }
-  return viem_parseTransaction(serializedTransaction) as never
-}
-
-export declare namespace parseTransaction {
-  export type ReturnValue<
-    serialized extends
-      TransactionSerializedGeneric = TransactionSerializedGeneric,
-  > = serialized extends TransactionSerializedFeeToken
-    ? TransactionSerializableFeeToken
-    : ParseTransactionReturnType<serialized>
-}
-
-export async function serializeTransaction(
-  transaction: TransactionSerializable & {
-    calls?: readonly Calls.Call[] | undefined
-    feePayer?: Account | true | undefined
-    from?: Address | undefined
-  },
-  signature?: viem_Signature | undefined,
-) {
-  if (!isTempoTransaction(transaction))
-    return viem_serializeTransaction(transaction as never, signature)
-
-  const signature_ = transaction.r && transaction.s ? transaction : signature
-
-  const {
-    authorizationList,
-    chainId,
-    calls,
-    feePayer,
-    feePayerSignature,
-    from,
-    nonce,
-    r,
-    s,
-    v,
-    ...rest
-  } = transaction
-
-  // TODO: remove once native transaction type has `calls`.
-  const { data, to, value } = (() => {
-    if (calls && from)
-      return {
-        data: Execute.encodeData(calls),
-        to: from,
-        value: 0n,
-      } as const
-    return {
-      data: transaction.data,
-      to: transaction.to,
-      value: transaction.value,
-    } as const
-  })()
-
-  const transaction_ox = {
-    ...rest,
-    authorizationList: authorizationList?.map((auth) => ({
-      ...auth,
-      nonce: BigInt(auth.nonce),
-      r: BigInt(auth.r!),
-      s: BigInt(auth.s!),
-      yParity: Number(auth.yParity),
-    })),
-    chainId: Number(chainId),
-    data,
-    feePayerSignature: feePayerSignature
-      ? {
-          r: BigInt(feePayerSignature.r!),
-          s: BigInt(feePayerSignature.s!),
-          yParity: Number(feePayerSignature.yParity),
-        }
-      : feePayer
-        ? null
-        : undefined,
-    to,
-    type: 'feeToken',
-    value,
-    ...(nonce ? { nonce: BigInt(nonce) } : {}),
-    ...(r ? { r: BigInt(r) } : {}),
-    ...(s ? { s: BigInt(s) } : {}),
-    ...(v ? { v: Number(v) } : {}),
-  } satisfies TxFeeToken.TransactionEnvelopeFeeToken
-
-  if (signature_ && typeof transaction.feePayer === 'object') {
-    const tx = TxFeeToken.from(transaction_ox, {
-      signature: signature_ as never,
-    })
-    const sender = Secp256k1.recoverAddress({
-      payload: TxFeeToken.getSignPayload(tx),
-      signature: signature_ as never,
-    })
-    const hash = TxFeeToken.getFeePayerSignPayload(tx, {
-      sender,
-    })
-    const feePayerSignature = await transaction.feePayer.sign!({
-      hash,
-    })
-    return TxFeeToken.serialize(tx, {
-      feePayerSignature: Signature.from(feePayerSignature),
-    })
-  }
-  return TxFeeToken.serialize(transaction_ox, {
-    feePayerSignature: feePayer === true ? null : undefined,
-    signature: signature as never,
-  })
-}