@xpla/xplajs 1.7.0-beta.0

package/src/tendermint/version/types.ts

@@ -0,0 +1,219 @@
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
+import { GlobalDecoderRegistry } from "../../registry";
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ */
+export interface App {
+  protocol: bigint;
+  software: string;
+}
+export interface AppProtoMsg {
+  typeUrl: "/tendermint.version.App";
+  value: Uint8Array;
+}
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ */
+export interface AppAmino {
+  protocol: string;
+  software: string;
+}
+export interface AppAminoMsg {
+  type: "/tendermint.version.App";
+  value: AppAmino;
+}
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ */
+export interface Consensus {
+  block: bigint;
+  app: bigint;
+}
+export interface ConsensusProtoMsg {
+  typeUrl: "/tendermint.version.Consensus";
+  value: Uint8Array;
+}
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ */
+export interface ConsensusAmino {
+  block: string;
+  app: string;
+}
+export interface ConsensusAminoMsg {
+  type: "/tendermint.version.Consensus";
+  value: ConsensusAmino;
+}
+function createBaseApp(): App {
+  return {
+    protocol: BigInt(0),
+    software: ""
+  };
+}
+export const App = {
+  typeUrl: "/tendermint.version.App",
+  is(o: any): o is App {
+    return o && (o.$typeUrl === App.typeUrl || typeof o.protocol === "bigint" && typeof o.software === "string");
+  },
+  isAmino(o: any): o is AppAmino {
+    return o && (o.$typeUrl === App.typeUrl || typeof o.protocol === "bigint" && typeof o.software === "string");
+  },
+  encode(message: App, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.protocol !== BigInt(0)) {
+      writer.uint32(8).uint64(message.protocol);
+    }
+    if (message.software !== "") {
+      writer.uint32(18).string(message.software);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): App {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseApp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.protocol = reader.uint64();
+          break;
+        case 2:
+          message.software = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<App>): App {
+    const message = createBaseApp();
+    message.protocol = object.protocol !== undefined && object.protocol !== null ? BigInt(object.protocol.toString()) : BigInt(0);
+    message.software = object.software ?? "";
+    return message;
+  },
+  fromAmino(object: AppAmino): App {
+    const message = createBaseApp();
+    if (object.protocol !== undefined && object.protocol !== null) {
+      message.protocol = BigInt(object.protocol);
+    }
+    if (object.software !== undefined && object.software !== null) {
+      message.software = object.software;
+    }
+    return message;
+  },
+  toAmino(message: App): AppAmino {
+    const obj: any = {};
+    obj.protocol = message.protocol !== BigInt(0) ? message.protocol?.toString() : undefined;
+    obj.software = message.software === "" ? undefined : message.software;
+    return obj;
+  },
+  fromAminoMsg(object: AppAminoMsg): App {
+    return App.fromAmino(object.value);
+  },
+  fromProtoMsg(message: AppProtoMsg): App {
+    return App.decode(message.value);
+  },
+  toProto(message: App): Uint8Array {
+    return App.encode(message).finish();
+  },
+  toProtoMsg(message: App): AppProtoMsg {
+    return {
+      typeUrl: "/tendermint.version.App",
+      value: App.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(App.typeUrl, App);
+function createBaseConsensus(): Consensus {
+  return {
+    block: BigInt(0),
+    app: BigInt(0)
+  };
+}
+export const Consensus = {
+  typeUrl: "/tendermint.version.Consensus",
+  is(o: any): o is Consensus {
+    return o && (o.$typeUrl === Consensus.typeUrl || typeof o.block === "bigint" && typeof o.app === "bigint");
+  },
+  isAmino(o: any): o is ConsensusAmino {
+    return o && (o.$typeUrl === Consensus.typeUrl || typeof o.block === "bigint" && typeof o.app === "bigint");
+  },
+  encode(message: Consensus, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.block !== BigInt(0)) {
+      writer.uint32(8).uint64(message.block);
+    }
+    if (message.app !== BigInt(0)) {
+      writer.uint32(16).uint64(message.app);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Consensus {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConsensus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.block = reader.uint64();
+          break;
+        case 2:
+          message.app = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Consensus>): Consensus {
+    const message = createBaseConsensus();
+    message.block = object.block !== undefined && object.block !== null ? BigInt(object.block.toString()) : BigInt(0);
+    message.app = object.app !== undefined && object.app !== null ? BigInt(object.app.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: ConsensusAmino): Consensus {
+    const message = createBaseConsensus();
+    if (object.block !== undefined && object.block !== null) {
+      message.block = BigInt(object.block);
+    }
+    if (object.app !== undefined && object.app !== null) {
+      message.app = BigInt(object.app);
+    }
+    return message;
+  },
+  toAmino(message: Consensus): ConsensusAmino {
+    const obj: any = {};
+    obj.block = message.block !== BigInt(0) ? message.block?.toString() : undefined;
+    obj.app = message.app !== BigInt(0) ? message.app?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ConsensusAminoMsg): Consensus {
+    return Consensus.fromAmino(object.value);
+  },
+  fromProtoMsg(message: ConsensusProtoMsg): Consensus {
+    return Consensus.decode(message.value);
+  },
+  toProto(message: Consensus): Uint8Array {
+    return Consensus.encode(message).finish();
+  },
+  toProtoMsg(message: Consensus): ConsensusProtoMsg {
+    return {
+      typeUrl: "/tendermint.version.Consensus",
+      value: Consensus.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Consensus.typeUrl, Consensus);

package/src/types.d.ts

@@ -0,0 +1,124 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+import { IBinaryReader, IBinaryWriter } from "./binary";
+import { Any } from "./google/protobuf/any";
+import { OfflineSigner } from "@interchainjs/cosmos/types/wallet";
+import { HttpEndpoint } from "@interchainjs/types";
+export type ProtoMsg = Omit<Any, "typeUrl"> & {
+    typeUrl: any;
+};
+export interface IAminoMsg<Amino> {
+    type: any;
+    value: Amino;
+}
+export interface IProtoType {
+    $typeUrl?: any;
+}
+/**
+ * A type generated by Telescope 1.0.
+ */
+export interface TelescopeGeneratedCodec<T = unknown, SDK = unknown, Amino = unknown> {
+    readonly typeUrl: string;
+    readonly aminoType?: string;
+    is?(o: unknown): o is T;
+    isSDK?(o: unknown): o is SDK;
+    isAmino?(o: unknown): o is Amino;
+    encode: (message: T, writer?: IBinaryWriter | any) => IBinaryWriter | any;
+    decode: (input: IBinaryReader | Uint8Array | any, length?: number) => T;
+    fromPartial: (object: any) => T | any;
+    fromJSON?: (object: any) => T | any;
+    toJSON?: (message: T | any) => any;
+    fromSDK?: (sdk: SDK) => T;
+    fromSDKJSON?: (object: any) => SDK;
+    toSDK?: (message: T) => SDK;
+    fromAmino?: (amino: Amino) => T;
+    toAmino?: (message: T) => Amino;
+    fromAminoMsg?: (aminoMsg: IAminoMsg<Amino>) => T;
+    toAminoMsg?: (message: T) => IAminoMsg<Amino>;
+    toProto?: (message: T) => Uint8Array;
+    fromProtoMsg?: (message: ProtoMsg) => T;
+    toProtoMsg?: (message: T) => Any;
+}
+export type TelescopeGeneratedType<T = unknown, SDK = unknown, Amino = unknown> = TelescopeGeneratedCodec<T, SDK, Amino>;
+export type GeneratedType = TelescopeGeneratedCodec;
+/**
+ * Coin defines a token with a denomination and an amount.
+ *
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface Coin {
+    denom: string;
+    amount: string;
+}
+export type EncodeObject = Message<any>;
+export interface Message<T> {
+    typeUrl: string;
+    value: T;
+}
+export interface StdFee {
+    amount: Coin[];
+    gas: string;
+    /** The granter address that is used for paying with feegrants */
+    granter?: string;
+    /** The fee payer address. The payer must have signed the transaction. */
+    payer?: string;
+}
+export interface MsgData {
+    msgType: string;
+    data: Uint8Array;
+}
+export interface Attribute {
+    key: string;
+    value: string;
+    index: boolean;
+}
+export interface Event {
+    type: string;
+    attributes: Attribute[];
+}
+/**
+ * The response after successfully broadcasting a transaction.
+ * Success or failure refer to the execution result.
+ */
+export interface DeliverTxResponse {
+    height: number;
+    /** The position of the transaction within the block. This is a 0-based index. */
+    txIndex: number;
+    /** Error code. The transaction suceeded if and only if code is 0. */
+    code: number;
+    transactionHash: string;
+    events: Event[];
+    /**
+     * A string-based log document.
+     *
+     * This currently seems to merge attributes of multiple events into one event per type
+     * (https://github.com/tendermint/tendermint/issues/9595). You might want to use the `events`
+     * field instead.
+     */
+    rawLog?: string;
+    /** @deprecated Use `msgResponses` instead. */
+    data?: MsgData[];
+    /**
+     * The message responses of the [TxMsgData](https://github.com/cosmos/cosmos-sdk/blob/v0.46.3/proto/cosmos/base/abci/v1beta1/abci.proto#L128-L140)
+     * as `Any`s.
+     * This field is an empty list for chains running Cosmos SDK < 0.46.
+     */
+    msgResponses: Array<{
+        typeUrl: string;
+        value: Uint8Array;
+    }>;
+    gasUsed: bigint;
+    gasWanted: bigint;
+}
+export interface TxRpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+    signAndBroadcast?(signerAddress: string, messages: EncodeObject[], fee: StdFee | "auto" | number, memo: string): Promise<DeliverTxResponse>;
+}
+export interface SigningClientParams {
+    rpcEndpoint: string | HttpEndpoint;
+    signer: OfflineSigner;
+}

package/src/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/types.ts

@@ -0,0 +1,155 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.11.3
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+
+import { IBinaryReader, IBinaryWriter } from "./binary";
+import { Any } from "./google/protobuf/any";
+import { OfflineSigner } from "@interchainjs/cosmos/types/wallet";
+import { HttpEndpoint } from "@interchainjs/types";
+
+export type ProtoMsg = Omit<Any, "typeUrl"> & { typeUrl: any };
+
+export interface IAminoMsg<Amino> {
+  type: any;
+  value: Amino;
+}
+
+export interface IProtoType {
+  $typeUrl?: any;
+}
+
+/**
+ * A type generated by Telescope 1.0.
+ */
+export interface TelescopeGeneratedCodec<
+  T = unknown,
+  SDK = unknown,
+  Amino = unknown
+> {
+  readonly typeUrl: string;
+  readonly aminoType?: string;
+  is?(o: unknown): o is T;
+  isSDK?(o: unknown): o is SDK;
+  isAmino?(o: unknown): o is Amino;
+  encode: (message: T, writer?: IBinaryWriter | any) => IBinaryWriter | any;
+  decode: (input: IBinaryReader | Uint8Array | any, length?: number) => T;
+  fromPartial: (object: any) => T | any;
+  fromJSON?: (object: any) => T | any;
+  toJSON?: (message: T | any) => any;
+  fromSDK?: (sdk: SDK) => T;
+  fromSDKJSON?: (object: any) => SDK;
+  toSDK?: (message: T) => SDK;
+  fromAmino?: (amino: Amino) => T;
+  toAmino?: (message: T) => Amino;
+  fromAminoMsg?: (aminoMsg: IAminoMsg<Amino>) => T;
+  toAminoMsg?: (message: T) => IAminoMsg<Amino>;
+  toProto?: (message: T) => Uint8Array;
+  fromProtoMsg?: (message: ProtoMsg) => T;
+  toProtoMsg?: (message: T) => Any;
+}
+
+export type TelescopeGeneratedType<
+  T = unknown,
+  SDK = unknown,
+  Amino = unknown
+> = TelescopeGeneratedCodec<T, SDK, Amino>;
+
+export type GeneratedType = TelescopeGeneratedCodec;
+
+/**
+ * Coin defines a token with a denomination and an amount.
+ *
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface Coin {
+  denom: string;
+  amount: string;
+}
+
+export type EncodeObject = Message<any>;
+
+export interface Message<T> {
+  typeUrl: string;
+  value: T;
+}
+
+export interface StdFee {
+  amount: Coin[];
+  gas: string;
+  /** The granter address that is used for paying with feegrants */
+  granter?: string;
+  /** The fee payer address. The payer must have signed the transaction. */
+  payer?: string;
+}
+
+export interface MsgData {
+  msgType: string;
+  data: Uint8Array;
+}
+
+export interface Attribute {
+  key: string;
+  value: string;
+  index: boolean;
+}
+export interface Event {
+  type: string;
+  attributes: Attribute[];
+}
+
+/**
+ * The response after successfully broadcasting a transaction.
+ * Success or failure refer to the execution result.
+ */
+export interface DeliverTxResponse {
+  height: number;
+  /** The position of the transaction within the block. This is a 0-based index. */
+  txIndex: number;
+  /** Error code. The transaction suceeded if and only if code is 0. */
+  code: number;
+  transactionHash: string;
+  events: Event[];
+  /**
+   * A string-based log document.
+   *
+   * This currently seems to merge attributes of multiple events into one event per type
+   * (https://github.com/tendermint/tendermint/issues/9595). You might want to use the `events`
+   * field instead.
+   */
+  rawLog?: string;
+  /** @deprecated Use `msgResponses` instead. */
+  data?: MsgData[];
+  /**
+   * The message responses of the [TxMsgData](https://github.com/cosmos/cosmos-sdk/blob/v0.46.3/proto/cosmos/base/abci/v1beta1/abci.proto#L128-L140)
+   * as `Any`s.
+   * This field is an empty list for chains running Cosmos SDK < 0.46.
+   */
+  msgResponses: Array<{
+    typeUrl: string;
+    value: Uint8Array;
+  }>;
+  gasUsed: bigint;
+  gasWanted: bigint;
+}
+
+export interface TxRpc {
+  request(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Promise<Uint8Array>;
+  signAndBroadcast?(
+    signerAddress: string,
+    messages: EncodeObject[],
+    fee: StdFee | "auto" | number,
+    memo: string
+  ): Promise<DeliverTxResponse>;
+}
+
+export interface SigningClientParams {
+  rpcEndpoint: string | HttpEndpoint;
+  signer: OfflineSigner;
+}

package/src/utf8.d.ts

@@ -0,0 +1,27 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+export declare function utf8Length(str: string): number;
+/**
+ * Reads UTF8 bytes as a string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+export declare function utf8Read(buffer: ArrayLike<number>, start: number, end: number): string;
+/**
+ * Writes a string as UTF8 bytes.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Bytes written
+ */
+export declare function utf8Write(str: string, buffer: Uint8Array | Array<number>, offset: number): number;

package/src/utf8.js

@@ -0,0 +1,140 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+// Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// * Redistributions of source code must retain the above copyright
+//   notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+//   notice, this list of conditions and the following disclaimer in the
+//   documentation and/or other materials provided with the distribution.
+// * Neither the name of its author, nor the names of its contributors
+//   may be used to endorse or promote products derived from this software
+//   without specific prior written permission.
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8Length = utf8Length;
+exports.utf8Read = utf8Read;
+exports.utf8Write = utf8Write;
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+function utf8Length(str) {
+    let len = 0, c = 0;
+    for (let i = 0; i < str.length; ++i) {
+        c = str.charCodeAt(i);
+        if (c < 128)
+            len += 1;
+        else if (c < 2048)
+            len += 2;
+        else if ((c & 0xfc00) === 0xd800 &&
+            (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
+            ++i;
+            len += 4;
+        }
+        else
+            len += 3;
+    }
+    return len;
+}
+/**
+ * Reads UTF8 bytes as a string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+function utf8Read(buffer, start, end) {
+    const len = end - start;
+    if (len < 1)
+        return "";
+    const chunk = [];
+    let parts = [], i = 0, // char offset
+    t; // temporary
+    while (start < end) {
+        t = buffer[start++];
+        if (t < 128)
+            chunk[i++] = t;
+        else if (t > 191 && t < 224)
+            chunk[i++] = ((t & 31) << 6) | (buffer[start++] & 63);
+        else if (t > 239 && t < 365) {
+            t =
+                (((t & 7) << 18) |
+                    ((buffer[start++] & 63) << 12) |
+                    ((buffer[start++] & 63) << 6) |
+                    (buffer[start++] & 63)) -
+                    0x10000;
+            chunk[i++] = 0xd800 + (t >> 10);
+            chunk[i++] = 0xdc00 + (t & 1023);
+        }
+        else
+            chunk[i++] =
+                ((t & 15) << 12) |
+                    ((buffer[start++] & 63) << 6) |
+                    (buffer[start++] & 63);
+        if (i > 8191) {
+            (parts || (parts = [])).push(String.fromCharCode(...chunk));
+            i = 0;
+        }
+    }
+    if (parts) {
+        if (i)
+            parts.push(String.fromCharCode(...chunk.slice(0, i)));
+        return parts.join("");
+    }
+    return String.fromCharCode(...chunk.slice(0, i));
+}
+/**
+ * Writes a string as UTF8 bytes.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Bytes written
+ */
+function utf8Write(str, buffer, offset) {
+    const start = offset;
+    let c1, // character 1
+    c2; // character 2
+    for (let i = 0; i < str.length; ++i) {
+        c1 = str.charCodeAt(i);
+        if (c1 < 128) {
+            buffer[offset++] = c1;
+        }
+        else if (c1 < 2048) {
+            buffer[offset++] = (c1 >> 6) | 192;
+            buffer[offset++] = (c1 & 63) | 128;
+        }
+        else if ((c1 & 0xfc00) === 0xd800 &&
+            ((c2 = str.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
+            c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
+            ++i;
+            buffer[offset++] = (c1 >> 18) | 240;
+            buffer[offset++] = ((c1 >> 12) & 63) | 128;
+            buffer[offset++] = ((c1 >> 6) & 63) | 128;
+            buffer[offset++] = (c1 & 63) | 128;
+        }
+        else {
+            buffer[offset++] = (c1 >> 12) | 224;
+            buffer[offset++] = ((c1 >> 6) & 63) | 128;
+            buffer[offset++] = (c1 & 63) | 128;
+        }
+    }
+    return offset - start;
+}