@bitgo-beta/sdk-coin-sui 0.0.0-semantic-release-managed

package/dist/src/lib/mystenlab/builder/Transactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transactions.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/Transactions.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/mystenlab/builder/Transactions.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transactions = exports.TransactionType = exports.PublishTransaction = exports.MakeMoveVecTransaction = exports.MergeCoinsTransaction = exports.SplitCoinsTransaction = exports.TransferObjectsTransaction = exports.MoveCallTransaction = exports.PureTransactionArgument = exports.ObjectTransactionArgument = exports.TransactionArgument = exports.TransactionBlockInput = void 0;
+exports.getTransactionType = getTransactionType;
+const bcs_1 = require("@mysten/bcs");
+const superstruct_1 = require("superstruct");
+const common_1 = require("../types/common");
+const utils_1 = require("./utils");
+const option = (some) => (0, superstruct_1.union)([(0, superstruct_1.object)({ None: (0, superstruct_1.literal)(null) }), (0, superstruct_1.object)({ Some: some })]);
+exports.TransactionBlockInput = (0, superstruct_1.object)({
+    kind: (0, superstruct_1.literal)('Input'),
+    index: (0, superstruct_1.integer)(),
+    value: (0, superstruct_1.optional)((0, superstruct_1.any)()),
+    type: (0, superstruct_1.optional)((0, superstruct_1.union)([(0, superstruct_1.literal)('pure'), (0, superstruct_1.literal)('object')])),
+});
+const TransactionArgumentTypes = [
+    exports.TransactionBlockInput,
+    (0, superstruct_1.object)({ kind: (0, superstruct_1.literal)('GasCoin') }),
+    (0, superstruct_1.object)({ kind: (0, superstruct_1.literal)('Result'), index: (0, superstruct_1.integer)() }),
+    (0, superstruct_1.object)({
+        kind: (0, superstruct_1.literal)('NestedResult'),
+        index: (0, superstruct_1.integer)(),
+        resultIndex: (0, superstruct_1.integer)(),
+    }),
+];
+// Generic transaction argument
+exports.TransactionArgument = (0, superstruct_1.union)([...TransactionArgumentTypes]);
+// Transaction argument referring to an object:
+exports.ObjectTransactionArgument = (0, superstruct_1.union)([...TransactionArgumentTypes]);
+exports.ObjectTransactionArgument[utils_1.TRANSACTION_TYPE] = {
+    kind: 'object',
+};
+const PureTransactionArgument = (type) => {
+    const struct = (0, superstruct_1.union)([...TransactionArgumentTypes]);
+    struct[utils_1.TRANSACTION_TYPE] = {
+        kind: 'pure',
+        type,
+    };
+    return struct;
+};
+exports.PureTransactionArgument = PureTransactionArgument;
+exports.MoveCallTransaction = (0, superstruct_1.object)({
+    kind: (0, superstruct_1.literal)('MoveCall'),
+    target: (0, superstruct_1.define)('target', (0, superstruct_1.string)().validator),
+    typeArguments: (0, superstruct_1.array)((0, superstruct_1.string)()),
+    arguments: (0, superstruct_1.array)(exports.TransactionArgument),
+});
+exports.TransferObjectsTransaction = (0, superstruct_1.object)({
+    kind: (0, superstruct_1.literal)('TransferObjects'),
+    objects: (0, superstruct_1.array)(exports.ObjectTransactionArgument),
+    address: (0, exports.PureTransactionArgument)(bcs_1.BCS.ADDRESS),
+});
+exports.SplitCoinsTransaction = (0, superstruct_1.object)({
+    kind: (0, superstruct_1.literal)('SplitCoins'),
+    coin: exports.ObjectTransactionArgument,
+    amounts: (0, superstruct_1.array)((0, exports.PureTransactionArgument)('u64')),
+});
+exports.MergeCoinsTransaction = (0, superstruct_1.object)({
+    kind: (0, superstruct_1.literal)('MergeCoins'),
+    destination: exports.ObjectTransactionArgument,
+    sources: (0, superstruct_1.array)(exports.ObjectTransactionArgument),
+});
+exports.MakeMoveVecTransaction = (0, superstruct_1.object)({
+    kind: (0, superstruct_1.literal)('MakeMoveVec'),
+    type: (0, superstruct_1.optional)(option((0, superstruct_1.string)())),
+    objects: (0, superstruct_1.array)(exports.ObjectTransactionArgument),
+});
+exports.PublishTransaction = (0, superstruct_1.object)({
+    kind: (0, superstruct_1.literal)('Publish'),
+    modules: (0, superstruct_1.array)((0, superstruct_1.array)((0, superstruct_1.integer)())),
+    dependencies: (0, superstruct_1.array)(common_1.ObjectId),
+});
+const TransactionTypes = [
+    exports.MoveCallTransaction,
+    exports.TransferObjectsTransaction,
+    exports.SplitCoinsTransaction,
+    exports.MergeCoinsTransaction,
+    exports.PublishTransaction,
+    exports.MakeMoveVecTransaction,
+];
+exports.TransactionType = (0, superstruct_1.union)([...TransactionTypes]);
+function getTransactionType(data) {
+    (0, superstruct_1.assert)(data, exports.TransactionType);
+    return TransactionTypes.find((schema) => (0, superstruct_1.is)(data, schema));
+}
+/**
+ * Simple helpers used to construct transactions:
+ */
+exports.Transactions = {
+    MoveCall(input) {
+        return (0, utils_1.create)({
+            kind: 'MoveCall',
+            target: input.target,
+            arguments: input.arguments ?? [],
+            typeArguments: input.typeArguments ?? [],
+        }, exports.MoveCallTransaction);
+    },
+    TransferObjects(objects, address) {
+        return (0, utils_1.create)({ kind: 'TransferObjects', objects, address }, exports.TransferObjectsTransaction);
+    },
+    SplitCoins(coin, amounts) {
+        return (0, utils_1.create)({ kind: 'SplitCoins', coin, amounts }, exports.SplitCoinsTransaction);
+    },
+    MergeCoins(destination, sources) {
+        return (0, utils_1.create)({ kind: 'MergeCoins', destination, sources }, exports.MergeCoinsTransaction);
+    },
+    Publish(modules, dependencies) {
+        return (0, utils_1.create)({ kind: 'Publish', modules, dependencies }, exports.PublishTransaction);
+    },
+    MakeMoveVec({ type, objects, }) {
+        return (0, utils_1.create)({
+            kind: 'MakeMoveVec',
+            type: type ? { Some: type } : { None: null },
+            objects,
+        }, exports.MakeMoveVecTransaction);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Transactions.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/Transactions.ts"],"names":[],"mappings":"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","sourcesContent":["import { BCS } from '@mysten/bcs';\nimport {\n  is,\n  any,\n  array,\n  Infer,\n  integer,\n  literal,\n  object,\n  optional,\n  string,\n  union,\n  assert,\n  Struct,\n  define,\n} from 'superstruct';\nimport { ObjectId } from '../types/common';\nimport { TRANSACTION_TYPE, WellKnownEncoding, create } from './utils';\n\nconst option = <T extends Struct<any, any>>(some: T) =>\n  union([object({ None: literal(null) }), object({ Some: some })]);\n\nexport const TransactionBlockInput = object({\n  kind: literal('Input'),\n  index: integer(),\n  value: optional(any()),\n  type: optional(union([literal('pure'), literal('object')])),\n});\nexport type TransactionBlockInput = Infer<typeof TransactionBlockInput>;\n\nconst TransactionArgumentTypes = [\n  TransactionBlockInput,\n  object({ kind: literal('GasCoin') }),\n  object({ kind: literal('Result'), index: integer() }),\n  object({\n    kind: literal('NestedResult'),\n    index: integer(),\n    resultIndex: integer(),\n  }),\n] as const;\n\n// Generic transaction argument\nexport const TransactionArgument = union([...TransactionArgumentTypes]);\nexport type TransactionArgument = Infer<typeof TransactionArgument>;\n\n// Transaction argument referring to an object:\nexport const ObjectTransactionArgument = union([...TransactionArgumentTypes]);\n(ObjectTransactionArgument as any)[TRANSACTION_TYPE] = {\n  kind: 'object',\n} as WellKnownEncoding;\n\nexport const PureTransactionArgument = (type: string) => {\n  const struct = union([...TransactionArgumentTypes]);\n  (struct as any)[TRANSACTION_TYPE] = {\n    kind: 'pure',\n    type,\n  } as WellKnownEncoding;\n  return struct;\n};\n\nexport const MoveCallTransaction = object({\n  kind: literal('MoveCall'),\n  target: define<`${string}::${string}::${string}`>('target', string().validator),\n  typeArguments: array(string()),\n  arguments: array(TransactionArgument),\n});\nexport type MoveCallTransaction = Infer<typeof MoveCallTransaction>;\n\nexport const TransferObjectsTransaction = object({\n  kind: literal('TransferObjects'),\n  objects: array(ObjectTransactionArgument),\n  address: PureTransactionArgument(BCS.ADDRESS),\n});\nexport type TransferObjectsTransaction = Infer<typeof TransferObjectsTransaction>;\n\nexport const SplitCoinsTransaction = object({\n  kind: literal('SplitCoins'),\n  coin: ObjectTransactionArgument,\n  amounts: array(PureTransactionArgument('u64')),\n});\nexport type SplitCoinsTransaction = Infer<typeof SplitCoinsTransaction>;\n\nexport const MergeCoinsTransaction = object({\n  kind: literal('MergeCoins'),\n  destination: ObjectTransactionArgument,\n  sources: array(ObjectTransactionArgument),\n});\nexport type MergeCoinsTransaction = Infer<typeof MergeCoinsTransaction>;\n\nexport const MakeMoveVecTransaction = object({\n  kind: literal('MakeMoveVec'),\n  type: optional(option(string())),\n  objects: array(ObjectTransactionArgument),\n});\nexport type MakeMoveVecTransaction = Infer<typeof MakeMoveVecTransaction>;\n\nexport const PublishTransaction = object({\n  kind: literal('Publish'),\n  modules: array(array(integer())),\n  dependencies: array(ObjectId),\n});\nexport type PublishTransaction = Infer<typeof PublishTransaction>;\n\nconst TransactionTypes = [\n  MoveCallTransaction,\n  TransferObjectsTransaction,\n  SplitCoinsTransaction,\n  MergeCoinsTransaction,\n  PublishTransaction,\n  MakeMoveVecTransaction,\n] as const;\n\nexport const TransactionType = union([...TransactionTypes]);\nexport type TransactionType = Infer<typeof TransactionType>;\n\nexport function getTransactionType(data: unknown) {\n  assert(data, TransactionType);\n  return TransactionTypes.find((schema) => is(data, schema as Struct))!;\n}\n\n/**\n * Simple helpers used to construct transactions:\n */\nexport const Transactions = {\n  MoveCall(\n    input: Omit<MoveCallTransaction, 'kind' | 'arguments' | 'typeArguments'> & {\n      arguments?: TransactionArgument[];\n      typeArguments?: string[];\n    }\n  ): MoveCallTransaction {\n    return create(\n      {\n        kind: 'MoveCall',\n        target: input.target,\n        arguments: input.arguments ?? [],\n        typeArguments: input.typeArguments ?? [],\n      },\n      MoveCallTransaction\n    );\n  },\n  TransferObjects(objects: TransactionArgument[], address: TransactionArgument): TransferObjectsTransaction {\n    return create({ kind: 'TransferObjects', objects, address }, TransferObjectsTransaction);\n  },\n  SplitCoins(coin: TransactionArgument, amounts: TransactionArgument[]): SplitCoinsTransaction {\n    return create({ kind: 'SplitCoins', coin, amounts }, SplitCoinsTransaction);\n  },\n  MergeCoins(destination: TransactionArgument, sources: TransactionArgument[]): MergeCoinsTransaction {\n    return create({ kind: 'MergeCoins', destination, sources }, MergeCoinsTransaction);\n  },\n  Publish(modules: number[][], dependencies: ObjectId[]): PublishTransaction {\n    return create({ kind: 'Publish', modules, dependencies }, PublishTransaction);\n  },\n  MakeMoveVec({\n    type,\n    objects,\n  }: Omit<MakeMoveVecTransaction, 'kind' | 'type'> & {\n    type?: string;\n  }): MakeMoveVecTransaction {\n    return create(\n      {\n        kind: 'MakeMoveVec',\n        type: type ? { Some: type } : { None: null },\n        objects,\n      },\n      MakeMoveVecTransaction\n    );\n  },\n};\n"]}

package/dist/src/lib/mystenlab/builder/bcs.d.ts

@@ -0,0 +1,25 @@
+import { BCS, TypeName } from '@mysten/bcs';
+export declare const ARGUMENT_INNER = "Argument";
+export declare const VECTOR = "vector";
+export declare const OPTION = "Option";
+export declare const CALL_ARG = "CallArg";
+export declare const TYPE_TAG = "TypeTag";
+export declare const OBJECT_ARG = "ObjectArg";
+export declare const PROGRAMMABLE_TX_BLOCK = "ProgrammableTransaction";
+export declare const PROGRAMMABLE_CALL_INNER = "ProgrammableMoveCall";
+export declare const TRANSACTION_INNER = "Transaction";
+export declare const ENUM_KIND = "EnumKind";
+/** Wrapper around transaction Enum to support `kind` matching in TS */
+export declare const TRANSACTION: TypeName;
+/** Wrapper around Argument Enum to support `kind` matching in TS */
+export declare const ARGUMENT: TypeName;
+/** Custom serializer for decoding package, module, function easier */
+export declare const PROGRAMMABLE_CALL = "SimpleProgrammableMoveCall";
+/** Transaction types */
+export type Option<T> = {
+    some: T;
+} | {
+    none: true;
+};
+export declare const builder: BCS;
+//# sourceMappingURL=bcs.d.ts.map

package/dist/src/lib/mystenlab/builder/bcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bcs.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/bcs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAM5C,eAAO,MAAM,cAAc,aAAa,CAAC;AACzC,eAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,eAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,UAAU,cAAc,CAAC;AACtC,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAC/D,eAAO,MAAM,uBAAuB,yBAAyB,CAAC;AAC9D,eAAO,MAAM,iBAAiB,gBAAgB,CAAC;AAE/C,eAAO,MAAM,SAAS,aAAa,CAAC;AAEpC,uEAAuE;AACvE,eAAO,MAAM,WAAW,EAAE,QAAyC,CAAC;AACpE,oEAAoE;AACpE,eAAO,MAAM,QAAQ,EAAE,QAAsC,CAAC;AAE9D,sEAAsE;AACtE,eAAO,MAAM,iBAAiB,+BAA+B,CAAC;AAE9D,wBAAwB;AAExB,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC;AAErD,eAAO,MAAM,OAAO,KAwDhB,CAAC"}

package/dist/src/lib/mystenlab/builder/bcs.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = exports.PROGRAMMABLE_CALL = exports.ARGUMENT = exports.TRANSACTION = exports.ENUM_KIND = exports.TRANSACTION_INNER = exports.PROGRAMMABLE_CALL_INNER = exports.PROGRAMMABLE_TX_BLOCK = exports.OBJECT_ARG = exports.TYPE_TAG = exports.CALL_ARG = exports.OPTION = exports.VECTOR = exports.ARGUMENT_INNER = void 0;
+const bcs_1 = require("@mysten/bcs");
+const sui_bcs_1 = require("../types/sui-bcs");
+const common_1 = require("../types/common");
+const type_tag_serializer_1 = require("../txn-data-serializers/type-tag-serializer");
+exports.ARGUMENT_INNER = 'Argument';
+exports.VECTOR = 'vector';
+exports.OPTION = 'Option';
+exports.CALL_ARG = 'CallArg';
+exports.TYPE_TAG = 'TypeTag';
+exports.OBJECT_ARG = 'ObjectArg';
+exports.PROGRAMMABLE_TX_BLOCK = 'ProgrammableTransaction';
+exports.PROGRAMMABLE_CALL_INNER = 'ProgrammableMoveCall';
+exports.TRANSACTION_INNER = 'Transaction';
+exports.ENUM_KIND = 'EnumKind';
+/** Wrapper around transaction Enum to support `kind` matching in TS */
+exports.TRANSACTION = [exports.ENUM_KIND, exports.TRANSACTION_INNER];
+/** Wrapper around Argument Enum to support `kind` matching in TS */
+exports.ARGUMENT = [exports.ENUM_KIND, exports.ARGUMENT_INNER];
+/** Custom serializer for decoding package, module, function easier */
+exports.PROGRAMMABLE_CALL = 'SimpleProgrammableMoveCall';
+exports.builder = new bcs_1.BCS(sui_bcs_1.bcs)
+    .registerStructType(exports.PROGRAMMABLE_TX_BLOCK, {
+    inputs: [exports.VECTOR, exports.CALL_ARG],
+    transactions: [exports.VECTOR, exports.TRANSACTION],
+})
+    .registerEnumType(exports.ARGUMENT_INNER, {
+    GasCoin: null,
+    Input: { index: bcs_1.BCS.U16 },
+    Result: { index: bcs_1.BCS.U16 },
+    NestedResult: { index: bcs_1.BCS.U16, resultIndex: bcs_1.BCS.U16 },
+})
+    .registerStructType(exports.PROGRAMMABLE_CALL_INNER, {
+    package: bcs_1.BCS.ADDRESS,
+    module: bcs_1.BCS.STRING,
+    function: bcs_1.BCS.STRING,
+    type_arguments: [exports.VECTOR, exports.TYPE_TAG],
+    arguments: [exports.VECTOR, exports.ARGUMENT],
+})
+    .registerEnumType(exports.TRANSACTION_INNER, {
+    /**
+     * A Move Call - any public Move function can be called via
+     * this transaction. The results can be used that instant to pass
+     * into the next transaction.
+     */
+    MoveCall: exports.PROGRAMMABLE_CALL,
+    /**
+     * Transfer vector of objects to a receiver.
+     */
+    TransferObjects: {
+        objects: [exports.VECTOR, exports.ARGUMENT],
+        address: exports.ARGUMENT,
+    },
+    /**
+     * Split `amount` from a `coin`.
+     */
+    SplitCoins: { coin: exports.ARGUMENT, amounts: [exports.VECTOR, exports.ARGUMENT] },
+    /**
+     * Merge Vector of Coins (`sources`) into a `destination`.
+     */
+    MergeCoins: { destination: exports.ARGUMENT, sources: [exports.VECTOR, exports.ARGUMENT] },
+    /**
+     * Publish a Move module.
+     */
+    Publish: {
+        modules: [exports.VECTOR, [exports.VECTOR, bcs_1.BCS.U8]],
+        dependencies: [exports.VECTOR, bcs_1.BCS.ADDRESS],
+    },
+    /**
+     * Build a vector of objects using the input arguments.
+     * It is impossible to construct a `vector<T: key>` otherwise,
+     * so this call serves a utility function.
+     */
+    MakeMoveVec: {
+        type: [exports.OPTION, exports.TYPE_TAG],
+        objects: [exports.VECTOR, exports.ARGUMENT],
+    },
+});
+/**
+ * Wrapper around Enum, which transforms any `T` into an object with `kind` property:
+ * @example
+ * ```
+ * let bcsEnum = { TransferObjects: { objects: [], address: ... } }
+ * // becomes
+ * let translatedEnum = { kind: 'TransferObjects', objects: [], address: ... };
+ * ```
+ */
+exports.builder.registerType([exports.ENUM_KIND, 'T'], function encode(writer, data, typeParams, typeMap) {
+    const kind = data.kind;
+    const invariant = { [kind]: data };
+    const [enumType] = typeParams;
+    return this.getTypeInterface(enumType)._encodeRaw.call(this, writer, invariant, typeParams, typeMap);
+}, function decode(reader, typeParams, typeMap) {
+    const [enumType] = typeParams;
+    const data = this.getTypeInterface(enumType)._decodeRaw.call(this, reader, typeParams, typeMap);
+    // enum invariant can only have one `key` field
+    const kind = Object.keys(data)[0];
+    return { kind, ...data[kind] };
+}, (data) => {
+    if (typeof data !== 'object' && !('kind' in data)) {
+        throw new Error(`EnumKind: Missing property "kind" in the input ${JSON.stringify(data)}`);
+    }
+    return true;
+});
+/**
+ * Custom deserializer for the ProgrammableCall.
+ *
+ * Hides the inner structure and gives a simpler, more convenient
+ * interface to encode and decode this struct as a part of `TransactionData`.
+ *
+ * - `(package)::(module)::(function)` are now `target` property.
+ * - `TypeTag[]` array is now passed as strings, not as a struct.
+ */
+exports.builder.registerType(exports.PROGRAMMABLE_CALL, function encodeProgrammableTx(writer, data, typeParams, typeMap) {
+    const [pkg, module, fun] = data.target.split('::');
+    const type_arguments = data.typeArguments.map((tag) => type_tag_serializer_1.TypeTagSerializer.parseFromStr(tag, true));
+    return this.getTypeInterface(exports.PROGRAMMABLE_CALL_INNER)._encodeRaw.call(this, writer, {
+        package: (0, common_1.normalizeSuiAddress)(pkg),
+        module,
+        function: fun,
+        type_arguments,
+        arguments: data.arguments,
+    }, typeParams, typeMap);
+}, function decodeProgrammableTx(reader, typeParams, typeMap) {
+    let data = exports.builder
+        .getTypeInterface(exports.PROGRAMMABLE_CALL_INNER)
+        ._decodeRaw.call(this, reader, typeParams, typeMap);
+    return {
+        target: [data.package, data.module, data.function].join('::'),
+        arguments: data.arguments,
+        typeArguments: data.type_arguments.map(type_tag_serializer_1.TypeTagSerializer.tagToString),
+    };
+}, 
+// Validation callback to error out if the data format is invalid.
+// TODO: make sure TypeTag can be parsed.
+(data) => {
+    return data.target.split('::').length === 3;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bcs.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/bcs.ts"],"names":[],"mappings":"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","sourcesContent":["import { BCS, TypeName } from '@mysten/bcs';\nimport { bcs, TypeTag } from '../types/sui-bcs';\nimport { normalizeSuiAddress } from '../types/common';\nimport { TypeTagSerializer } from '../txn-data-serializers/type-tag-serializer';\nimport { TransactionArgument, MoveCallTransaction } from './Transactions';\n\nexport const ARGUMENT_INNER = 'Argument';\nexport const VECTOR = 'vector';\nexport const OPTION = 'Option';\nexport const CALL_ARG = 'CallArg';\nexport const TYPE_TAG = 'TypeTag';\nexport const OBJECT_ARG = 'ObjectArg';\nexport const PROGRAMMABLE_TX_BLOCK = 'ProgrammableTransaction';\nexport const PROGRAMMABLE_CALL_INNER = 'ProgrammableMoveCall';\nexport const TRANSACTION_INNER = 'Transaction';\n\nexport const ENUM_KIND = 'EnumKind';\n\n/** Wrapper around transaction Enum to support `kind` matching in TS */\nexport const TRANSACTION: TypeName = [ENUM_KIND, TRANSACTION_INNER];\n/** Wrapper around Argument Enum to support `kind` matching in TS */\nexport const ARGUMENT: TypeName = [ENUM_KIND, ARGUMENT_INNER];\n\n/** Custom serializer for decoding package, module, function easier */\nexport const PROGRAMMABLE_CALL = 'SimpleProgrammableMoveCall';\n\n/** Transaction types */\n\nexport type Option<T> = { some: T } | { none: true };\n\nexport const builder = new BCS(bcs)\n  .registerStructType(PROGRAMMABLE_TX_BLOCK, {\n    inputs: [VECTOR, CALL_ARG],\n    transactions: [VECTOR, TRANSACTION],\n  })\n  .registerEnumType(ARGUMENT_INNER, {\n    GasCoin: null,\n    Input: { index: BCS.U16 },\n    Result: { index: BCS.U16 },\n    NestedResult: { index: BCS.U16, resultIndex: BCS.U16 },\n  })\n  .registerStructType(PROGRAMMABLE_CALL_INNER, {\n    package: BCS.ADDRESS,\n    module: BCS.STRING,\n    function: BCS.STRING,\n    type_arguments: [VECTOR, TYPE_TAG],\n    arguments: [VECTOR, ARGUMENT],\n  })\n  .registerEnumType(TRANSACTION_INNER, {\n    /**\n     * A Move Call - any public Move function can be called via\n     * this transaction. The results can be used that instant to pass\n     * into the next transaction.\n     */\n    MoveCall: PROGRAMMABLE_CALL,\n    /**\n     * Transfer vector of objects to a receiver.\n     */\n    TransferObjects: {\n      objects: [VECTOR, ARGUMENT],\n      address: ARGUMENT,\n    },\n    /**\n     * Split `amount` from a `coin`.\n     */\n    SplitCoins: { coin: ARGUMENT, amounts: [VECTOR, ARGUMENT] },\n    /**\n     * Merge Vector of Coins (`sources`) into a `destination`.\n     */\n    MergeCoins: { destination: ARGUMENT, sources: [VECTOR, ARGUMENT] },\n    /**\n     * Publish a Move module.\n     */\n    Publish: {\n      modules: [VECTOR, [VECTOR, BCS.U8]],\n      dependencies: [VECTOR, BCS.ADDRESS],\n    },\n    /**\n     * Build a vector of objects using the input arguments.\n     * It is impossible to construct a `vector<T: key>` otherwise,\n     * so this call serves a utility function.\n     */\n    MakeMoveVec: {\n      type: [OPTION, TYPE_TAG],\n      objects: [VECTOR, ARGUMENT],\n    },\n  });\n\n/**\n * Utilities for better decoding.\n */\n\ntype ProgrammableCallInner = {\n  package: string;\n  module: string;\n  function: string;\n  type_arguments: TypeTag[];\n  arguments: TransactionArgument[];\n};\n\n/**\n * Wrapper around Enum, which transforms any `T` into an object with `kind` property:\n * @example\n * ```\n * let bcsEnum = { TransferObjects: { objects: [], address: ... } }\n * // becomes\n * let translatedEnum = { kind: 'TransferObjects', objects: [], address: ... };\n * ```\n */\nbuilder.registerType(\n  [ENUM_KIND, 'T'],\n  function encode(this: BCS, writer, data: { kind: string }, typeParams, typeMap) {\n    const kind = data.kind;\n    const invariant = { [kind]: data };\n    const [enumType] = typeParams;\n\n    return this.getTypeInterface(enumType as string)._encodeRaw.call(this, writer, invariant, typeParams, typeMap);\n  },\n  function decode(this: BCS, reader, typeParams, typeMap) {\n    const [enumType] = typeParams;\n    const data = this.getTypeInterface(enumType as string)._decodeRaw.call(this, reader, typeParams, typeMap);\n\n    // enum invariant can only have one `key` field\n    const kind = Object.keys(data)[0];\n    return { kind, ...data[kind] };\n  },\n  (data: { kind: string }) => {\n    if (typeof data !== 'object' && !('kind' in data)) {\n      throw new Error(`EnumKind: Missing property \"kind\" in the input ${JSON.stringify(data)}`);\n    }\n\n    return true;\n  }\n);\n\n/**\n * Custom deserializer for the ProgrammableCall.\n *\n * Hides the inner structure and gives a simpler, more convenient\n * interface to encode and decode this struct as a part of `TransactionData`.\n *\n * - `(package)::(module)::(function)` are now `target` property.\n * - `TypeTag[]` array is now passed as strings, not as a struct.\n */\nbuilder.registerType(\n  PROGRAMMABLE_CALL,\n  function encodeProgrammableTx(this: BCS, writer, data: MoveCallTransaction, typeParams, typeMap) {\n    const [pkg, module, fun] = data.target.split('::');\n    const type_arguments = data.typeArguments.map((tag) => TypeTagSerializer.parseFromStr(tag, true));\n\n    return this.getTypeInterface(PROGRAMMABLE_CALL_INNER)._encodeRaw.call(\n      this,\n      writer,\n      {\n        package: normalizeSuiAddress(pkg),\n        module,\n        function: fun,\n        type_arguments,\n        arguments: data.arguments,\n      } as ProgrammableCallInner,\n      typeParams,\n      typeMap\n    );\n  },\n  function decodeProgrammableTx(this: BCS, reader, typeParams, typeMap) {\n    let data: ProgrammableCallInner = builder\n      .getTypeInterface(PROGRAMMABLE_CALL_INNER)\n      ._decodeRaw.call(this, reader, typeParams, typeMap);\n\n    return {\n      target: [data.package, data.module, data.function].join('::'),\n      arguments: data.arguments,\n      typeArguments: data.type_arguments.map(TypeTagSerializer.tagToString),\n    };\n  },\n  // Validation callback to error out if the data format is invalid.\n  // TODO: make sure TypeTag can be parsed.\n  (data: MoveCallTransaction) => {\n    return data.target.split('::').length === 3;\n  }\n);\n"]}

package/dist/src/lib/mystenlab/builder/index.d.ts

@@ -0,0 +1,5 @@
+export * from './TransactionBlock';
+export * from './Transactions';
+export * from './Inputs';
+export * from './bcs';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/mystenlab/builder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC"}

package/dist/src/lib/mystenlab/builder/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TransactionBlock"), exports);
+__exportStar(require("./Transactions"), exports);
+__exportStar(require("./Inputs"), exports);
+__exportStar(require("./bcs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL215c3RlbmxhYi9idWlsZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxREFBbUM7QUFDbkMsaURBQStCO0FBQy9CLDJDQUF5QjtBQUN6Qix3Q0FBc0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL1RyYW5zYWN0aW9uQmxvY2snO1xuZXhwb3J0ICogZnJvbSAnLi9UcmFuc2FjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9JbnB1dHMnO1xuZXhwb3J0ICogZnJvbSAnLi9iY3MnO1xuIl19

package/dist/src/lib/mystenlab/builder/serializer.d.ts

@@ -0,0 +1,4 @@
+import { SuiJsonValue, SuiMoveNormalizedType } from '../types';
+export declare function isTxContext(param: SuiMoveNormalizedType): boolean;
+export declare function getPureSerializationType(normalizedType: SuiMoveNormalizedType, argVal: SuiJsonValue | undefined): string | undefined;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/src/lib/mystenlab/builder/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,YAAY,EACZ,qBAAqB,EAEtB,MAAM,UAAU,CAAC;AAmClB,wBAAgB,WAAW,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAGjE;AAaD,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,qBAAqB,EACrC,MAAM,EAAE,YAAY,GAAG,SAAS,GAC/B,MAAM,GAAG,SAAS,CAuDpB"}

package/dist/src/lib/mystenlab/builder/serializer.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTxContext = isTxContext;
+exports.getPureSerializationType = getPureSerializationType;
+const types_1 = require("../types");
+const STD_ASCII_MODULE_NAME = 'ascii';
+const STD_ASCII_STRUCT_NAME = 'String';
+const STD_UTF8_MODULE_NAME = 'string';
+const STD_UTF8_STRUCT_NAME = 'String';
+const STD_OPTION_MODULE_NAME = 'option';
+const STD_OPTION_STRUCT_NAME = 'Option';
+const RESOLVED_SUI_ID = {
+    address: types_1.SUI_FRAMEWORK_ADDRESS,
+    module: types_1.OBJECT_MODULE_NAME,
+    name: types_1.ID_STRUCT_NAME,
+};
+const RESOLVED_ASCII_STR = {
+    address: types_1.MOVE_STDLIB_ADDRESS,
+    module: STD_ASCII_MODULE_NAME,
+    name: STD_ASCII_STRUCT_NAME,
+};
+const RESOLVED_UTF8_STR = {
+    address: types_1.MOVE_STDLIB_ADDRESS,
+    module: STD_UTF8_MODULE_NAME,
+    name: STD_UTF8_STRUCT_NAME,
+};
+const RESOLVED_STD_OPTION = {
+    address: types_1.MOVE_STDLIB_ADDRESS,
+    module: STD_OPTION_MODULE_NAME,
+    name: STD_OPTION_STRUCT_NAME,
+};
+const isSameStruct = (a, b) => a.address === b.address && a.module === b.module && a.name === b.name;
+function isTxContext(param) {
+    const struct = (0, types_1.extractStructTag)(param)?.Struct;
+    return struct?.address === '0x2' && struct?.module === 'tx_context' && struct?.name === 'TxContext';
+}
+function expectType(typeName, argVal) {
+    if (typeof argVal === 'undefined') {
+        return;
+    }
+    if (typeof argVal !== typeName) {
+        throw new Error(`Expect ${argVal} to be ${typeName}, received ${typeof argVal}`);
+    }
+}
+const allowedTypes = ['Address', 'Bool', 'U8', 'U16', 'U32', 'U64', 'U128', 'U256'];
+function getPureSerializationType(normalizedType, argVal) {
+    if (typeof normalizedType === 'string' && allowedTypes.includes(normalizedType)) {
+        if (normalizedType in ['U8', 'U16', 'U32', 'U64', 'U128', 'U256']) {
+            expectType('number', argVal);
+        }
+        else if (normalizedType === 'Bool') {
+            expectType('boolean', argVal);
+        }
+        else if (normalizedType === 'Address') {
+            expectType('string', argVal);
+            if (argVal && !(0, types_1.isValidSuiAddress)(argVal)) {
+                throw new Error('Invalid Sui Address');
+            }
+        }
+        return normalizedType.toLowerCase();
+    }
+    else if (typeof normalizedType === 'string') {
+        throw new Error(`Unknown pure normalized type ${JSON.stringify(normalizedType, null, 2)}`);
+    }
+    if ('Vector' in normalizedType) {
+        if ((argVal === undefined || typeof argVal === 'string') && normalizedType.Vector === 'U8') {
+            return 'string';
+        }
+        if (argVal !== undefined && !Array.isArray(argVal)) {
+            throw new Error(`Expect ${argVal} to be a array, received ${typeof argVal}`);
+        }
+        const innerType = getPureSerializationType(normalizedType.Vector, 
+        // undefined when argVal is empty
+        argVal ? argVal[0] : undefined);
+        if (innerType === undefined) {
+            return;
+        }
+        return `vector<${innerType}>`;
+    }
+    if ('Struct' in normalizedType) {
+        if (isSameStruct(normalizedType.Struct, RESOLVED_ASCII_STR)) {
+            return 'string';
+        }
+        else if (isSameStruct(normalizedType.Struct, RESOLVED_UTF8_STR)) {
+            return 'utf8string';
+        }
+        else if (isSameStruct(normalizedType.Struct, RESOLVED_SUI_ID)) {
+            return 'address';
+        }
+        else if (isSameStruct(normalizedType.Struct, RESOLVED_STD_OPTION)) {
+            const optionToVec = {
+                Vector: normalizedType.Struct.typeArguments[0],
+            };
+            return getPureSerializationType(optionToVec, argVal);
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serializer.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/serializer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  extractStructTag,\n  ID_STRUCT_NAME,\n  isValidSuiAddress,\n  MOVE_STDLIB_ADDRESS,\n  OBJECT_MODULE_NAME,\n  SuiJsonValue,\n  SuiMoveNormalizedType,\n  SUI_FRAMEWORK_ADDRESS,\n} from '../types';\n\nconst STD_ASCII_MODULE_NAME = 'ascii';\nconst STD_ASCII_STRUCT_NAME = 'String';\n\nconst STD_UTF8_MODULE_NAME = 'string';\nconst STD_UTF8_STRUCT_NAME = 'String';\n\nconst STD_OPTION_MODULE_NAME = 'option';\nconst STD_OPTION_STRUCT_NAME = 'Option';\n\nconst RESOLVED_SUI_ID = {\n  address: SUI_FRAMEWORK_ADDRESS,\n  module: OBJECT_MODULE_NAME,\n  name: ID_STRUCT_NAME,\n};\nconst RESOLVED_ASCII_STR = {\n  address: MOVE_STDLIB_ADDRESS,\n  module: STD_ASCII_MODULE_NAME,\n  name: STD_ASCII_STRUCT_NAME,\n};\nconst RESOLVED_UTF8_STR = {\n  address: MOVE_STDLIB_ADDRESS,\n  module: STD_UTF8_MODULE_NAME,\n  name: STD_UTF8_STRUCT_NAME,\n};\n\nconst RESOLVED_STD_OPTION = {\n  address: MOVE_STDLIB_ADDRESS,\n  module: STD_OPTION_MODULE_NAME,\n  name: STD_OPTION_STRUCT_NAME,\n};\n\nconst isSameStruct = (a: any, b: any) => a.address === b.address && a.module === b.module && a.name === b.name;\n\nexport function isTxContext(param: SuiMoveNormalizedType): boolean {\n  const struct = extractStructTag(param)?.Struct;\n  return struct?.address === '0x2' && struct?.module === 'tx_context' && struct?.name === 'TxContext';\n}\n\nfunction expectType(typeName: string, argVal?: SuiJsonValue) {\n  if (typeof argVal === 'undefined') {\n    return;\n  }\n  if (typeof argVal !== typeName) {\n    throw new Error(`Expect ${argVal} to be ${typeName}, received ${typeof argVal}`);\n  }\n}\n\nconst allowedTypes = ['Address', 'Bool', 'U8', 'U16', 'U32', 'U64', 'U128', 'U256'];\n\nexport function getPureSerializationType(\n  normalizedType: SuiMoveNormalizedType,\n  argVal: SuiJsonValue | undefined\n): string | undefined {\n  if (typeof normalizedType === 'string' && allowedTypes.includes(normalizedType)) {\n    if (normalizedType in ['U8', 'U16', 'U32', 'U64', 'U128', 'U256']) {\n      expectType('number', argVal);\n    } else if (normalizedType === 'Bool') {\n      expectType('boolean', argVal);\n    } else if (normalizedType === 'Address') {\n      expectType('string', argVal);\n      if (argVal && !isValidSuiAddress(argVal as string)) {\n        throw new Error('Invalid Sui Address');\n      }\n    }\n    return normalizedType.toLowerCase();\n  } else if (typeof normalizedType === 'string') {\n    throw new Error(`Unknown pure normalized type ${JSON.stringify(normalizedType, null, 2)}`);\n  }\n\n  if ('Vector' in normalizedType) {\n    if ((argVal === undefined || typeof argVal === 'string') && normalizedType.Vector === 'U8') {\n      return 'string';\n    }\n\n    if (argVal !== undefined && !Array.isArray(argVal)) {\n      throw new Error(`Expect ${argVal} to be a array, received ${typeof argVal}`);\n    }\n\n    const innerType = getPureSerializationType(\n      normalizedType.Vector,\n      // undefined when argVal is empty\n      argVal ? argVal[0] : undefined\n    );\n\n    if (innerType === undefined) {\n      return;\n    }\n\n    return `vector<${innerType}>`;\n  }\n\n  if ('Struct' in normalizedType) {\n    if (isSameStruct(normalizedType.Struct, RESOLVED_ASCII_STR)) {\n      return 'string';\n    } else if (isSameStruct(normalizedType.Struct, RESOLVED_UTF8_STR)) {\n      return 'utf8string';\n    } else if (isSameStruct(normalizedType.Struct, RESOLVED_SUI_ID)) {\n      return 'address';\n    } else if (isSameStruct(normalizedType.Struct, RESOLVED_STD_OPTION)) {\n      const optionToVec: SuiMoveNormalizedType = {\n        Vector: normalizedType.Struct.typeArguments[0],\n      };\n      return getPureSerializationType(optionToVec, argVal);\n    }\n  }\n\n  return undefined;\n}\n"]}

package/dist/src/lib/mystenlab/builder/utils.d.ts

@@ -0,0 +1,10 @@
+import { Struct } from 'superstruct';
+export declare function create<T, S>(value: T, struct: Struct<T, S>): T;
+export type WellKnownEncoding = {
+    kind: 'object';
+} | {
+    kind: 'pure';
+    type: string;
+};
+export declare const TRANSACTION_TYPE: unique symbol;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/lib/mystenlab/builder/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,MAAM,EAAE,MAAM,aAAa,CAAC;AAElE,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAE9D;AAED,MAAM,MAAM,iBAAiB,GACzB;IACE,IAAI,EAAE,QAAQ,CAAC;CAChB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN,eAAO,MAAM,gBAAgB,eAAsC,CAAC"}

package/dist/src/lib/mystenlab/builder/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSACTION_TYPE = void 0;
+exports.create = create;
+const superstruct_1 = require("superstruct");
+function create(value, struct) {
+    return (0, superstruct_1.create)(value, struct);
+}
+exports.TRANSACTION_TYPE = Symbol('transaction-argument-type');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL215c3RlbmxhYi9idWlsZGVyL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLHdCQUVDO0FBSkQsNkNBQWtFO0FBRWxFLFNBQWdCLE1BQU0sQ0FBTyxLQUFRLEVBQUUsTUFBb0I7SUFDekQsT0FBTyxJQUFBLG9CQUFpQixFQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsQ0FBQztBQUMxQyxDQUFDO0FBV1ksUUFBQSxnQkFBZ0IsR0FBRyxNQUFNLENBQUMsMkJBQTJCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNyZWF0ZSBhcyBzdXBlcnN0cnVjdENyZWF0ZSwgU3RydWN0IH0gZnJvbSAnc3VwZXJzdHJ1Y3QnO1xuXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlPFQsIFM+KHZhbHVlOiBULCBzdHJ1Y3Q6IFN0cnVjdDxULCBTPik6IFQge1xuICByZXR1cm4gc3VwZXJzdHJ1Y3RDcmVhdGUodmFsdWUsIHN0cnVjdCk7XG59XG5cbmV4cG9ydCB0eXBlIFdlbGxLbm93bkVuY29kaW5nID1cbiAgfCB7XG4gICAgICBraW5kOiAnb2JqZWN0JztcbiAgICB9XG4gIHwge1xuICAgICAga2luZDogJ3B1cmUnO1xuICAgICAgdHlwZTogc3RyaW5nO1xuICAgIH07XG5cbmV4cG9ydCBjb25zdCBUUkFOU0FDVElPTl9UWVBFID0gU3ltYm9sKCd0cmFuc2FjdGlvbi1hcmd1bWVudC10eXBlJyk7XG4iXX0=

package/dist/src/lib/mystenlab/cryptography/hash.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a Blake2b hash of typed data as a base64 string.
+ *
+ * @param typeTag type tag (e.g. TransactionData, SenderSignedData)
+ * @param data data to hash
+ */
+export declare function hashTypedData(typeTag: string, data: Uint8Array): Uint8Array;
+//# sourceMappingURL=hash.d.ts.map

package/dist/src/lib/mystenlab/cryptography/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/cryptography/hash.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAQ3E"}

package/dist/src/lib/mystenlab/cryptography/hash.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashTypedData = hashTypedData;
+const blake2b_1 = __importDefault(require("@bitgo-beta/blake2b"));
+/**
+ * Generates a Blake2b hash of typed data as a base64 string.
+ *
+ * @param typeTag type tag (e.g. TransactionData, SenderSignedData)
+ * @param data data to hash
+ */
+function hashTypedData(typeTag, data) {
+    const typeTagBytes = Array.from(`${typeTag}::`).map((e) => e.charCodeAt(0));
+    const dataWithTag = new Uint8Array(typeTagBytes.length + data.length);
+    dataWithTag.set(typeTagBytes);
+    dataWithTag.set(data, typeTagBytes.length);
+    return (0, blake2b_1.default)(32).update(dataWithTag).digest('binary');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvbXlzdGVubGFiL2NyeXB0b2dyYXBoeS9oYXNoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBUUEsc0NBUUM7QUFoQkQsa0VBQTBDO0FBRTFDOzs7OztHQUtHO0FBQ0gsU0FBZ0IsYUFBYSxDQUFDLE9BQWUsRUFBRSxJQUFnQjtJQUM3RCxNQUFNLFlBQVksR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLEdBQUcsT0FBTyxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUU1RSxNQUFNLFdBQVcsR0FBRyxJQUFJLFVBQVUsQ0FBQyxZQUFZLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUN0RSxXQUFXLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzlCLFdBQVcsQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUUzQyxPQUFPLElBQUEsaUJBQU8sRUFBQyxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBQzFELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgYmxha2UyYiBmcm9tICdAYml0Z28tYmV0YS9ibGFrZTJiJztcblxuLyoqXG4gKiBHZW5lcmF0ZXMgYSBCbGFrZTJiIGhhc2ggb2YgdHlwZWQgZGF0YSBhcyBhIGJhc2U2NCBzdHJpbmcuXG4gKlxuICogQHBhcmFtIHR5cGVUYWcgdHlwZSB0YWcgKGUuZy4gVHJhbnNhY3Rpb25EYXRhLCBTZW5kZXJTaWduZWREYXRhKVxuICogQHBhcmFtIGRhdGEgZGF0YSB0byBoYXNoXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBoYXNoVHlwZWREYXRhKHR5cGVUYWc6IHN0cmluZywgZGF0YTogVWludDhBcnJheSk6IFVpbnQ4QXJyYXkge1xuICBjb25zdCB0eXBlVGFnQnl0ZXMgPSBBcnJheS5mcm9tKGAke3R5cGVUYWd9OjpgKS5tYXAoKGUpID0+IGUuY2hhckNvZGVBdCgwKSk7XG5cbiAgY29uc3QgZGF0YVdpdGhUYWcgPSBuZXcgVWludDhBcnJheSh0eXBlVGFnQnl0ZXMubGVuZ3RoICsgZGF0YS5sZW5ndGgpO1xuICBkYXRhV2l0aFRhZy5zZXQodHlwZVRhZ0J5dGVzKTtcbiAgZGF0YVdpdGhUYWcuc2V0KGRhdGEsIHR5cGVUYWdCeXRlcy5sZW5ndGgpO1xuXG4gIHJldHVybiBibGFrZTJiKDMyKS51cGRhdGUoZGF0YVdpdGhUYWcpLmRpZ2VzdCgnYmluYXJ5Jyk7XG59XG4iXX0=