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