@ckb-ccc/core 1.12.5 → 1.14.0

package/src/molecule/predefined.ts

@@ -1,91 +1,104 @@
 import { bytesFrom, bytesTo } from "../bytes/index.js";
-import { Hex, hexFrom, HexLike } from "../hex/index.js";
-import { byteVec, Codec, option, uint, uintNumber, vector } from "./codec.js";
+import { Codec, CodecBytes } from "../codec/index.js";
+import { Hex, HexLike } from "../hex/index.js";
+import { byteVec, option, vector } from "./codec.js";
+
+import {
+  CodecBool as Bool,
+  CodecByte as Byte,
+  CodecByte16 as Byte16,
+  CodecByte32 as Byte32,
+  CodecByte4 as Byte4,
+  CodecByte8 as Byte8,
+  CodecUint128 as Uint128,
+  CodecUint128BE as Uint128BE,
+  CodecUint128LE as Uint128LE,
+  CodecUint16 as Uint16,
+  CodecUint16BE as Uint16BE,
+  CodecUint16LE as Uint16LE,
+  CodecUint256 as Uint256,
+  CodecUint256BE as Uint256BE,
+  CodecUint256LE as Uint256LE,
+  CodecUint32 as Uint32,
+  CodecUint32BE as Uint32BE,
+  CodecUint32LE as Uint32LE,
+  CodecUint512 as Uint512,
+  CodecUint512BE as Uint512BE,
+  CodecUint512LE as Uint512LE,
+  CodecUint64 as Uint64,
+  CodecUint64BE as Uint64BE,
+  CodecUint64LE as Uint64LE,
+  CodecUint8 as Uint8,
+} from "../codec/index.js";
+
+export {
+  Bool,
+  Byte,
+  Byte16,
+  Byte32,
+  Byte4,
+  Byte8,
+  Uint128,
+  Uint128BE,
+  Uint128LE,
+  Uint16,
+  Uint16BE,
+  Uint16LE,
+  Uint256,
+  Uint256BE,
+  Uint256LE,
+  Uint32,
+  Uint32BE,
+  Uint32LE,
+  Uint512,
+  Uint512BE,
+  Uint512LE,
+  Uint64,
+  Uint64BE,
+  Uint64LE,
+  Uint8,
+};
 
-export const Uint8 = uintNumber(1, true);
 export const Uint8Opt = option(Uint8);
 export const Uint8Vec = vector(Uint8);
 
-export const Uint16LE = uintNumber(2, true);
-export const Uint16BE = uintNumber(2);
-export const Uint16 = Uint16LE;
 export const Uint16Opt = option(Uint16);
 export const Uint16Vec = vector(Uint16);
 
-export const Uint32LE = uintNumber(4, true);
-export const Uint32BE = uintNumber(4);
-export const Uint32 = Uint32LE;
 export const Uint32Opt = option(Uint32);
 export const Uint32Vec = vector(Uint32);
 
-export const Uint64LE = uint(8, true);
-export const Uint64BE = uint(8);
-export const Uint64 = Uint64LE;
 export const Uint64Opt = option(Uint64);
 export const Uint64Vec = vector(Uint64);
 
-export const Uint128LE = uint(16, true);
-export const Uint128BE = uint(16);
-export const Uint128 = Uint128LE;
 export const Uint128Opt = option(Uint128);
 export const Uint128Vec = vector(Uint128);
 
-export const Uint256LE = uint(32, true);
-export const Uint256BE = uint(32);
-export const Uint256 = Uint256LE;
 export const Uint256Opt = option(Uint256);
 export const Uint256Vec = vector(Uint256);
 
-export const Uint512LE = uint(64, true);
-export const Uint512BE = uint(64);
-export const Uint512 = Uint512LE;
 export const Uint512Opt = option(Uint512);
 export const Uint512Vec = vector(Uint512);
 
-export const Bytes: Codec<HexLike, Hex> = byteVec({
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
+export const Bytes: Codec<HexLike, Hex> = byteVec(CodecBytes);
 export const BytesOpt = option(Bytes);
 export const BytesVec = vector(Bytes);
 
-export const Bool: Codec<boolean> = Codec.from({
-  byteLength: 1,
-  encode: (value) => bytesFrom(value ? [1] : [0]),
-  decode: (buffer) => bytesFrom(buffer)[0] !== 0,
-});
 export const BoolOpt = option(Bool);
 export const BoolVec = vector(Bool);
 
-export const Byte4: Codec<HexLike, Hex> = Codec.from({
-  byteLength: 4,
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
+export const ByteOpt = option(Byte);
+export const ByteVec = vector(Byte);
+
 export const Byte4Opt = option(Byte4);
 export const Byte4Vec = vector(Byte4);
 
-export const Byte8: Codec<HexLike, Hex> = Codec.from({
-  byteLength: 8,
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
 export const Byte8Opt = option(Byte8);
 export const Byte8Vec = vector(Byte8);
 
-export const Byte16: Codec<HexLike, Hex> = Codec.from({
-  byteLength: 16,
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
 export const Byte16Opt = option(Byte16);
 export const Byte16Vec = vector(Byte16);
 
-export const Byte32: Codec<HexLike, Hex> = Codec.from({
-  byteLength: 32,
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
 export const Byte32Opt = option(Byte32);
 export const Byte32Vec = vector(Byte32);
 

package/src/signer/btc/index.ts

@@ -1,3 +1,4 @@
+export * from "./psbt.js";
 export * from "./signerBtc.js";
 export * from "./signerBtcPublicKeyReadonly.js";
 export * from "./verify.js";

package/src/signer/btc/psbt.ts

@@ -0,0 +1,98 @@
+import { Hex, HexLike, hexFrom } from "../../hex/index.js";
+
+/**
+ * Options for signing a PSBT (Partially Signed Bitcoin Transaction)
+ */
+export type SignPsbtOptionsLike = {
+  /**
+   * Whether to finalize the PSBT after signing.
+   * Default is true.
+   */
+  autoFinalized?: boolean;
+  /**
+   * Array of inputs to sign
+   */
+  inputsToSign?: InputToSignLike[];
+};
+
+export class SignPsbtOptions {
+  constructor(
+    public autoFinalized: boolean,
+    public inputsToSign: InputToSign[],
+  ) {}
+
+  static from(options?: SignPsbtOptionsLike): SignPsbtOptions {
+    if (options instanceof SignPsbtOptions) {
+      return options;
+    }
+    return new SignPsbtOptions(
+      options?.autoFinalized ?? true,
+      options?.inputsToSign?.map((i) => InputToSign.from(i)) ?? [],
+    );
+  }
+}
+
+/**
+ * Specification for an input to sign in a PSBT.
+ * Must specify at least one of: address or pubkey.
+ */
+export type InputToSignLike = {
+  /**
+   * Which input to sign (index in the PSBT inputs array)
+   */
+  index: number;
+  /**
+   * (Optional) Sighash types to use for signing.
+   */
+  sighashTypes?: number[];
+  /**
+   * (Optional) When signing and unlocking Taproot addresses, the tweakSigner is used by default
+   * for signature generation. Setting this to true allows for signing with the original private key.
+   * Default value is false.
+   */
+  disableTweakSigner?: boolean;
+} & (
+  | {
+      /**
+       * The address whose corresponding private key to use for signing.
+       */
+      address: string;
+      /**
+       * The public key whose corresponding private key to use for signing.
+       */
+      publicKey?: HexLike;
+    }
+  | {
+      /**
+       * The address whose corresponding private key to use for signing.
+       */
+      address?: string;
+      /**
+       * The public key whose corresponding private key to use for signing.
+       */
+      publicKey: HexLike;
+    }
+);
+
+export class InputToSign {
+  constructor(
+    public index: number,
+    public sighashTypes?: number[],
+    public disableTweakSigner?: boolean,
+    public address?: string,
+    public publicKey?: Hex,
+  ) {}
+
+  static from(input: InputToSignLike): InputToSign {
+    if (input instanceof InputToSign) {
+      return input;
+    }
+    return new InputToSign(
+      input.index,
+      input.sighashTypes,
+      input.disableTweakSigner,
+      input.address,
+      input.publicKey ? hexFrom(input.publicKey) : undefined,
+    );
+  }
+}

package/src/signer/btc/signerBtc.ts

@@ -2,9 +2,10 @@ import { Address } from "../../address/index.js";
 import { bytesConcat, bytesFrom } from "../../bytes/index.js";
 import { Transaction, TransactionLike, WitnessArgs } from "../../ckb/index.js";
 import { KnownScript } from "../../client/index.js";
-import { HexLike, hexFrom } from "../../hex/index.js";
+import { Hex, HexLike, hexFrom } from "../../hex/index.js";
 import { numToBytes } from "../../num/index.js";
 import { Signer, SignerSignType, SignerType } from "../signer/index.js";
+import { SignPsbtOptionsLike } from "./psbt.js";
 import { btcEcdsaPublicKeyHash } from "./verify.js";
 
 /**
@@ -22,6 +23,21 @@ export abstract class SignerBtc extends Signer {
     return SignerSignType.BtcEcdsa;
   }
 
+  /**
+   * Sign and broadcast a PSBT.
+   *
+   * @param psbtHex - The hex string of PSBT to sign and broadcast.
+   * @param options - Options for signing the PSBT.
+   * @returns A promise that resolves to the transaction ID as a Hex string.
+   */
+  async signAndBroadcastPsbt(
+    psbtHex: HexLike,
+    options?: SignPsbtOptionsLike,
+  ): Promise<Hex> {
+    const signedPsbt = await this.signPsbt(psbtHex, options);
+    return this.broadcastPsbt(signedPsbt, options);
+  }
+
   /**
    * Gets the Bitcoin account associated with the signer.
    *
@@ -123,4 +139,28 @@ export abstract class SignerBtc extends Signer {
     tx.setWitnessArgsAt(info.position, witness);
     return tx;
   }
+
+  /**
+   * Signs a Partially Signed Bitcoin Transaction (PSBT).
+   *
+   * @param psbtHex - The hex string of PSBT to sign.
+   * @param options - Options for signing the PSBT
+   * @returns A promise that resolves to the signed PSBT as a Hex string.
+   */
+  abstract signPsbt(
+    psbtHex: HexLike,
+    options?: SignPsbtOptionsLike,
+  ): Promise<Hex>;
+
+  /**
+   * Broadcasts a PSBT to the Bitcoin network.
+   *
+   * @param psbtHex - The hex string of the PSBT to broadcast.
+   * @param options - Options for broadcasting the PSBT.
+   * @returns A promise that resolves to the transaction ID as a Hex string.
+   */
+  abstract broadcastPsbt(
+    psbtHex: HexLike,
+    options?: SignPsbtOptionsLike,
+  ): Promise<Hex>;
 }

package/src/signer/btc/signerBtcPublicKeyReadonly.ts

@@ -1,5 +1,6 @@
 import { Client } from "../../client/index.js";
 import { Hex, HexLike, hexFrom } from "../../hex/index.js";
+import { SignPsbtOptionsLike } from "./psbt.js";
 import { SignerBtc } from "./signerBtc.js";
 
 /**
@@ -70,4 +71,18 @@ export class SignerBtcPublicKeyReadonly extends SignerBtc {
   async getBtcPublicKey(): Promise<Hex> {
     return this.publicKey;
   }
+
+  async signPsbt(
+    _psbtHex: HexLike,
+    _options?: SignPsbtOptionsLike,
+  ): Promise<Hex> {
+    throw new Error("Read-only signer does not support signPsbt");
+  }
+
+  async broadcastPsbt(
+    _psbtHex: HexLike,
+    _options?: SignPsbtOptionsLike,
+  ): Promise<Hex> {
+    throw new Error("Read-only signer does not support broadcastPsbt");
+  }
 }

package/src/signer/btc/verify.ts

@@ -1,4 +1,4 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
 import { ripemd160 } from "@noble/hashes/legacy.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import bs58check from "bs58check";
@@ -98,5 +98,6 @@ export function verifyMessageBtcEcdsa(
     bytesFrom(rawSign),
     messageHashBtcEcdsa(challenge),
     bytesFrom(publicKey),
+    { prehash: false },
   );
 }

package/src/signer/ckb/signerCkbPrivateKey.ts

@@ -1,9 +1,8 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
 import { bytesConcat, bytesFrom, BytesLike } from "../../bytes/index.js";
 import { Transaction, TransactionLike, WitnessArgs } from "../../ckb/index.js";
 import { Client } from "../../client/index.js";
 import { Hex, hexFrom, HexLike } from "../../hex/index.js";
-import { numBeToBytes } from "../../num/index.js";
 import { SignerCkbPublicKey } from "./signerCkbPublicKey.js";
 import { messageHashCkbSecp256k1 } from "./verifyCkbSecp256k1.js";
 
@@ -27,16 +26,12 @@ export class SignerCkbPrivateKey extends SignerCkbPublicKey {
     const signature = secp256k1.sign(
       bytesFrom(message),
       bytesFrom(this.privateKey),
+      {
+        format: "recovered",
+        prehash: false,
+      },
     );
-    const { r, s, recovery } = signature;
-
-    return hexFrom(
-      bytesConcat(
-        numBeToBytes(r, 32),
-        numBeToBytes(s, 32),
-        numBeToBytes(recovery, 1),
-      ),
-    );
+    return hexFrom(bytesConcat(signature.slice(1), signature.slice(0, 1)));
   }
 
   async signMessageRaw(message: string | BytesLike): Promise<Hex> {

package/src/signer/ckb/verifyCkbSecp256k1.ts

@@ -1,8 +1,7 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { BytesLike, bytesFrom } from "../../bytes/index.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { bytesConcat, bytesFrom, BytesLike } from "../../bytes/index.js";
 import { hashCkb } from "../../hasher/index.js";
 import { Hex, hexFrom } from "../../hex/index.js";
-import { numFrom } from "../../num/index.js";
 
 /**
  * @public
@@ -21,15 +20,12 @@ export function verifyMessageCkbSecp256k1(
   signature: string,
   publicKey: string,
 ): boolean {
-  const signatureBytes = bytesFrom(signature);
+  const raw = bytesFrom(signature);
+
   return secp256k1.verify(
-    new secp256k1.Signature(
-      numFrom(signatureBytes.slice(0, 32)),
-      numFrom(signatureBytes.slice(32, 64)),
-    )
-      .addRecoveryBit(Number(numFrom(signatureBytes.slice(64, 65))))
-      .toBytes(),
+    bytesConcat(raw.slice(64), raw.slice(0, 64)),
     bytesFrom(messageHashCkbSecp256k1(message)),
     bytesFrom(publicKey),
+    { format: "recovered", prehash: false },
   );
 }

package/src/signer/doge/signerDogePrivateKey.ts

@@ -1,4 +1,4 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
 import {
   Bytes,
   bytesConcat,
@@ -87,10 +87,13 @@ export class SignerDogePrivateKey extends SignerDoge {
     const signature = secp256k1.sign(
       messageHashDogeEcdsa(challenge),
       this.privateKey,
+      {
+        format: "recovered",
+        prehash: false,
+      },
     );
-
     return bytesTo(
-      bytesConcat([31 + signature.recovery], signature.toCompactRawBytes()),
+      bytesConcat([31 + Number(signature[0])], signature.slice(1)),
       "base64",
     );
   }

package/src/signer/doge/verify.ts

@@ -1,4 +1,4 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
 import { Bytes, bytesFrom, BytesLike } from "../../bytes/index.js";
 import { hexFrom } from "../../hex/index.js";
 import {
@@ -38,18 +38,17 @@ export function verifyMessageDogeEcdsa(
   const challenge =
     typeof message === "string" ? message : hexFrom(message).slice(2);
   const signatureBytes = bytesFrom(signature, "base64");
-  const recoveryBit = signatureBytes[0];
-  const rawSign = signatureBytes.slice(1);
-
-  const sig = secp256k1.Signature.fromCompact(
-    hexFrom(rawSign).slice(2),
-  ).addRecoveryBit(recoveryBit - 31);
+  signatureBytes[0] -= 31;
 
   return (
     btcPublicKeyFromP2pkhAddress(address) ===
     hexFrom(
       btcEcdsaPublicKeyHash(
-        sig.recoverPublicKey(messageHashDogeEcdsa(challenge)).toHex(),
+        secp256k1.recoverPublicKey(
+          signatureBytes,
+          messageHashDogeEcdsa(challenge),
+          { prehash: false },
+        ),
       ),
     )
   );

package/src/signer/nostr/signerNostrPrivateKey.ts

@@ -1,7 +1,8 @@
-import { schnorr } from "@noble/curves/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1.js";
 import { bech32 } from "bech32";
+import { Bytes, bytesFrom, BytesLike } from "../../bytes/index.js";
 import { Client } from "../../client/index.js";
-import { Hex, hexFrom, HexLike } from "../../hex/index.js";
+import { hexFrom } from "../../hex/index.js";
 import { NostrEvent } from "./signerNostr.js";
 import { SignerNostrPublicKeyReadonly } from "./signerNostrPublicKeyReadonly.js";
 import { nostrEventHash } from "./verify.js";
@@ -11,22 +12,22 @@ import { nostrEventHash } from "./verify.js";
  * Support nsec and hex format
  */
 export class SignerNostrPrivateKey extends SignerNostrPublicKeyReadonly {
-  private readonly privateKey: Hex;
+  private readonly privateKey: Bytes;
 
-  constructor(client: Client, privateKeyLike: HexLike) {
+  constructor(client: Client, privateKeyLike: BytesLike) {
     const privateKey = (() => {
       if (
         typeof privateKeyLike === "string" &&
         privateKeyLike.startsWith("nsec")
       ) {
         const { words } = bech32.decode(privateKeyLike);
-        return hexFrom(bech32.fromWords(words));
+        return bytesFrom(bech32.fromWords(words));
       }
 
-      return hexFrom(privateKeyLike);
+      return bytesFrom(privateKeyLike);
     })();
 
-    super(client, schnorr.getPublicKey(privateKey.slice(2)));
+    super(client, schnorr.getPublicKey(privateKey));
 
     this.privateKey = privateKey;
   }
@@ -34,7 +35,7 @@ export class SignerNostrPrivateKey extends SignerNostrPublicKeyReadonly {
   async signNostrEvent(event: NostrEvent): Promise<Required<NostrEvent>> {
     const pubkey = (await this.getNostrPublicKey()).slice(2);
     const eventHash = nostrEventHash({ ...event, pubkey });
-    const signature = schnorr.sign(eventHash, this.privateKey.slice(2));
+    const signature = schnorr.sign(eventHash, this.privateKey);
 
     return {
       ...event,

package/src/signer/nostr/verify.ts

@@ -1,4 +1,4 @@
-import { schnorr } from "@noble/curves/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { bech32 } from "bech32";
 import { Bytes, BytesLike, bytesFrom } from "../../bytes/index.js";
@@ -65,7 +65,7 @@ export function verifyMessageNostrEvent(
   const eventHash = nostrEventHash({ ...event, pubkey });
 
   try {
-    return schnorr.verify(hexFrom(signature).slice(2), eventHash, pubkey);
+    return schnorr.verify(bytesFrom(signature), eventHash, bytesFrom(pubkey));
   } catch (_) {
     return false;
   }

package/src/utils/index.ts

@@ -1,4 +1,5 @@
-import { NumLike, numFrom, numToHex } from "../num/index.js";
+import { Zero } from "../fixedPoint/index.js";
+import { NumLike, numFrom, numToHex, type Num } from "../num/index.js";
 
 /**
  * A type safe way to apply a transformer on a value if it's not empty.
@@ -196,3 +197,21 @@ export function stringify(val: unknown) {
     return value;
   });
 }
+
+/**
+ * Calculate the greatest common divisor (GCD) of two NumLike values using the Euclidean algorithm.
+ *
+ * @param a - First operand.
+ * @param b - Second operand.
+ * @returns GCD(a, b) as a Num.
+ */
+export function gcd(a: NumLike, b: NumLike): Num {
+  a = numFrom(a);
+  b = numFrom(b);
+  a = a < Zero ? -a : a;
+  b = b < Zero ? -b : b;
+  while (b !== Zero) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}

package/tsdown.config.mts

@@ -0,0 +1,53 @@
+import { defineConfig } from "tsdown";
+
+const common = {
+  minify: true,
+  dts: true,
+  platform: "neutral" as const,
+  sourcemap: true,
+  exports: true,
+};
+
+const entry = {
+  index: "src/index.ts",
+  barrel: "src/barrel.ts",
+  advanced: "src/advanced.ts",
+  advancedBarrel: "src/advancedBarrel.ts",
+} as const;
+
+const bundleDeps = [
+  "@noble/curves",
+  "@noble/hashes",
+  "@noble/ciphers",
+  "@noble/curves/*",
+  "@noble/hashes/*",
+  "@noble/ciphers/*",
+  "bs58check",
+  "bs58", // By bs58check
+  "base-x", // By bs58 - bs58check
+] as string[];
+
+export default defineConfig(
+  (
+    [
+      {
+        entry,
+        deps: {
+          onlyBundle: [] as string[],
+        },
+        format: "esm",
+        copy: "./misc/basedirs/dist/*",
+      },
+      {
+        entry,
+        deps: {
+          alwaysBundle: bundleDeps,
+          onlyBundle: bundleDeps,
+        },
+        format: "cjs",
+        outDir: "dist.commonjs",
+        copy: "./misc/basedirs/dist.commonjs/*",
+      },
+    ] as const
+  ).map((c) => ({ ...c, ...common })),
+);

package/dist/address/address.advanced.d.ts

@@ -1,65 +0,0 @@
-import { Client } from "../client/index.js";
-import { type AddressLike } from "./index.js";
-/**
- * Parses an address string into an address information object.
- *
- * @param address - The address string to parse.
- * @returns An object containing the address prefix, address format, and payload array.
- *
- * @throws Will throw an error if the address format is unknown.
- *
- * @example
- * ```typescript
- * const addressInfo = addressPayloadFromString("ckt1112139193129");
- * console.log(addressInfo.prefix); // Outputs the address prefix
- * console.log(addressInfo.format); // Outputs the address format
- * console.log(addressInfo.payload); // Outputs the payload array
- * ```
- */
-export declare function addressPayloadFromString(address: string): {
-    prefix: string;
-    format: AddressFormat;
-    payload: number[];
-};
-/**
- * Converts an address payload into an address-like object.
- *
- * @param prefix - The address prefix.
- * @param format - The format of the address, as defined by the AddressFormat enum.
- * @param payload - The payload array containing the address data.
- * @param client - The client instance used to fetch known scripts.
- * @returns A promise that resolves to an AddressLike object.
- *
- * @throws Will throw an error if the payload length is insufficient or if the script type is unknown.
- *
- * @example
- * ```typescript
- * const address = await addressFromPayload("ckt", AddressFormat.Full, [/* payload data *\/], client);
- * console.log(address.script); // Outputs the script object
- * console.log(address.prefix); // Outputs the address prefix
- * ```
- */
-export declare function addressFromPayload(prefix: string, format: AddressFormat, payload: number[], client: Client): Promise<AddressLike>;
-export declare enum AddressFormat {
-    /**
-     * full version identifies the hashType
-     */
-    Full = 0,
-    /**
-     * @deprecated
-     * short version for locks with Known codeHash, deprecated
-     */
-    Short = 1,
-    /**
-     * @deprecated
-     * full version with hashType = "Data", deprecated
-     */
-    FullData = 2,
-    /**
-     * @deprecated
-     * full version with hashType = "Type", deprecated
-     */
-    FullType = 4
-}
-export declare const ADDRESS_BECH32_LIMIT = 1023;
-//# sourceMappingURL=address.advanced.d.ts.map