@kontor/kontor-sdk 1.0.0-alpha.27 → 1.0.0-alpha.29

package/src/sdk/actions/kontor/public/call-compose.ts

@@ -34,7 +34,7 @@ export type CallComposeParameters<
     | [Address, XOnlyPubKey]
     | undefined,
 > = CallComposeRequest &
-  GetAccountParameter<account, accountOverride, false, true> &
+  GetAccountParameter<account, accountOverride, true, true> &
   GetChainParameter<chain, chainOverride>;
 
 // TODO: organize these types or just refernece direc
@@ -56,6 +56,7 @@ export async function callCompose<
 ): Promise<CallComposeReturnType> {
   const {
     account: account_ = client.account,
+    chain = client.chain,
     utxos,
     satsPerVByte,
     instruction,
@@ -66,6 +67,10 @@ export async function callCompose<
     throw new Error("Account is required");
   }
 
+  if (!chain) {
+    throw new Error("Chain is required");
+  }
+
   if (utxos.length === 0) {
     // TODO: add custom error
     throw new Error("at least one funding UTXO is required");
@@ -74,15 +79,14 @@ export async function callCompose<
   //
   const account = parseAccount(account_);
 
-  const composeCall = await getKontorAction(
+  const composeCall = getKontorAction(
     client,
     buildComposeQuery,
     "buildComposeQuery",
   )({
     instruction,
     utxos,
-    xOnlyPubKey: account.xOnlyPubKey,
-    address: account.address,
+    account,
     satsPerVByte,
   });
 

package/src/sdk/actions/kontor/public/call-view.ts

@@ -5,15 +5,15 @@ import type {
 import type { ResolvedRegister } from "../../../../wit/register.js";
 import type { KontorPublicClient } from "../../../clients/kontor/create-public-client.js";
 import type { HttpTransport } from "../../../clients/transports/create-http-transport.js";
-import type { Chain } from "../../../types/chain.js";
+import type { Chain, GetChainParameter } from "../../../types/chain.js";
 
 export type CallViewParameters<
-  _chain extends Chain | undefined = Chain | undefined,
+  chain extends Chain | undefined = Chain,
+  chainOverride extends Chain | undefined = Chain | undefined,
 > = {
   contractAddress: ResolvedRegister["contractAddress"];
   wave: string;
-};
-
+} & GetChainParameter<chain, chainOverride>;
 // TODO: refine this type
 export type CallViewReturnType = ResultResponse<ViewResult>;
 
@@ -24,6 +24,7 @@ export async function callView<
   params: CallViewParameters<chain>,
 ): Promise<CallViewReturnType> {
   const { contractAddress, wave } = params;
+  // TODO: assert chain
 
   try {
     const response = await client.request({

package/src/sdk/actions/kontor/public/inspect.ts

@@ -5,19 +5,34 @@ import type {
 } from "../../../types/kontor.js";
 import type { KontorPublicClient } from "../../../clients/kontor/create-public-client.js";
 import type { HttpTransport } from "../../../clients/transports/create-http-transport.js";
-import type { Chain } from "../../../types/chain.js";
-
-export type InspectParameters = TransactionHex;
+import type { Chain, GetChainParameter } from "../../../types/chain.js";
+// import { assertCurrentChain } from "../../../utils/chain/assert-current-chain.js";
 
+export type InspectParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> = TransactionHex & GetChainParameter<chain, chainOverride>;
 export type InspectReturnType = ResultResponse<OpWithResult[]>;
 
 export async function inspect<
   chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
 >(
   client: KontorPublicClient<HttpTransport, chain>,
-  params: InspectParameters,
+  params: InspectParameters<chain, chainOverride>,
 ): Promise<InspectReturnType> {
-  const { hex } = params;
+  const {
+    hex,
+    // chain: chain_ = client.chain
+  } = params;
+
+  // TODO: chain assertions everywhere ( need to get current chain )
+
+  // assertCurrentChain({
+  //     currentChain: client.chain,
+  //     chain: chain_
+  // });
+  //
 
   try {
     const response = await client.request({
@@ -27,10 +42,6 @@ export async function inspect<
       body: { hex: hex },
     });
 
-    console.log("callView response:", response);
-
-    // TODO: fix CallViwewReturnType
-    // @ts-ignore
     return response;
   } catch (e) {
     // TODO: augment error handling

package/src/sdk/actions/kontor/public/proc-contract.test.ts

@@ -31,13 +31,12 @@ test.skip("e2e", async () => {
       "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
       "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
     ],
+    chain: signet,
   });
 
   // proc contract action defined on client
   // response is correctly typed
   const res = await client.procContract({
-    account: client.account!,
-    chain: signet,
     wit: wit,
     // can also be injected
 

package/src/sdk/actions/kontor/public/proc-contract.ts

@@ -18,52 +18,6 @@ import {
 } from "../../../utils/wit/encode-function-data.js";
 import { callCompose, type CallComposeReturnType } from "./call-compose.js";
 
-// export type WriteContractParameters<
-//   abi extends Abi | readonly unknown[] = Abi,
-//   functionName extends ContractFunctionName<
-//     abi,
-//     'nonpayable' | 'payable'
-//   > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
-//   args extends ContractFunctionArgs<
-//     abi,
-//     'nonpayable' | 'payable',
-//     functionName
-//   > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
-//   chain extends Chain | undefined = Chain | undefined,
-//   account extends Account | undefined = Account | undefined,
-//   chainOverride extends Chain | undefined = Chain | undefined,
-//   ///
-//   allFunctionNames = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
-//   derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
-// > = ContractFunctionParameters<
-//   abi,
-//   'nonpayable' | 'payable',
-//   functionName,
-//   args,
-//   false,
-//   allFunctionNames
-// > &
-//   GetChainParameter<chain, chainOverride> &
-//   Prettify<
-//     GetAccountParameter<account, Account | Address, true, true> &
-//       GetMutabilityAwareValue<
-//         abi,
-//         'nonpayable' | 'payable',
-//         functionName,
-//         FormattedTransactionRequest<derivedChain>['value'],
-//         args
-//       > & {
-//         /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
-//         dataSuffix?: Hex | undefined
-//       }
-//   > &
-//   UnionEvaluate<
-//     UnionOmit<
-//       FormattedTransactionRequest<derivedChain>,
-//       'data' | 'from' | 'to' | 'value'
-//     >
-//   >
-
 export type ProcContractParameters<
   wit extends Wit | readonly unknown[] = Wit,
   functionName extends ContractFunctionName<wit, "proc"> = ContractFunctionName<
@@ -78,12 +32,16 @@ export type ProcContractParameters<
   chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
   chainOverride extends Chain | undefined = Chain | undefined,
+  accountOverride extends Account | [Address, XOnlyPubKey] | undefined =
+    | Account
+    | [Address, XOnlyPubKey]
+    | undefined,
 > = ContractFunctionParameters<wit, "proc", functionName, args> & {
   utxos: UtxoId[];
   gas: bigint;
   satsPerVByte: number;
 } & GetChainParameter<chain, chainOverride> &
-  GetAccountParameter<account, Account | [XOnlyPubKey, Address], true, true>;
+  GetAccountParameter<account, accountOverride, true, true>;
 
 export type ProcContractReturnType = CallComposeReturnType;
 
@@ -93,9 +51,18 @@ export async function procContract<
   const wit extends Wit | readonly unknown[],
   functionName extends ContractFunctionName<wit, "proc">,
   const args extends ContractFunctionArgs<wit, "proc", functionName>,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
 >(
   client: KontorPublicClient<HttpTransport, chain>,
-  parameters: ProcContractParameters<wit, functionName, args>,
+  parameters: ProcContractParameters<
+    wit,
+    functionName,
+    args,
+    chain,
+    account,
+    chainOverride
+  >,
 ): Promise<ProcContractReturnType> {
   const {
     wit: wit,
@@ -111,13 +78,6 @@ export async function procContract<
     ...rest
   } = parameters as ProcContractParameters;
 
-  // @ts-ignore
-  const wave = encodeFunctionData({
-    wit: wit,
-    args,
-    functionName,
-  } as EncodeFunctionDataParameters);
-
   if (!account_) {
     // TODO: add custom error
     throw new Error("account is required");
@@ -128,6 +88,12 @@ export async function procContract<
     throw new Error("at least one funding UTXO is required");
   }
 
+  const wave = encodeFunctionData({
+    wit: wit,
+    args,
+    functionName,
+  } as EncodeFunctionDataParameters);
+
   try {
     const response = await getKontorAction(
       client,

package/src/sdk/actions/kontor/public/{view-contract.test-d.ts → view-contract.test.ts}

@@ -4,16 +4,16 @@ import { parseWit } from "../../../../wit/wit-parser/parse-wit.js";
 import { createPublicClient } from "../../../clients/kontor/create-public-client.js";
 import { http } from "../../../clients/transports/http.js";
 import { nativeToken } from "../../../contracts/wits.js";
+import { signet } from "../../../chains/definitions/signet.js";
 
 const wit = parseWit(nativeToken.raw);
 
 test("e2e", async () => {
   const client = createPublicClient({
     transport: http("https://signet-staging.kontor.network:35000/api"),
+    chain: signet,
   });
 
-  // view contract action defined on client
-  // response is correctly typed
   const res = await client.viewContract({
     wit: wit,
     functionName: "balances", // functin name is only valid if it's got a view-context

package/src/sdk/actions/kontor/public/view-contract.ts

@@ -2,7 +2,7 @@ import type { Wit } from "../../../../wit/wit.js";
 import type { Prettify } from "../../../../wit/type-utils.js";
 import type { KontorPublicClient } from "../../../clients/kontor/create-public-client.js";
 import type { HttpTransport } from "../../../clients/transports/create-http-transport.js";
-import type { Chain } from "../../../types/chain.js";
+import type { Chain, GetChainParameter } from "../../../types/chain.js";
 import type {
   ContractFunctionArgs,
   ContractFunctionName,
@@ -11,7 +11,6 @@ import type {
 } from "../../../types/contract.js";
 import { getKontorAction } from "../../../utils/get-action.js";
 import { decodeFunctionResult } from "../../../utils/wit/decode-function-result.js";
-// import { getAction } from "../../utils/getAction.js";
 import {
   encodeFunctionData,
   type EncodeFunctionDataParameters,
@@ -29,7 +28,10 @@ export type ViewContractParameters<
     "view",
     functionName
   > = ContractFunctionArgs<wit, "view", functionName>,
-> = ContractFunctionParameters<wit, "view", functionName, args>;
+  chain extends Chain | undefined = Chain,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> = ContractFunctionParameters<wit, "view", functionName, args> &
+  GetChainParameter<chain, chainOverride>;
 
 export type ViewContractReturnType<
   wit extends Wit | readonly unknown[] = Wit,
@@ -46,26 +48,24 @@ export type ViewContractReturnType<
 > = Prettify<ContractFunctionReturnType<wit, "view", functionName, args>>;
 
 export async function viewContract<
-  // chain exhttps://viem.sh/tends Chain | undefined,
   chain extends Chain | undefined,
   const wit extends Wit | readonly unknown[],
   functionName extends ContractFunctionName<wit, "view">,
   const args extends ContractFunctionArgs<wit, "view", functionName>,
 >(
   client: KontorPublicClient<HttpTransport, chain>,
-  parameters: ViewContractParameters<wit, functionName, args>,
+  parameters: ViewContractParameters<wit, functionName, args, chain>,
 ): Promise<ViewContractReturnType<wit, functionName, args>> {
   const {
     wit: wit,
     contractAddress,
     args,
     functionName,
-
-    // @ts-ignore
-    ...rest
+    chain: chain_ = client.chain,
   } = parameters as ViewContractParameters;
 
-  // @ts-ignore
+  //TODO: assert chain ( or delegate to downstream call )
+
   const wave = encodeFunctionData({
     wit: wit,
     args,
@@ -80,6 +80,7 @@ export async function viewContract<
     )({
       contractAddress: contractAddress,
       wave: wave,
+      chain: chain_,
     });
 
     console.log(response.result.type);

package/src/sdk/chains/definitions/signet.ts

@@ -1,7 +1,6 @@
 import { defineChain } from "../../utils/chain/defineChain.js";
 
 export const signet = defineChain({
-  id: 0,
   name: "signet",
   nativeCurrency: { name: "Kontor", symbol: "KOR", decimals: 18 },
   blockTime: 1_000 * 60 * 10,

package/src/sdk/clients/base/create-rpc-client.test.ts

@@ -78,7 +78,6 @@ describe("transports", () => {
      },
      "fees": undefined,
      "formatters": undefined,
-     "id": 0,
      "name": "signet",
      "nativeCurrency": {
        "decimals": 18,

package/src/sdk/clients/create-public-client.test.ts

@@ -81,7 +81,6 @@ test("with chain", () => {
      },
      "fees": undefined,
      "formatters": undefined,
-     "id": 0,
      "name": "signet",
      "nativeCurrency": {
        "decimals": 18,

package/src/sdk/clients/decorators/kontor/public.ts

@@ -59,35 +59,44 @@ export type KontorPublicActions<
     const wit extends Wit | readonly unknown[],
     functionName extends ContractFunctionName<wit, "view">,
     const args extends ContractFunctionArgs<wit, "view", functionName>,
+    chainOverride extends Chain | undefined,
   >(
-    args: ViewContractParameters<wit, functionName, args>,
+    args: ViewContractParameters<wit, functionName, args, chain, chainOverride>,
   ) => Promise<ViewContractReturnType<wit, functionName, args>>;
 
   procContract: <
     const wit extends Wit | readonly unknown[],
     functionName extends ContractFunctionName<wit, "proc">,
     const args extends ContractFunctionArgs<wit, "proc", functionName>,
+    chainOverride extends Chain | undefined,
   >(
-    args: ProcContractParameters<wit, functionName, args>,
+    args: ProcContractParameters<
+      wit,
+      functionName,
+      args,
+      chain,
+      account,
+      chainOverride
+    >,
   ) => Promise<ProcContractReturnType>;
 
-  callView: <chain extends Chain | undefined>(
-    args: CallViewParameters<chain>,
+  callView: <chainOverride extends Chain | undefined>(
+    args: CallViewParameters<chain, chainOverride>,
   ) => Promise<CallViewReturnType>;
 
-  buildInstructionQuery: <chain extends Chain | undefined>(
-    args: BuildInstructionQueryParameters<chain>,
-  ) => Promise<BuildInstructionQueryReturnType>;
+  buildInstructionQuery: (
+    args: BuildInstructionQueryParameters<account>,
+  ) => BuildInstructionQueryReturnType;
 
-  buildComposeQuery: <chain extends Chain | undefined>(
-    args: BuildComposeQueryParameters<chain>,
-  ) => Promise<BuildComposeQueryReturnType>;
+  buildComposeQuery: (
+    args: BuildComposeQueryParameters<account>,
+  ) => BuildComposeQueryReturnType;
 
   callCompose: <chainOverride extends Chain | undefined>(
     args: CallComposeParameters<chain, account, chainOverride>,
   ) => Promise<CallComposeReturnType>;
-  inspect: <_chain extends Chain | undefined>(
-    args: InspectParameters,
+  inspect: <chainOverride extends Chain | undefined>(
+    args: InspectParameters<chain, chainOverride>,
   ) => Promise<InspectReturnType>;
 };
 

package/src/sdk/clients/kontor/create-public-client.test.ts

@@ -39,11 +39,4 @@ test("creates", async () => {
       "viewContract": [Function],
     }
   `);
-
-  const x = await client.callView({
-    contractAddress: "token_0_0",
-    wave: "balances()",
-  });
-
-  console.log({ x });
 });

package/src/sdk/errors/chain.ts

@@ -0,0 +1,64 @@
+import type { Chain } from "../types/chain.js";
+
+import { BaseError } from "./base.js";
+
+export type ChainMismatchErrorType = ChainMismatchError & {
+  name: "ChainMismatchError";
+};
+export class ChainMismatchError extends BaseError {
+  constructor({ chain, currentChain }: { chain: Chain; currentChain: Chain }) {
+    super(
+      `The current chain of the wallet (name: ${currentChain.name}) does not match the target chain for the transaction (name: ${chain.name}).`,
+      {
+        metaMessages: [
+          `Current Chain:  ${currentChain.name}`,
+          `Expected Chain: ${chain.name}`,
+        ],
+        name: "ChainMismatchError",
+      },
+    );
+  }
+}
+
+export type ChainNotFoundErrorType = ChainNotFoundError & {
+  name: "ChainNotFoundError";
+};
+export class ChainNotFoundError extends BaseError {
+  constructor() {
+    super(
+      [
+        "No chain was provided to the request.",
+        "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient.",
+      ].join("\n"),
+      {
+        name: "ChainNotFoundError",
+      },
+    );
+  }
+}
+
+export type ClientChainNotConfiguredErrorType =
+  ClientChainNotConfiguredError & {
+    name: "ClientChainNotConfiguredError";
+  };
+export class ClientChainNotConfiguredError extends BaseError {
+  constructor() {
+    super("No chain was provided to the Client.", {
+      name: "ClientChainNotConfiguredError",
+    });
+  }
+}
+
+export type InvalidChainIdErrorType = InvalidChainIdError & {
+  name: "InvalidChainIdError";
+};
+export class InvalidChainIdError extends BaseError {
+  constructor({ chainId }: { chainId?: number | undefined }) {
+    super(
+      typeof chainId === "number"
+        ? `Chain ID "${chainId}" is invalid.`
+        : "Chain ID is invalid.",
+      { name: "InvalidChainIdError" },
+    );
+  }
+}

package/src/sdk/test/e2e.test.ts

@@ -116,7 +116,10 @@ export const wit = parseWit(nativeTokenRaw);
 // });
 
 test("e2e kontor wallet client", async () => {
-  const account = mnemonicToAccount(process.env.TEST_MNEMONIC!);
+  const account = mnemonicToAccount(process.env.TEST_MNEMONIC!, {
+    coinType: 1,
+    networkConfig: signet.networkConfig,
+  });
 
   const kontorPublicClient = createKontorPublicClient({
     transport: http("https://signet-staging.kontor.network:35000/api"),
@@ -140,6 +143,27 @@ test("e2e kontor wallet client", async () => {
     satsPerVByte: 1,
   });
 
+  // TODO: add separate tests for these
+  // const instructionQuery_ = kontorPublicClient.buildInstructionQuery({
+  //   utxos: [
+  //     "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
+  //   ],
+  //   instruction: Instruction.issuance(),
+  // });
+  //
+  // const composeQuery_ = kontorPublicClient.buildComposeQuery({
+  //   utxos: [
+  //     "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
+  //   ],
+  //
+  //   instruction: Instruction.issuance(),
+  //   satsPerVByte: 1,
+  // });
+  // const x = await kontorPublicClient.callView({
+  //   contractAddress: "token_0_0",
+  //   wave: "balances()",
+  // });
+
   const commit: Transaction = await kontorWalletClient.signCommit({
     psbt: res.result.commit_psbt_hex,
   });

package/src/sdk/types/chain.ts

@@ -73,8 +73,6 @@ export type Chain<
         }
       >
     | undefined;
-  /** ID in number form */
-  id: number;
   /** Human-readable name */
   name: string;
   nativeCurrency: ChainNativeCurrency;

package/src/sdk/types/contract.ts

@@ -1,5 +1,4 @@
 import type {
-  // Address,
   Wit,
   WitFunction,
   WitParameter,
@@ -26,10 +25,6 @@ export type ContractFunctionName<
       : functionName
     : string;
 
-// AbiParametersToPrimitiveTypes,
-// AbiParameterToPrimitiveType,
-// ExtractAbiFunction,
-
 export type ContractFunctionArgs<
   wit extends Wit | readonly unknown[] = Wit,
   mutability extends WitStateMutability = WitStateMutability,
@@ -107,12 +102,8 @@ export type ContractFunctionParameters<
     mutability,
     functionName
   > = ContractFunctionArgs<wit, mutability, functionName>,
-  // deployless extends boolean = false,
-  ///
   allFunctionNames = ContractFunctionName<wit, mutability>,
   allArgs = ContractFunctionArgs<wit, mutability, functionName>,
-  // when `args` is inferred to `readonly []` ("inputs": []) or `never` (`abi` declared as `Abi` or not inferrable), allow `args` to be optional.
-  // important that both branches return same structural type
 > = {
   wit: wit;
   functionName:
@@ -224,23 +215,21 @@ export type ExtractWitItemForArgs<
   ExtractWitItem<wit, name> extends infer witItem extends WitItem & {
     inputs: readonly WitParameter[];
   }
-    ? IsUnion<witItem> extends true // narrow overloads using `args` by converting to tuple and filtering out overloads that don't match
+    ? IsUnion<witItem> extends true
       ? UnionToTuple<witItem> extends infer witItems extends
           readonly (WitItem & {
             inputs: readonly WitParameter[];
           })[]
         ? {
             [k in keyof witItems]: (
-              readonly [] extends args
-                ? readonly [] // fallback to `readonly []` if `args` has no value (e.g. `args` property not provided)
-                : args
+              readonly [] extends args ? readonly [] : args
             ) extends WitParametersToPrimitiveTypes<
               witItems[k]["inputs"],
               "inputs"
             >
               ? witItems[k]
               : never;
-          }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)
+          }[number]
         : never
       : witItem
     : never;

package/src/sdk/utils/chain/assert-current-chain.ts

@@ -0,0 +1,28 @@
+import {
+  ChainMismatchError,
+  type ChainMismatchErrorType,
+  ChainNotFoundError,
+  type ChainNotFoundErrorType,
+} from "../../errors/chain.js";
+
+import type { ErrorType } from "../../errors/utils.js";
+import type { Chain } from "../../types/chain.js";
+
+export type AssertCurrentChainParameters = {
+  chain?: Chain | undefined;
+  currentChain: Chain;
+};
+
+export type AssertCurrentChainErrorType =
+  | ChainNotFoundErrorType
+  | ChainMismatchErrorType
+  | ErrorType;
+
+export function assertCurrentChain({
+  chain,
+  currentChain,
+}: AssertCurrentChainParameters): void {
+  if (!chain) throw new ChainNotFoundError();
+  if (currentChain.name !== chain.name)
+    throw new ChainMismatchError({ chain, currentChain });
+}

package/src/sdk/utils/kontor/build-compose-query.ts

@@ -0,0 +1,33 @@
+import type { Address, UtxoId, XOnlyPubKey } from "../../types/misc.js";
+import type { ComposeQuery } from "@kontor/kontor-ts";
+import type { Inst } from "../../../sdk/types/kontor.js";
+import { buildInstructionQuery } from "./build-instruction-query.js";
+
+export type BuildComposeQueryParameters = {
+  instruction: Inst;
+  address: Address;
+  xOnlyPubKey: XOnlyPubKey; // TODO: maybe this should be wrapped in a single object
+  utxos: UtxoId[];
+  satsPerVByte: number;
+};
+
+export type BuildComposeQueryReturnType = ComposeQuery;
+
+export function buildComposeQuery(
+  params: BuildComposeQueryParameters,
+): BuildComposeQueryReturnType {
+  const { instruction: inst, utxos, address, xOnlyPubKey } = params;
+
+  const instruction = buildInstructionQuery({
+    instruction: inst,
+    utxos,
+    xOnlyPubKey,
+    address,
+  });
+
+  return {
+    instructions: [instruction],
+    sat_per_vbyte: params.satsPerVByte,
+    envelope: null,
+  };
+}