PHP WebShell
Текущая директория: /usr/lib/node_modules/bitgo/node_modules/@iota/iota-sdk/dist/cjs/bcs
Просмотр файла: bcs.js
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var bcs_exports = {};
__export(bcs_exports, {
Address: () => Address,
AppId: () => AppId,
Argument: () => Argument,
CallArg: () => CallArg,
Command: () => Command,
CompressedSignature: () => CompressedSignature,
GasData: () => GasData,
Intent: () => Intent,
IntentMessage: () => IntentMessage,
IntentScope: () => IntentScope,
IntentVersion: () => IntentVersion,
IotaObjectRef: () => IotaObjectRef,
MultiSig: () => MultiSig,
MultiSigPkMap: () => MultiSigPkMap,
MultiSigPublicKey: () => MultiSigPublicKey,
ObjectArg: () => ObjectArg,
ObjectDigest: () => ObjectDigest,
Owner: () => Owner,
PasskeyAuthenticator: () => PasskeyAuthenticator,
ProgrammableMoveCall: () => ProgrammableMoveCall,
ProgrammableTransaction: () => ProgrammableTransaction,
PublicKey: () => PublicKey,
SenderSignedData: () => SenderSignedData,
SenderSignedTransaction: () => SenderSignedTransaction,
SharedObjectRef: () => SharedObjectRef,
StructTag: () => StructTag,
TransactionData: () => TransactionData,
TransactionDataV1: () => TransactionDataV1,
TransactionExpiration: () => TransactionExpiration,
TransactionKind: () => TransactionKind,
TypeTag: () => TypeTag,
base64String: () => base64String
});
module.exports = __toCommonJS(bcs_exports);
var import_bcs = require("@iota/bcs");
var import_iota_types = require("../utils/iota-types.js");
var import_type_tag_serializer = require("./type-tag-serializer.js");
function unsafe_u64(options) {
return import_bcs.bcs.u64({
name: "unsafe_u64",
...options
}).transform({
input: (val) => val,
output: (val) => Number(val)
});
}
function optionEnum(type) {
return import_bcs.bcs.enum("Option", {
None: null,
Some: type
});
}
const Address = import_bcs.bcs.bytes(import_iota_types.IOTA_ADDRESS_LENGTH).transform({
validate: (val) => {
const address = typeof val === "string" ? val : (0, import_bcs.toHex)(val);
if (!address || !(0, import_iota_types.isValidIotaAddress)((0, import_iota_types.normalizeIotaAddress)(address))) {
throw new Error(`Invalid IOTA address ${address}`);
}
},
input: (val) => typeof val === "string" ? (0, import_bcs.fromHex)((0, import_iota_types.normalizeIotaAddress)(val)) : val,
output: (val) => (0, import_iota_types.normalizeIotaAddress)((0, import_bcs.toHex)(val))
});
const ObjectDigest = import_bcs.bcs.vector(import_bcs.bcs.u8()).transform({
name: "ObjectDigest",
input: (value) => (0, import_bcs.fromBase58)(value),
output: (value) => (0, import_bcs.toBase58)(new Uint8Array(value)),
validate: (value) => {
if ((0, import_bcs.fromBase58)(value).length !== 32) {
throw new Error("ObjectDigest must be 32 bytes");
}
}
});
const IotaObjectRef = import_bcs.bcs.struct("IotaObjectRef", {
objectId: Address,
version: import_bcs.bcs.u64(),
digest: ObjectDigest
});
const SharedObjectRef = import_bcs.bcs.struct("SharedObjectRef", {
objectId: Address,
initialSharedVersion: import_bcs.bcs.u64(),
mutable: import_bcs.bcs.bool()
});
const ObjectArg = import_bcs.bcs.enum("ObjectArg", {
ImmOrOwnedObject: IotaObjectRef,
SharedObject: SharedObjectRef,
Receiving: IotaObjectRef
});
const Owner = import_bcs.bcs.enum("Owner", {
AddressOwner: Address,
ObjectOwner: Address,
Shared: import_bcs.bcs.struct("Shared", {
initialSharedVersion: import_bcs.bcs.u64()
}),
Immutable: null
});
const CallArg = import_bcs.bcs.enum("CallArg", {
Pure: import_bcs.bcs.struct("Pure", {
bytes: import_bcs.bcs.vector(import_bcs.bcs.u8()).transform({
input: (val) => typeof val === "string" ? (0, import_bcs.fromBase64)(val) : val,
output: (val) => (0, import_bcs.toBase64)(new Uint8Array(val))
})
}),
Object: ObjectArg
});
const InnerTypeTag = import_bcs.bcs.enum("TypeTag", {
bool: null,
u8: null,
u64: null,
u128: null,
address: null,
signer: null,
vector: import_bcs.bcs.lazy(() => InnerTypeTag),
struct: import_bcs.bcs.lazy(() => StructTag),
u16: null,
u32: null,
u256: null
});
const TypeTag = InnerTypeTag.transform({
input: (typeTag) => typeof typeTag === "string" ? import_type_tag_serializer.TypeTagSerializer.parseFromStr(typeTag, true) : typeTag,
output: (typeTag) => import_type_tag_serializer.TypeTagSerializer.tagToString(typeTag)
});
const Argument = import_bcs.bcs.enum("Argument", {
GasCoin: null,
Input: import_bcs.bcs.u16(),
Result: import_bcs.bcs.u16(),
NestedResult: import_bcs.bcs.tuple([import_bcs.bcs.u16(), import_bcs.bcs.u16()])
});
const ProgrammableMoveCall = import_bcs.bcs.struct("ProgrammableMoveCall", {
package: Address,
module: import_bcs.bcs.string(),
function: import_bcs.bcs.string(),
typeArguments: import_bcs.bcs.vector(TypeTag),
arguments: import_bcs.bcs.vector(Argument)
});
const Command = import_bcs.bcs.enum("Command", {
/**
* 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: ProgrammableMoveCall,
/**
* Transfer vector of objects to a receiver.
*/
TransferObjects: import_bcs.bcs.struct("TransferObjects", {
objects: import_bcs.bcs.vector(Argument),
address: Argument
}),
// /**
// * Split `amount` from a `coin`.
// */
SplitCoins: import_bcs.bcs.struct("SplitCoins", {
coin: Argument,
amounts: import_bcs.bcs.vector(Argument)
}),
// /**
// * Merge Vector of Coins (`sources`) into a `destination`.
// */
MergeCoins: import_bcs.bcs.struct("MergeCoins", {
destination: Argument,
sources: import_bcs.bcs.vector(Argument)
}),
// /**
// * Publish a Move module.
// */
Publish: import_bcs.bcs.struct("Publish", {
modules: import_bcs.bcs.vector(
import_bcs.bcs.vector(import_bcs.bcs.u8()).transform({
input: (val) => typeof val === "string" ? (0, import_bcs.fromBase64)(val) : val,
output: (val) => (0, import_bcs.toBase64)(new Uint8Array(val))
})
),
dependencies: import_bcs.bcs.vector(Address)
}),
// /**
// * Build a vector of objects using the input arguments.
// * It is impossible to export construct a `vector<T: key>` otherwise,
// * so this call serves a utility function.
// */
MakeMoveVec: import_bcs.bcs.struct("MakeMoveVec", {
type: optionEnum(TypeTag).transform({
input: (val) => val === null ? {
None: true
} : {
Some: val
},
output: (val) => val.Some ?? null
}),
elements: import_bcs.bcs.vector(Argument)
}),
Upgrade: import_bcs.bcs.struct("Upgrade", {
modules: import_bcs.bcs.vector(
import_bcs.bcs.vector(import_bcs.bcs.u8()).transform({
input: (val) => typeof val === "string" ? (0, import_bcs.fromBase64)(val) : val,
output: (val) => (0, import_bcs.toBase64)(new Uint8Array(val))
})
),
dependencies: import_bcs.bcs.vector(Address),
package: Address,
ticket: Argument
})
});
const ProgrammableTransaction = import_bcs.bcs.struct("ProgrammableTransaction", {
inputs: import_bcs.bcs.vector(CallArg),
commands: import_bcs.bcs.vector(Command)
});
const TransactionKind = import_bcs.bcs.enum("TransactionKind", {
ProgrammableTransaction,
ChangeEpoch: null,
Genesis: null,
ConsensusCommitPrologue: null
});
const TransactionExpiration = import_bcs.bcs.enum("TransactionExpiration", {
None: null,
Epoch: unsafe_u64()
});
const StructTag = import_bcs.bcs.struct("StructTag", {
address: Address,
module: import_bcs.bcs.string(),
name: import_bcs.bcs.string(),
typeParams: import_bcs.bcs.vector(InnerTypeTag)
});
const GasData = import_bcs.bcs.struct("GasData", {
payment: import_bcs.bcs.vector(IotaObjectRef),
owner: Address,
price: import_bcs.bcs.u64(),
budget: import_bcs.bcs.u64()
});
const TransactionDataV1 = import_bcs.bcs.struct("TransactionDataV1", {
kind: TransactionKind,
sender: Address,
gasData: GasData,
expiration: TransactionExpiration
});
const TransactionData = import_bcs.bcs.enum("TransactionData", {
V1: TransactionDataV1
});
const IntentScope = import_bcs.bcs.enum("IntentScope", {
TransactionData: null,
TransactionEffects: null,
CheckpointSummary: null,
PersonalMessage: null
});
const IntentVersion = import_bcs.bcs.enum("IntentVersion", {
V0: null
});
const AppId = import_bcs.bcs.enum("AppId", {
Iota: null
});
const Intent = import_bcs.bcs.struct("Intent", {
scope: IntentScope,
version: IntentVersion,
appId: AppId
});
function IntentMessage(T) {
return import_bcs.bcs.struct(`IntentMessage<${T.name}>`, {
intent: Intent,
value: T
});
}
const CompressedSignature = import_bcs.bcs.enum("CompressedSignature", {
ED25519: import_bcs.bcs.fixedArray(64, import_bcs.bcs.u8()),
Secp256k1: import_bcs.bcs.fixedArray(64, import_bcs.bcs.u8()),
Secp256r1: import_bcs.bcs.fixedArray(64, import_bcs.bcs.u8())
});
const PublicKey = import_bcs.bcs.enum("PublicKey", {
ED25519: import_bcs.bcs.fixedArray(32, import_bcs.bcs.u8()),
Secp256k1: import_bcs.bcs.fixedArray(33, import_bcs.bcs.u8()),
Secp256r1: import_bcs.bcs.fixedArray(33, import_bcs.bcs.u8())
});
const MultiSigPkMap = import_bcs.bcs.struct("MultiSigPkMap", {
pubKey: PublicKey,
weight: import_bcs.bcs.u8()
});
const MultiSigPublicKey = import_bcs.bcs.struct("MultiSigPublicKey", {
pk_map: import_bcs.bcs.vector(MultiSigPkMap),
threshold: import_bcs.bcs.u16()
});
const MultiSig = import_bcs.bcs.struct("MultiSig", {
sigs: import_bcs.bcs.vector(CompressedSignature),
bitmap: import_bcs.bcs.u16(),
multisig_pk: MultiSigPublicKey
});
const base64String = import_bcs.bcs.vector(import_bcs.bcs.u8()).transform({
input: (val) => typeof val === "string" ? (0, import_bcs.fromBase64)(val) : val,
output: (val) => (0, import_bcs.toBase64)(new Uint8Array(val))
});
const SenderSignedTransaction = import_bcs.bcs.struct("SenderSignedTransaction", {
intentMessage: IntentMessage(TransactionData),
txSignatures: import_bcs.bcs.vector(base64String)
});
const SenderSignedData = import_bcs.bcs.vector(SenderSignedTransaction, {
name: "SenderSignedData"
});
const PasskeyAuthenticator = import_bcs.bcs.struct("PasskeyAuthenticator", {
authenticatorData: import_bcs.bcs.vector(import_bcs.bcs.u8()),
clientDataJson: import_bcs.bcs.string(),
userSignature: import_bcs.bcs.vector(import_bcs.bcs.u8())
});
//# sourceMappingURL=bcs.js.map
Выполнить команду
Для локальной разработки. Не используйте в интернете!