@xyo-network/xl1-rpc 1.16.22 → 1.16.24

package/dist/node/types/schema/common/Permission.d.ts

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-export declare const CaveatTypesZod: z.ZodEnum<{
-    chain: "chain";
-    expiration: "expiration";
-    filteredResponse: "filteredResponse";
-    rateLimit: "rateLimit";
-    restrictReturnedAccounts: "restrictReturnedAccounts";
-}>;
-export declare const CaveatsZod: z.ZodObject<{
-    type: z.ZodEnum<{
-        chain: "chain";
-        expiration: "expiration";
-        filteredResponse: "filteredResponse";
-        rateLimit: "rateLimit";
-        restrictReturnedAccounts: "restrictReturnedAccounts";
-    }>;
-    value: z.ZodJSONSchema;
-}, z.core.$strip>;
-export declare const PermissionZod: z.ZodObject<{
-    parentCapability: z.ZodString;
-    caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            chain: "chain";
-            expiration: "expiration";
-            filteredResponse: "filteredResponse";
-            rateLimit: "rateLimit";
-            restrictReturnedAccounts: "restrictReturnedAccounts";
-        }>;
-        value: z.ZodJSONSchema;
-    }, z.core.$strip>>>;
-    invoker: z.ZodString;
-}, z.core.$strip>;
-export declare const InvokerPermissionZod: z.ZodObject<{
-    parentCapability: z.ZodString;
-    caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            chain: "chain";
-            expiration: "expiration";
-            filteredResponse: "filteredResponse";
-            rateLimit: "rateLimit";
-            restrictReturnedAccounts: "restrictReturnedAccounts";
-        }>;
-        value: z.ZodJSONSchema;
-    }, z.core.$strip>>>;
-    invoker: z.ZodString;
-    date: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const PermissionRequestZod: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
-export declare const RequestedPermissionZod: z.ZodObject<{
-    parentCapability: z.ZodString;
-    date: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-//# sourceMappingURL=Permission.d.ts.map

package/dist/node/types/schema/common/Permission.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Permission.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,cAAc;;;;;;EAA+F,CAAA;AAE1H,eAAO,MAAM,UAAU;;;;;;;;;iBAGrB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;iBAIxB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;iBAAwD,CAAA;AAEzF,eAAO,MAAM,oBAAoB,8DAAsD,CAAA;AAEvF,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAA"}

package/dist/node/types/schema/common/RewardsRangeOptions.d.ts

@@ -1,11 +0,0 @@
-import { z } from 'zod';
-export declare const RewardsRangeOptionsZod: z.ZodObject<{
-    positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
-    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
-        step: z.ZodNumber;
-    }, z.core.$strip>>>;
-    stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
-}, z.core.$strip>;
-//# sourceMappingURL=RewardsRangeOptions.d.ts.map

package/dist/node/types/schema/common/RewardsRangeOptions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RewardsRangeOptions.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/RewardsRangeOptions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,sBAAsB;;;;;;;;iBAKjC,CAAA"}

package/dist/node/types/schema/common/Sequence.d.ts

@@ -1,9 +0,0 @@
-import type { LocalSequence, QualifiedSequence } from '@xyo-network/payload-model';
-import * as z from 'zod';
-export declare const LocalSequenceToStringZod: z.ZodString;
-export declare const LocalSequenceFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<LocalSequence, string>>;
-export declare const QualifiedSequenceToStringZod: z.ZodString;
-export declare const QualifiedSequenceFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<QualifiedSequence, string>>;
-export declare const SequenceToStringZod: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
-export declare const SequenceFromStringZod: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<QualifiedSequence, string>>]>;
-//# sourceMappingURL=Sequence.d.ts.map

package/dist/node/types/schema/common/Sequence.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sequence.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Sequence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAElF,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,eAAO,MAAM,wBAAwB,aAAuC,CAAA;AAC5E,eAAO,MAAM,0BAA0B,+DAAgG,CAAA;AAGvI,eAAO,MAAM,4BAA4B,aAA2C,CAAA;AACpF,eAAO,MAAM,8BAA8B,mEAA4G,CAAA;AAEvJ,eAAO,MAAM,mBAAmB,iDAAoE,CAAA;AACpG,eAAO,MAAM,qBAAqB,yJAAwE,CAAA"}

package/dist/node/types/schema/common/Stake.d.ts

@@ -1,62 +0,0 @@
-import type { PositionId } from '@xyo-network/xl1-protocol';
-import * as z from 'zod';
-export declare const StakeZod: z.ZodObject<{
-    amount: z.ZodBigInt;
-    addBlock: z.ZodNumber;
-    id: z.ZodNumber;
-    removeBlock: z.ZodNumber;
-    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
-    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
-    withdrawBlock: z.ZodNumber;
-}, z.core.$strip>;
-export declare const StakeToJsonZod: z.ZodPipe<z.ZodObject<{
-    amount: z.ZodBigInt;
-    addBlock: z.ZodNumber;
-    id: z.ZodNumber;
-    removeBlock: z.ZodNumber;
-    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
-    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
-    withdrawBlock: z.ZodNumber;
-}, z.core.$strip>, z.ZodTransform<{
-    addBlock: number;
-    amount: import("@xylabs/sdk-js").Hex;
-    id: number;
-    removeBlock: number;
-    staked: import("@xylabs/sdk-js").Address;
-    staker: import("@xylabs/sdk-js").Address;
-    withdrawBlock: number;
-}, {
-    amount: bigint;
-    addBlock: number;
-    id: number;
-    removeBlock: number;
-    staked: import("@xylabs/sdk-js").Address;
-    staker: import("@xylabs/sdk-js").Address;
-    withdrawBlock: number;
-}>>;
-export declare const JsonToStakeZod: z.ZodPipe<z.ZodObject<{
-    addBlock: z.ZodNumber;
-    id: z.ZodNumber;
-    removeBlock: z.ZodNumber;
-    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
-    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
-    withdrawBlock: z.ZodNumber;
-    amount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-}, z.core.$strip>, z.ZodTransform<{
-    addBlock: number;
-    amount: import("@xyo-network/xl1-protocol").AttoXL1;
-    id: PositionId;
-    removeBlock: number;
-    staked: import("@xylabs/sdk-js").Address;
-    staker: import("@xylabs/sdk-js").Address;
-    withdrawBlock: number;
-}, {
-    addBlock: number;
-    id: number;
-    removeBlock: number;
-    staked: import("@xylabs/sdk-js").Address;
-    staker: import("@xylabs/sdk-js").Address;
-    withdrawBlock: number;
-    amount: import("@xylabs/sdk-js").Hex;
-}>>;
-//# sourceMappingURL=Stake.d.ts.map

package/dist/node/types/schema/common/Stake.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Stake.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Stake.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,QAAQ;;;;;;;;iBAcnB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;GAQxB,CAAA;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;QAGX,UAAU;;;;;;;;;;;;;GAKvB,CAAA"}

package/dist/node/types/schema/common/TimeDomain.d.ts

@@ -1,3 +0,0 @@
-import * as z from 'zod';
-export declare const TimeDomainZod: z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>;
-//# sourceMappingURL=TimeDomain.d.ts.map

package/dist/node/types/schema/common/TimeDomain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TimeDomain.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TimeDomain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,aAAa,6FAIxB,CAAA"}

package/dist/node/types/schema/common/TransactionBoundWitness.d.ts

@@ -1,75 +0,0 @@
-import * as z from 'zod';
-export declare const BlockStartZod: z.ZodObject<{
-    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-}, z.core.$strip>;
-export declare const BlockEndZod: z.ZodObject<{
-    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-}, z.core.$strip>;
-export declare const BlockDurationZod: z.ZodObject<{
-    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-}, z.core.$strip>;
-export declare const BlockScriptsZod: z.ZodObject<{
-    script: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const WithTransactionFeesZod: z.ZodObject<{
-    fees: z.ZodObject<{
-        base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const TransactionBoundWitnessZod: z.ZodObject<{
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
-    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
-        __schema: true;
-    }, string>>]>>;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
-    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-    fees: z.ZodObject<{
-        base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-    }, z.core.$strip>;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
-    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
-    script: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const SignedTransactionBoundWitnessZod: z.ZodObject<{
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
-    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
-        __schema: true;
-    }, string>>]>>;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
-    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-    fees: z.ZodObject<{
-        base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-        priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
-    }, z.core.$strip>;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
-    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
-    script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-}, z.core.$strip>;
-//# sourceMappingURL=TransactionBoundWitness.d.ts.map

package/dist/node/types/schema/common/TransactionBoundWitness.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,aAAa;;iBAAoC,CAAA;AAC9D,eAAO,MAAM,WAAW;;iBAAoC,CAAA;AAC5D,eAAO,MAAM,gBAAgB;;;iBAAyD,CAAA;AACtF,eAAO,MAAM,eAAe;;iBAAuD,CAAA;AAEnF,eAAO,MAAM,sBAAsB;;;;;;;iBAA4C,CAAA;AAM/E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;iBAUd,CAAA;AAEzB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;iBAUV,CAAA"}

package/dist/node/types/schema/common/TransactionFees.d.ts

@@ -1,53 +0,0 @@
-import * as z from 'zod';
-export declare const AttoZod: z.ZodBigInt;
-export declare const JsonToAttoZod: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-export declare const AttoToJsonZod: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-export declare const TransactionFeesHexZod: z.ZodObject<{
-    base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-    gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-    gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-    priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-}, z.core.$strip>;
-export type TransactionFeesHexZodType = z.infer<typeof TransactionFeesHexZod>;
-export declare const TransactionFeesBigIntZod: z.ZodObject<{
-    base: z.ZodBigInt;
-    gasLimit: z.ZodBigInt;
-    gasPrice: z.ZodBigInt;
-    priority: z.ZodBigInt;
-}, z.core.$strip>;
-export type TransactionFeesBigIntZodType = z.infer<typeof TransactionFeesBigIntZod>;
-export declare const TransactionFeesJsonToBigIntZod: z.ZodPipe<z.ZodObject<{
-    base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-    gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-    gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-    priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-}, z.core.$strip>, z.ZodTransform<{
-    base: bigint;
-    gasLimit: bigint;
-    gasPrice: bigint;
-    priority: bigint;
-}, {
-    base: import("@xylabs/sdk-js").Hex;
-    gasLimit: import("@xylabs/sdk-js").Hex;
-    gasPrice: import("@xylabs/sdk-js").Hex;
-    priority: import("@xylabs/sdk-js").Hex;
-}>>;
-export declare const TransactionFeesBigIntToJsonZod: z.ZodPipe<z.ZodObject<{
-    base: z.ZodBigInt;
-    gasLimit: z.ZodBigInt;
-    gasPrice: z.ZodBigInt;
-    priority: z.ZodBigInt;
-}, z.core.$strip>, z.ZodTransform<{
-    base: import("@xylabs/sdk-js").Hex;
-    gasLimit: import("@xylabs/sdk-js").Hex;
-    gasPrice: import("@xylabs/sdk-js").Hex;
-    priority: import("@xylabs/sdk-js").Hex;
-}, {
-    base: bigint;
-    gasLimit: bigint;
-    gasPrice: bigint;
-    priority: bigint;
-}>>;
-export type TransactionFeesJsonToBigIntZodType = z.infer<typeof TransactionFeesJsonToBigIntZod>;
-export type TransactionFeesBigIntToJsonZodType = z.infer<typeof TransactionFeesBigIntToJsonZod>;
-//# sourceMappingURL=TransactionFees.d.ts.map

package/dist/node/types/schema/common/TransactionFees.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionFees.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,OAAO,aAAa,CAAA;AACjC,eAAO,MAAM,aAAa,+NAA+C,CAAA;AAEzE,eAAO,MAAM,aAAa,8EAAkB,CAAA;AAE5C,eAAO,MAAM,qBAAqB;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}

package/dist/node/types/schema/common/TransferPair.d.ts

@@ -1,3 +0,0 @@
-import z from 'zod';
-export declare const TransferPairZod: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
-//# sourceMappingURL=TransferPair.d.ts.map

package/dist/node/types/schema/common/TransferPair.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransferPair.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransferPair.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,eAAe,wLAE1B,CAAA"}

package/dist/node/types/schema/common/index.d.ts

@@ -1,16 +0,0 @@
-export * from './ArrayBuffer.ts';
-export * from './BlockBoundWitness.ts';
-export * from './BoundWitness.ts';
-export * from './Chain.ts';
-export * from './HydratedBlock.ts';
-export * from './HydratedTransaction.ts';
-export * from './Json.ts';
-export * from './Permission.ts';
-export * from './RewardsRangeOptions.ts';
-export * from './Sequence.ts';
-export * from './Stake.ts';
-export * from './TimeDomain.ts';
-export * from './TransactionBoundWitness.ts';
-export * from './TransactionFees.ts';
-export * from './TransferPair.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/node/types/schema/common/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA"}

package/src/types/schema/common/ArrayBuffer.ts

@@ -1,42 +0,0 @@
-import * as z from 'zod'
-
-function base64Encode(u8: Uint8Array): string {
-  // Node
-  if (typeof Buffer !== 'undefined' && typeof Buffer.from === 'function') {
-    return Buffer.from(u8).toString('base64')
-  }
-
-  // Browser
-  let binary = ''
-  const chunk = 0x80_00
-  for (let i = 0; i < u8.length; i += chunk) {
-    // eslint-disable-next-line unicorn/prefer-code-point
-    binary += String.fromCharCode(...u8.subarray(i, i + chunk))
-  }
-  return btoa(binary)
-}
-
-/** Base64 decode that works in Node and browsers -> Uint8Array */
-function base64Decode(b64: string): Uint8Array {
-  // Node
-  if (typeof Buffer !== 'undefined' && typeof Buffer.from === 'function') {
-    return new Uint8Array(Buffer.from(b64, 'base64'))
-  }
-
-  // Browser
-  const binary = atob(b64)
-  const u8 = new Uint8Array(binary.length)
-  // eslint-disable-next-line unicorn/prefer-code-point
-  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i)
-  return u8
-}
-
-export const ArrayBufferToJsonZod = z.instanceof(ArrayBuffer).transform((x) => {
-  const u8 = new Uint8Array(x)
-  return base64Encode(u8)
-})
-
-export const JsonToArrayBufferZod = z.string().transform((x) => {
-  const u8 = base64Decode(x)
-  return u8.buffer
-})

package/src/types/schema/common/BlockBoundWitness.ts

@@ -1,36 +0,0 @@
-import { HashZod } from '@xylabs/sdk-js'
-import { StorageMetaZod } from '@xyo-network/payload-model'
-import { XL1BlockNumberZod } from '@xyo-network/xl1-protocol'
-import * as z from 'zod'
-
-import {
-  SignedBoundWitnessZod,
-  UnsignedBoundWitnessZod,
-} from './BoundWitness.ts'
-import { ChainZod } from './Chain.ts'
-
-const BlockBoundWitnessFieldsZod = z.object({
-  block: XL1BlockNumberZod,
-  chain: ChainZod,
-  previous: HashZod.nullable(),
-  protocol: z.number(),
-  step_hashes: z.array(HashZod).optional(),
-})
-
-const BlockBoundWitnessMetaZod = z.object({ $epoch: z.number() })
-
-export const BlockBoundWitnessZod = UnsignedBoundWitnessZod
-// eslint-disable-next-line sonarjs/deprecation
-  .merge(StorageMetaZod.partial())
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(BlockBoundWitnessFieldsZod)
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(BlockBoundWitnessMetaZod)
-
-export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(StorageMetaZod.partial())
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(BlockBoundWitnessFieldsZod)
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(BlockBoundWitnessMetaZod)

package/src/types/schema/common/BoundWitness.ts

@@ -1,56 +0,0 @@
-import {
-  AddressZod, HashZod, HexZod,
-} from '@xylabs/sdk-js'
-import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import {
-  PayloadZod, SchemaZod, StorageMetaZod,
-} from '@xyo-network/payload-model'
-import * as z from 'zod'
-
-const BoundWitnessRequiredFieldsZod = z.object({
-  addresses: z.array(AddressZod),
-  payload_hashes: z.array(HashZod),
-  payload_schemas: z.array(SchemaZod),
-  previous_hashes: z.array(HashZod.nullable()),
-})
-
-const BoundWitnessMetaZod = z.object({
-  $destination: AddressZod.optional(),
-  $sourceQuery: HashZod.optional(),
-  $signatures: z.array(z.union([HexZod, z.null()])),
-})
-
-export const BoundWitnessZod = PayloadZod
-  .extend({ schema: z.literal(BoundWitnessSchema) })
-  .extend(BoundWitnessRequiredFieldsZod.shape)
-  .extend(BoundWitnessMetaZod.shape)
-  .refine(data => data.$signatures.length === data.addresses.length, { message: '$signatures length must equal addresses length' })
-
-export type BoundWitness = z.infer<typeof BoundWitnessZod>
-
-export const AnyBoundWitnessZod = BoundWitnessZod
-  .catchall(z.any())
-
-export type AnyBoundWitness = z.infer<typeof AnyBoundWitnessZod>
-
-export const UnsignedBoundWitnessZod = BoundWitnessZod.refine(data => data.$signatures.includes(null), { message: 'all $signatures must be null' })
-
-export type UnsignedBoundWitness = z.infer<typeof UnsignedBoundWitnessZod>
-
-export const AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod
-  .catchall(z.any())
-
-export type AnyUnsignedBoundWitness = z.infer<typeof AnyUnsignedBoundWitnessZod>
-
-export const UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod
-  .safeExtend(BoundWitnessRequiredFieldsZod.shape)
-  .safeExtend(BoundWitnessMetaZod.shape)
-  .safeExtend(StorageMetaZod.shape)
-
-export const SignedBoundWitnessZod = BoundWitnessZod.refine(data => !data.$signatures.includes(null), { message: 'all $signatures must not be null' })
-
-export const SignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod
-
-export const AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z.any())
-
-export const AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z.any())

package/src/types/schema/common/Chain.ts

@@ -1,5 +0,0 @@
-import { AddressRegEx, toAddress } from '@xylabs/sdk-js'
-import type { ChainId } from '@xyo-network/xl1-protocol'
-import * as z from 'zod'
-
-export const ChainZod = z.string().toLowerCase().regex(AddressRegEx).transform<ChainId>(v => toAddress(v) as ChainId)

package/src/types/schema/common/HydratedBlock.ts

@@ -1,32 +0,0 @@
-import { PayloadZodLoose, WithStorageMetaZod } from '@xyo-network/payload-model'
-import * as z from 'zod'
-
-import {
-  BlockBoundWitnessZod,
-  SignedBlockBoundWitnessZod,
-} from './BlockBoundWitness.ts'
-
-export const HydratedBlockZod = z.tuple([
-  BlockBoundWitnessZod,
-  z.array(PayloadZodLoose),
-])
-
-export const HydratedBlockWithStorageMetaZod = z.tuple([
-  WithStorageMetaZod(BlockBoundWitnessZod),
-  z.array(WithStorageMetaZod(PayloadZodLoose)),
-])
-
-export const SignedHydratedBlockZod = z.tuple([
-  SignedBlockBoundWitnessZod,
-  z.array(PayloadZodLoose),
-])
-
-export const SignedHydratedBlockToJsonZod = z.tuple([
-  SignedBlockBoundWitnessZod,
-  z.array(PayloadZodLoose),
-])
-
-export const SignedHydratedBlockWithStorageMetaZod = z.tuple([
-  WithStorageMetaZod(SignedBlockBoundWitnessZod),
-  z.array(WithStorageMetaZod(PayloadZodLoose)),
-])

package/src/types/schema/common/HydratedTransaction.ts

@@ -1,37 +0,0 @@
-import type { JsonObject } from '@xylabs/sdk-js'
-import { asAnyPayload, PayloadZodLoose } from '@xyo-network/payload-model'
-import { asSignedHydratedTransaction } from '@xyo-network/xl1-protocol'
-import * as z from 'zod'
-
-import { SignedTransactionBoundWitnessZod, TransactionBoundWitnessZod } from './TransactionBoundWitness.ts'
-
-export const HydratedTransactionZod = z.tuple([
-  TransactionBoundWitnessZod,
-  z.array(PayloadZodLoose),
-])
-
-export const UnsignedHydratedTransactionZod = z.tuple([
-  TransactionBoundWitnessZod,
-  z.array(PayloadZodLoose),
-])
-
-export const SignedHydratedTransactionZod = z.tuple([
-  SignedTransactionBoundWitnessZod,
-  z.array(PayloadZodLoose),
-])
-
-export const SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([
-  tx,
-  payloads,
-]) => asSignedHydratedTransaction([
-  tx as JsonObject,
-  payloads.map(payload => payload as JsonObject),
-]))
-
-export const JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(([
-  tx,
-  payloads,
-]) => ([
-  asSignedHydratedTransaction(tx),
-  payloads.map(p => asAnyPayload(p)),
-]))

package/src/types/schema/common/Json.ts

@@ -1,19 +0,0 @@
-import * as z from 'zod'
-
-// Define recursive JSON value schema
-const JsonValueZod: z.ZodType<unknown> = z.lazy(() =>
-  z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(JsonValueZod),
-    z.record(z.string(), JsonValueZod), // object with string keys and JSON values
-  ]))
-
-// JSON object schema — top-level must be an object
-export const JsonObjectZod = z.record(z.string(), JsonValueZod)
-
-// TypeScript type for reference
-export type JsonValue = z.infer<typeof JsonValueZod>
-export type JsonObject = z.infer<typeof JsonObjectZod>

package/src/types/schema/common/Permission.ts

@@ -1,23 +0,0 @@
-import { z } from 'zod'
-
-export const CaveatTypesZod = z.enum(['chain', 'expiration', 'filteredResponse', 'rateLimit', 'restrictReturnedAccounts'])
-
-export const CaveatsZod = z.object({
-  type: CaveatTypesZod,
-  value: z.json(),
-})
-
-export const PermissionZod = z.object({
-  parentCapability: z.string(),
-  caveats: CaveatsZod.array().optional(),
-  invoker: z.string(),
-})
-
-export const InvokerPermissionZod = PermissionZod.extend({ date: z.number().optional() })
-
-export const PermissionRequestZod = z.record(z.string(), z.record(z.string(), z.any()))
-
-export const RequestedPermissionZod = z.object({
-  parentCapability: z.string(),
-  date: z.number().optional(),
-})

package/src/types/schema/common/RewardsRangeOptions.ts

@@ -1,10 +0,0 @@
-import { AddressZod } from '@xylabs/sdk-js'
-import { BlockRangeZod, StepIdentityZod } from '@xyo-network/xl1-protocol'
-import { z } from 'zod'
-
-export const RewardsRangeOptionsZod = z.object({
-  positions: z.array(z.number()).optional(),
-  range: BlockRangeZod.optional(),
-  steps: z.array(StepIdentityZod).optional(),
-  stakers: z.array(AddressZod).optional(),
-})

package/src/types/schema/common/Sequence.ts

@@ -1,15 +0,0 @@
-import { HexRegExMinMax, toHex } from '@xylabs/sdk-js'
-import type { LocalSequence, QualifiedSequence } from '@xyo-network/payload-model'
-import { SequenceConstants } from '@xyo-network/payload-model'
-import * as z from 'zod'
-
-const LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes))
-export const LocalSequenceToStringZod = z.string().regex(LocalSequenceRegex)
-export const LocalSequenceFromStringZod = z.string().regex(LocalSequenceRegex).transform<LocalSequence>(v => toHex(v) as LocalSequence)
-
-const QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes))
-export const QualifiedSequenceToStringZod = z.string().regex(QualifiedSequenceRegex)
-export const QualifiedSequenceFromStringZod = z.string().regex(QualifiedSequenceRegex).transform<QualifiedSequence>(v => toHex(v) as QualifiedSequence)
-
-export const SequenceToStringZod = z.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod])
-export const SequenceFromStringZod = z.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod])