@algorandfoundation/algorand-typescript 0.0.1-alpha.1

package/op.d.ts

@@ -0,0 +1,55 @@
+import { AddwType, BalanceType, Base64DecodeType, BitLengthType, BsqrtType, BtoiType, BzeroType, ConcatType, DivmodwType, DivwType, EcdsaPkDecompressType, EcdsaPkRecoverType, EcdsaVerifyType, Ed25519verifyBareType, Ed25519verifyType, EllipticCurveType, ExpType, ExpwType, ExtractType, ExtractUint16Type, ExtractUint32Type, ExtractUint64Type, GaidType, GetBitType, GetByteType, GITxnType, GlobalType, GTxnType, ItobType, ITxnCreateType, ITxnType, JsonRefType, Keccak256Type, MulwType, ReplaceType, ScratchType, SelectType, SetBitType, SetByteType, Sha256Type, Sha3_256Type, Sha512_256Type, ShlType, ShrType, SqrtType, SubstringType, TxnType, VrfVerifyType } from './op-types';
+export declare const addw: AddwType;
+export declare const balance: BalanceType;
+export declare const base64Decode: Base64DecodeType;
+export declare const bitLength: BitLengthType;
+export declare const bsqrt: BsqrtType;
+export declare const btoi: BtoiType;
+export declare const bzero: BzeroType;
+export declare const concat: ConcatType;
+export declare const divmodw: DivmodwType;
+export declare const divw: DivwType;
+export declare const ecdsaPkDecompress: EcdsaPkDecompressType;
+export declare const ecdsaPkRecover: EcdsaPkRecoverType;
+export declare const ecdsaVerify: EcdsaVerifyType;
+export declare const ed25519verifyBare: Ed25519verifyBareType;
+export declare const ed25519verify: Ed25519verifyType;
+export declare const exp: ExpType;
+export declare const expw: ExpwType;
+export declare const extract: ExtractType;
+export declare const extractUint16: ExtractUint16Type;
+export declare const extractUint32: ExtractUint32Type;
+export declare const extractUint64: ExtractUint64Type;
+export declare const gaid: GaidType;
+export declare const getBit: GetBitType;
+export declare const getByte: GetByteType;
+export declare const itob: ItobType;
+export declare const keccak256: Keccak256Type;
+export declare const minBalance: BalanceType;
+export declare const mulw: MulwType;
+export declare const replace: ReplaceType;
+export declare const select: SelectType;
+export declare const setBit: SetBitType;
+export declare const setByte: SetByteType;
+export declare const sha256: Sha256Type;
+export declare const sha3_256: Sha3_256Type;
+export declare const sha512_256: Sha512_256Type;
+export declare const shl: ShlType;
+export declare const shr: ShrType;
+export declare const sqrt: SqrtType;
+export declare const substring: SubstringType;
+export declare const vrfVerify: VrfVerifyType;
+export declare const EllipticCurve: EllipticCurveType;
+export declare const Global: GlobalType;
+export declare const GTxn: GTxnType;
+export declare const JsonRef: JsonRefType;
+export declare const Txn: TxnType;
+export declare const GITxn: GITxnType;
+export declare const ITxn: ITxnType;
+export declare const ITxnCreate: ITxnCreateType;
+export declare const Scratch: ScratchType;
+export declare const AcctParams: import("./op-types").AcctParamsType;
+export declare const AppParams: import("./op-types").AppParamsType;
+export declare const AssetHolding: import("./op-types").AssetHoldingType;
+export declare const AssetParams: import("./op-types").AssetParamsType;
+export { VrfVerify } from './op-types';

package/package.json

@@ -0,0 +1,32 @@
+{
+  "scripts": {},
+  "files": [
+    "**"
+  ],
+  "name": "@algorandfoundation/algorand-typescript",
+  "version": "0.0.1-alpha.1",
+  "description": "",
+  "private": false,
+  "overrides": {
+    "micromatch": "4.0.8"
+  },
+  "peerDependencies": {
+    "tslib": "^2.6.2"
+  },
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js"
+    },
+    "./arc4": {
+      "types": "./arc4/index.d.ts",
+      "import": "./arc4/index.mjs",
+      "require": "./arc4/index.js"
+    }
+  }
+}

package/primitives.d.ts

@@ -0,0 +1,55 @@
+export type Uint64Compat = uint64 | bigint | boolean | number;
+export type BigUintCompat = Uint64Compat | bigint | bytes | number;
+export type StringCompat = string;
+export type BytesCompat = bytes | string | Uint8Array;
+/**
+ * An unsigned integer of exactly 64 bits
+ */
+export type uint64 = {
+    __type?: 'uint64';
+} & number;
+/**
+ * Create a uint64 value
+ * @param v The value to use
+ */
+export declare function Uint64(v: bigint): uint64;
+export declare function Uint64(v: number): uint64;
+export declare function Uint64(v: boolean): uint64;
+/**
+ * An unsigned integer of up to 512 bits
+ *
+ * Stored as a big-endian variable byte array
+ */
+export type biguint = {
+    __type?: 'biguint';
+} & bigint;
+/**
+ * Create a biguint value
+ * @param v The value to use
+ */
+export declare function BigUint(v: bigint): biguint;
+export declare function BigUint(v: boolean): biguint;
+export declare function BigUint(v: number): biguint;
+export declare function BigUint(v: bytes): biguint;
+export type bytes = {
+    readonly length: uint64;
+    at(i: Uint64Compat): bytes;
+    concat(other: BytesCompat): bytes;
+    bitwiseAnd(other: BytesCompat): bytes;
+    bitwiseOr(other: BytesCompat): bytes;
+    bitwiseXor(other: BytesCompat): bytes;
+    bitwiseInvert(): bytes;
+    equals(other: BytesCompat): boolean;
+    toString(): string;
+};
+export declare function Bytes(value: TemplateStringsArray, ...replacements: BytesCompat[]): bytes;
+export declare function Bytes(value: BytesCompat): bytes;
+export declare function Bytes(): bytes;
+export declare namespace Bytes {
+    var fromHex: (hex: string) => bytes;
+    var fromBase64: (b64: string) => bytes;
+    var fromBase32: (b32: string) => bytes;
+}
+export interface BytesBacked {
+    get bytes(): bytes;
+}

package/reference.d.ts

@@ -0,0 +1,207 @@
+import { bytes, uint64 } from './primitives';
+export type Account = {
+    readonly bytes: bytes;
+    /**
+     * Account balance in microalgos
+     *
+     * Account must be an available resource
+     */
+    readonly balance: uint64;
+    /**
+     * Minimum required balance for account, in microalgos
+     *
+     * Account must be an available resource
+     */
+    readonly minBalance: uint64;
+    /**
+     * Address the account is rekeyed to
+     *
+     * Account must be an available resource
+     */
+    readonly authAddress: Account;
+    /**
+     * The total number of uint64 values allocated by this account in Global and Local States.
+     *
+     * Account must be an available resource
+     */
+    readonly totalNumUint: uint64;
+    /**
+     * The total number of byte array values allocated by this account in Global and Local States.
+     *
+     * Account must be an available resource
+     */
+    readonly totalNumByteSlice: uint64;
+    /**
+     * The number of extra app code pages used by this account.
+     *
+     * Account must be an available resource
+     */
+    readonly totalExtraAppPages: uint64;
+    /**
+     * The number of existing apps created by this account.
+     *
+     * Account must be an available resource
+     */
+    readonly totalAppsCreated: uint64;
+    /**
+     * The number of apps this account is opted into.
+     *
+     * Account must be an available resource
+     */
+    readonly totalAppsOptedIn: uint64;
+    /**
+     * The number of existing ASAs created by this account.
+     *
+     * Account must be an available resource
+     */
+    readonly totalAssetsCreated: uint64;
+    /**
+     * The numbers of ASAs held by this account (including ASAs this account created).
+     *
+     * Account must be an available resource
+     */
+    readonly totalAssets: uint64;
+    /**
+     * The number of existing boxes created by this account's app.
+     *
+     * Account must be an available resource
+     */
+    readonly totalBoxes: uint64;
+    /**
+     * The total number of bytes used by this account's app's box keys and values.
+     *
+     * Account must be an available resource
+     */
+    readonly totalBoxBytes: uint64;
+    /**
+     * Returns true if this account is opted in to the specified Asset or Application.
+     * Note: Account and Asset/Application must be an available resource
+     *
+     * @param assetOrApp
+     */
+    isOptedIn(assetOrApp: Asset | Application): boolean;
+};
+export declare function Account(): Account;
+export declare function Account(address: bytes): Account;
+export declare function Asset(): Asset;
+export declare function Asset(assetId: uint64): Asset;
+/**
+ * An Asset on the Algorand network.
+ */
+export type Asset = {
+    /**
+     * Returns the id of the Asset
+     */
+    readonly id: uint64;
+    /**
+     * Total number of units of this asset
+     */
+    readonly total: uint64;
+    /**
+     * @see AssetParams.Decimals
+     */
+    readonly decimals: uint64;
+    /**
+     * Frozen by default or not
+     */
+    readonly defaultFrozen: boolean;
+    /**
+     * Asset unit name
+     */
+    readonly unitName: bytes;
+    /**
+     * Asset name
+     */
+    readonly name: bytes;
+    /**
+     * URL with additional info about the asset
+     */
+    readonly url: bytes;
+    /**
+     * Arbitrary commitment
+     */
+    readonly metadataHash: bytes;
+    /**
+     * Manager address
+     */
+    readonly manager: Account;
+    /**
+     * Reserve address
+     */
+    readonly reserve: Account;
+    /**
+     * Freeze address
+     */
+    readonly freeze: Account;
+    /**
+     * Clawback address
+     */
+    readonly clawback: Account;
+    /**
+     * Creator address
+     */
+    readonly creator: Account;
+    /**
+     * Amount of the asset unit held by this account. Fails if the account has not
+     * opted in to the asset.
+     * Asset and supplied Account must be an available resource
+     * @param account Account
+     * @return balance: uint64
+     */
+    balance(account: Account): uint64;
+    /**
+     * Is the asset frozen or not. Fails if the account has not
+     * opted in to the asset.
+     * Asset and supplied Account must be an available resource
+     * @param account Account
+     * @return isFrozen: boolean
+     */
+    frozen(account: Account): boolean;
+};
+export declare function Application(): Application;
+export declare function Application(applicationId: uint64): Application;
+/**
+ * An Application on the Algorand network.
+ */
+export type Application = {
+    /**
+     * The id of this application on the current network
+     */
+    readonly id: uint64;
+    /**
+     * Bytecode of Approval Program
+     */
+    readonly approvalProgram: bytes;
+    /**
+     * Bytecode of Clear State Program
+     */
+    readonly clearStateProgram: bytes;
+    /**
+     * Number of uint64 values allowed in Global State
+     */
+    readonly globalNumUint: uint64;
+    /**
+     * Number of byte array values allowed in Global State
+     */
+    readonly globalNumBytes: uint64;
+    /**
+     * Number of uint64 values allowed in Local State
+     */
+    readonly localNumUint: uint64;
+    /**
+     * Number of byte array values allowed in Local State
+     */
+    readonly localNumBytes: uint64;
+    /**
+     * Number of Extra Program Pages of code space
+     */
+    readonly extraProgramPages: uint64;
+    /**
+     * Creator address
+     */
+    readonly creator: Account;
+    /**
+     * Address for which this application has authority
+     */
+    readonly address: Account;
+};

package/state.d.ts

@@ -0,0 +1,28 @@
+import { bytes } from './primitives';
+import { Account } from './reference';
+/** A value saved in global state */
+export type GlobalState<ValueType> = {
+    value: ValueType;
+    delete: () => void;
+    hasValue: boolean;
+};
+type GlobalStateOptions<ValueType> = {
+    key?: bytes | string;
+    initialValue?: ValueType;
+};
+/** A single key in global state */
+export declare function GlobalState<ValueType>(options?: GlobalStateOptions<ValueType>): GlobalState<ValueType>;
+/** A value saved in local state */
+export type LocalStateForAccount<ValueType> = {
+    value: ValueType;
+    hasValue: boolean;
+    delete: () => void;
+};
+export type LocalState<ValueType> = {
+    (account: Account): LocalStateForAccount<ValueType>;
+};
+/** A single key in local state */
+export declare function LocalState<ValueType>(options?: {
+    key?: bytes | string;
+}): LocalState<ValueType>;
+export {};